From 719f789cebec004b350153e1f001303d6713f4a6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Gustavsson?= <bjorn@erlang.org>
Date: Thu, 17 Oct 2013 15:22:49 +0200
Subject: Fix complicated union of INTEGER constraints

A constraint that was an union of integer ranges:

   Type ::= INTEGER (lb1..ub1 | ... | lbN..ubN)

would sometimes (depending on the values) not all always be properly
combined to a single effective range, but would become:

   Type ::= INTEGER (lb2..ub2) (lb3..ub3)

If that type was used in a SEQUENCE:

   S ::= SEQUENCE {
           v Type
         }

the constraint would be simplified, taking the intersection of the
ranges.
---
 lib/asn1/src/asn1ct_check.erl                | 46 +++++-----------------------
 lib/asn1/test/asn1_SUITE_data/Constraints.py | 40 ++++++++++++++++++++++++
 lib/asn1/test/testConstraints.erl            | 18 +++++++++++
 3 files changed, 65 insertions(+), 39 deletions(-)

(limited to 'lib/asn1')

diff --git a/lib/asn1/src/asn1ct_check.erl b/lib/asn1/src/asn1ct_check.erl
index eddcda0018..feddda4228 100644
--- a/lib/asn1/src/asn1ct_check.erl
+++ b/lib/asn1/src/asn1ct_check.erl
@@ -4229,9 +4229,10 @@ constraint_union(S,C) when is_list(C) ->
 constraint_union(_S,C) ->
     [C].
 
-constraint_union1(S,[A={'ValueRange',_},union,B={'ValueRange',_}|Rest],Acc) ->
-    AunionB = constraint_union_vr([A,B]),
-    constraint_union1(S, AunionB++Rest, Acc);
+constraint_union1(S, [{'ValueRange',{Lb1,Ub1}},union,
+		      {'ValueRange',{Lb2,Ub2}}|Rest], Acc) ->
+    AunionB = {'ValueRange',{c_min(Lb1, Lb2),max(Ub1, Ub2)}},
+    constraint_union1(S,  [AunionB|Rest], Acc);
 constraint_union1(S,[A={'SingleValue',_},union,B={'SingleValue',_}|Rest],Acc) ->
     AunionB = constraint_union_sv(S,[A,B]),
     constraint_union1(S,Rest,Acc ++ AunionB);
@@ -4255,42 +4256,9 @@ constraint_union_sv(_S,SV) ->
 	[N] -> [{'SingleValue',N}];
 	L -> [{'SingleValue',L}]
     end.
-
-%% REMOVE????
-%%constraint_union(S,VR,'ValueRange') ->
-%%    constraint_union_vr(VR).
-
-%% constraint_union_vr(VR)
-%% VR = [{'ValueRange',{Lb,Ub}},...]
-%% Lb = 'MIN' | integer()
-%% Ub = 'MAX' | integer()
-%% Returns if possible only one ValueRange tuple with a range that
-%% is a union of all ranges in VR.
-constraint_union_vr(VR) ->
-    %% Sort VR by Lb in first hand and by Ub in second hand
-    Fun=fun({_,{'MIN',_B1}},{_,{A2,_B2}}) when is_integer(A2)->true;
-	   ({_,{A1,_B1}},{_,{'MAX',_B2}}) when is_integer(A1) -> true;
-	   ({_,{A1,_B1}},{_,{A2,_B2}}) when is_integer(A1),is_integer(A2),A1<A2 -> true;
-	   ({_,{A,B1}},{_,{A,B2}}) when B1=<B2->true;
-	   (_,_)->false end,
-    SortedVR = lists:usort(Fun,VR),
-    constraint_union_vr(SortedVR, []).
-
-constraint_union_vr([],Acc) ->
-    lists:reverse(Acc);
-constraint_union_vr([C|Rest],[]) ->
-    constraint_union_vr(Rest,[C]);
-constraint_union_vr([{_,{Lb,Ub2}}|Rest],[{_,{Lb,_Ub1}}|Acc]) -> %Ub2 > Ub1
-    constraint_union_vr(Rest,[{'ValueRange',{Lb,Ub2}}|Acc]);
-constraint_union_vr([{_,{_,Ub}}|Rest],A=[{_,{_,Ub}}|_Acc]) ->
-    constraint_union_vr(Rest,A);
-constraint_union_vr([{_,{Lb2,Ub2}}|Rest], [{_,{Lb1,Ub1}}|Acc])
-  when Ub1 =< Lb2, Ub1 < Ub2 ->
-    constraint_union_vr(Rest,[{'ValueRange',{Lb1,Ub2}}|Acc]);
-constraint_union_vr([{_,{_,Ub2}}|Rest],A=[{_,{_,Ub1}}|_Acc]) when Ub2=<Ub1->
-    constraint_union_vr(Rest,A);
-constraint_union_vr([VR|Rest],Acc) ->
-    constraint_union_vr(Rest,[VR|Acc]).
+c_min('MIN', _) -> 'MIN';
+c_min(_, 'MIN') -> 'MIN';
+c_min(A, B) -> min(A, B).
 
 union_sv_vr(_S,{'SingleValue',SV},VR) 
   when is_integer(SV) ->
diff --git a/lib/asn1/test/asn1_SUITE_data/Constraints.py b/lib/asn1/test/asn1_SUITE_data/Constraints.py
index e4bc987e4c..fcc8e4da31 100644
--- a/lib/asn1/test/asn1_SUITE_data/Constraints.py
+++ b/lib/asn1/test/asn1_SUITE_data/Constraints.py
@@ -94,4 +94,44 @@ pdf OBJECT IDENTIFIER ::= {1,2,3,4,5}
 
 ShorterExt ::= IA5String (SIZE (5, ...))
 
+SeqOverlapping ::= SEQUENCE {
+    v Overlapping
+}
+
+SeqNonOverlapping ::= SEQUENCE {
+    v NonOverlapping
+}
+
+Overlapping ::= INTEGER (7280..7560 |
+7580..7680 |
+7910..8210 |
+8600..8940 |
+9250..9600 |
+14759..15109 |
+15250..15590 |
+18050..18800 |
+19300..19950 |
+21100..21700 |
+26200..26900 |
+18500..19900 |
+20100..20250 |
+21100..21700 |
+23000..24000 |
+24960..26900)
+
+-- The same intervals, but merged and sorted --
+NonOverlapping ::= INTEGER (7280..7560 |
+7580..7680 |
+7910..8210 |
+8600..8940 |
+9250..9600 |
+14759..15109 |
+15250..15590 |
+18050..19950 |
+20100..20250 |
+21100..21700 |
+23000..24000 |
+24960..26900)
+
+
 END
diff --git a/lib/asn1/test/testConstraints.erl b/lib/asn1/test/testConstraints.erl
index 03a09492af..0c6653ccd9 100644
--- a/lib/asn1/test/testConstraints.erl
+++ b/lib/asn1/test/testConstraints.erl
@@ -182,6 +182,15 @@ int_constraints(Rules) ->
     roundtrip('ShorterExt', "abcde"),
     roundtrip('ShorterExt', "abcdef"),
 
+    %%==========================================================
+    %%  Unions of INTEGER constraints
+    %%==========================================================
+    seq_roundtrip(Rules, 'SeqOverlapping', 'SeqNonOverlapping', 7580),
+    seq_roundtrip(Rules, 'SeqOverlapping', 'SeqNonOverlapping', 9600),
+    seq_roundtrip(Rules, 'SeqOverlapping', 'SeqNonOverlapping', 18050),
+    seq_roundtrip(Rules, 'SeqOverlapping', 'SeqNonOverlapping', 19000),
+    seq_roundtrip(Rules, 'SeqOverlapping', 'SeqNonOverlapping', 26900),
+
     ok.
 
 %% PER: Ensure that if the lower bound is Lb, Lb+16#80 is encoded
@@ -240,3 +249,12 @@ range_error(Per, Type, Value) when Per =:= per; Per =:= uper ->
     %% on encode.
     {error,_} = 'Constraints':encode(Type, Value),
     ok.
+
+seq_roundtrip(Rules, Seq1, Seq2, Val) ->
+    Enc = roundtrip(Seq1, {Seq1,Val}),
+    case Rules of
+	ber ->
+	    roundtrip(Seq2, {Seq2,Val});
+	_ ->
+	    roundtrip_enc(Seq2, {Seq2,Val}, Enc)
+    end.
-- 
cgit v1.2.3