18 files changed, 690 insertions, 261 deletions

diff --git a/lib/asn1/src/Makefile b/lib/asn1/src/Makefile
index 3f24e15c04..500f4a1358 100644
--- a/lib/asn1/src/Makefile
+++ b/lib/asn1/src/Makefile
@@ -135,7 +135,7 @@ $(EBIN)/asn1ct_func.$(EMULATOR): asn1ct_func.erl
 
 asn1ct_eval_%.erl: asn1ct_eval_%.funcs
 	$(gen_verbose)erl -pa $(EBIN) -noshell -noinput \
-	   -run prepare_templates gen_asn1ct_eval $< >$@
+	   -run prepare_templates gen_asn1ct_eval $<
 
 $(APP_TARGET): $(APP_SRC) ../vsn.mk
 	$(vsn_verbose)sed -e 's;%VSN%;$(VSN);' $< > $@
@@ -180,7 +180,7 @@ RT_TEMPLATES_TARGET = $(RT_TEMPLATES:%=%.$(EMULATOR))
 
 asn1ct_rtt.erl: prepare_templates.$(EMULATOR) $(RT_TEMPLATES_TARGET)
 	$(gen_verbose)erl -noshell -noinput -run prepare_templates gen_asn1ct_rtt \
-           $(RT_TEMPLATES_TARGET) >asn1ct_rtt.erl
+           $(RT_TEMPLATES_TARGET)
 
 prepare_templates.$(EMULATOR): prepare_templates.erl
 	$(V_ERLC) prepare_templates.erl
diff --git a/lib/asn1/src/asn1ct_check.erl b/lib/asn1/src/asn1ct_check.erl
index eddcda0018..0a13801e08 100644
--- a/lib/asn1/src/asn1ct_check.erl
+++ b/lib/asn1/src/asn1ct_check.erl
@@ -2534,89 +2534,54 @@ normalize_integer(S,Int=#'Externalvaluereference'{value=Name},Type) ->
 normalize_integer(_,Int,_) ->
     exit({'Unknown INTEGER value',Int}).
 
-normalize_bitstring(S,Value,Type)->
-    %% There are four different Erlang formats of BIT STRING:
-    %% 1 - a list of ones and zeros.
-    %% 2 - a list of atoms.
-    %% 3 - as an integer, for instance in hexadecimal form.
-    %% 4 - as a tuple {Unused, Binary} where Unused is an integer
-    %%   and tells how many bits of Binary are unused.
-    %% 
-    %% normalize_bitstring/3 transforms Value according to:
-    %% A to 3,
-    %% B to 1,
-    %% C to 1 or 3
-    %% D to 2,
-    %% Value can be on format:
-    %% A - {hstring, String}, where String is a hexadecimal string.
-    %% B - {bstring, String}, where String is a string on bit format
-    %% C - #'Externalvaluereference'{value=V}, where V is a defined value
-    %% D - list of #'Externalvaluereference', where each value component
-    %%     is an identifier corresponing to NamedBits in Type.
-    %% E - list of ones and zeros, if Value already is normalized.
+%% normalize_bitstring(S, Value, Type) -> bitstring()
+%%  Convert a literal value for a BIT STRING to an Erlang bit string.
+%%
+normalize_bitstring(S, Value, Type)->
     case Value of
 	{hstring,String} when is_list(String) ->
-	    hstring_to_int(String);
+	    hstring_to_bitstring(String);
 	{bstring,String} when is_list(String) ->
-	    bstring_to_bitlist(String);
-	Rec when is_record(Rec,'Externalvaluereference') ->
-	    get_normalized_value(S,Value,Type,
-				 fun normalize_bitstring/3,[]);
+	    bstring_to_bitstring(String);
+	#'Externalvaluereference'{} ->
+	    get_normalized_value(S, Value, Type,
+				 fun normalize_bitstring/3, []);
 	RecList when is_list(RecList) ->
-	    case Type of
-		NBL when is_list(NBL) ->
-		    F = fun(#'Externalvaluereference'{value=Name}) ->
-				case lists:keysearch(Name,1,NBL) of
-				    {value,{Name,_}} ->
-					Name;
-				    Other ->
-					throw({error,Other})
-				end;
-			   (I) when I =:= 1; I =:= 0 ->
-				I;
-			   (Other) ->
-				throw({error,Other})
-			end,
-		    case catch lists:map(F,RecList) of
-			{error,Reason} ->
-			    asn1ct:warning("default value not "
-					   "compatible with type definition ~p~n",
-					   [Reason],S,
-					   "default value not "
-					   "compatible with type definition"),
-			    Value;
-			NewList ->
-			    NewList
-		    end;
-		_ ->
+	    F = fun(#'Externalvaluereference'{value=Name}) ->
+			case lists:keymember(Name, 1, Type) of
+			    true -> Name;
+			    false -> throw({error,false})
+			end;
+		   (Name) when is_atom(Name) ->
+			%% Already normalized.
+			Name;
+		   (Other) ->
+			throw({error,Other})
+		end,
+	    try
+		lists:map(F, RecList)
+	    catch
+		throw:{error,Reason} ->
 		    asn1ct:warning("default value not "
 				   "compatible with type definition ~p~n",
-				   [RecList],S,
+				   [Reason],S,
 				   "default value not "
 				   "compatible with type definition"),
 		    Value
 	    end;
-	{Name,String} when is_atom(Name) ->
-	    normalize_bitstring(S,String,Type);
-	Other ->
-	    asn1ct:warning("illegal default value ~p~n",[Other],S,
-			   "illegal default value"),
-	    Value
+	Bs when is_bitstring(Bs) ->
+	    %% Already normalized.
+	    Bs
     end.
 
-hstring_to_int(L) when is_list(L) ->
-    hstring_to_int(L,0).
-hstring_to_int([H|T],Acc) when H >= $A, H =< $F ->
-    hstring_to_int(T,(Acc bsl 4) + (H - $A + 10) ) ;
-hstring_to_int([H|T],Acc) when H >= $0, H =< $9 ->
-    hstring_to_int(T,(Acc bsl 4) + (H - $0));
-hstring_to_int([],Acc) ->
-    Acc.
+hstring_to_bitstring(L) ->
+    << <<(hex_to_int(D)):4>> || D <- L >>.
 
-bstring_to_bitlist([H|T]) when H == $0; H == $1 ->
-    [H - $0 | bstring_to_bitlist(T)];
-bstring_to_bitlist([]) ->
-    [].
+bstring_to_bitstring(L) ->
+    << <<(D-$0):1>> || D <- L >>.
+
+hex_to_int(D) when $0 =< D, D =< $9 -> D - $0;
+hex_to_int(D) when $A =< D, D =< $F -> D - ($A - 10).
 
 %% normalize_octetstring/1 changes representation of input Value to a 
 %% list of octets.
@@ -4229,9 +4194,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 +4221,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/src/asn1ct_constructed_ber_bin_v2.erl b/lib/asn1/src/asn1ct_constructed_ber_bin_v2.erl
index 8359b81b33..a38da8bcc2 100644
--- a/lib/asn1/src/asn1ct_constructed_ber_bin_v2.erl
+++ b/lib/asn1/src/asn1ct_constructed_ber_bin_v2.erl
@@ -1155,7 +1155,8 @@ gen_dec_line(Erules,TopType,Cname,CTags,Type,OptOrMand,DecObjInf)  ->
 		
 		emit([indent(4),"_ ->",nl]),
 		case OptOrMand of
-		    {'DEFAULT', Def} ->
+		    {'DEFAULT', Def0} ->
+			Def = asn1ct_gen:conform_value(Type, Def0),
 			emit([indent(8),"{",{asis,Def},",",{prev,tlv},"}",nl]);
 		    'OPTIONAL' ->
 			emit([indent(8),"{ asn1_NOVALUE, ",{prev,tlv},"}",nl])
diff --git a/lib/asn1/src/asn1ct_constructed_per.erl b/lib/asn1/src/asn1ct_constructed_per.erl
index 8d4afc0a0b..4672f7edd3 100644
--- a/lib/asn1/src/asn1ct_constructed_per.erl
+++ b/lib/asn1/src/asn1ct_constructed_per.erl
@@ -770,8 +770,10 @@ optionals(L) -> optionals(L,[],2).
 
 optionals([#'ComponentType'{prop='OPTIONAL'}|Rest], Acc, Pos) ->
     optionals(Rest, [Pos|Acc], Pos+1);
-optionals([#'ComponentType'{prop={'DEFAULT',Val}}|Rest], Acc, Pos) ->
-    optionals(Rest, [{Pos,Val}|Acc], Pos+1);
+optionals([#'ComponentType'{typespec=T,prop={'DEFAULT',Val}}|Rest],
+	  Acc, Pos) ->
+    Vals = def_values(T, Val),
+    optionals(Rest, [{Pos,Vals}|Acc], Pos+1);
 optionals([#'ComponentType'{}|Rest], Acc, Pos) ->
     optionals(Rest, Acc, Pos+1);
 optionals([], Acc, _) ->
@@ -888,7 +890,8 @@ gen_enc_components_call1(Erule,TopType,
 	       optional ->
 		   asn1ct_imm:enc_absent(Element, [asn1_NOVALUE], Imm1);
 	       {default,Def} ->
-		   asn1ct_imm:enc_absent(Element, [asn1_DEFAULT,Def], Imm1)
+		   DefValues = def_values(Type, Def),
+		   asn1ct_imm:enc_absent(Element, DefValues, Imm1)
 	   end,
     Imm = case Imm2 of
 	      [] -> [];
@@ -899,6 +902,38 @@ gen_enc_components_call1(_Erule,_TopType,[],Pos,_,_, Acc) ->
     ImmList = lists:reverse(Acc),
     {ImmList,Pos}.
 
+def_values(#type{def=#'Externaltypereference'{module=Mod,type=Type}}, Def) ->
+    #typedef{typespec=T} = asn1_db:dbget(Mod, Type),
+    def_values(T, Def);
+def_values(#type{def={'BIT STRING',[]}}, Bs) when is_bitstring(Bs) ->
+    ListBs = [B || <<B:1>> <= Bs],
+    IntBs = lists:foldl(fun(B, A) ->
+				(A bsl 1) bor B
+			end, 0, lists:reverse(ListBs)),
+    Sz = bit_size(Bs),
+    Compact = case 8 - Sz rem 8 of
+		  8 ->
+		      {0,Bs};
+		  Unused ->
+		      {Unused,<<Bs:Sz/bits,0:Unused>>}
+	      end,
+    [asn1_DEFAULT,Bs,Compact,ListBs,IntBs];
+def_values(#type{def={'BIT STRING',[_|_]=Ns}}, List) when is_list(List) ->
+    Bs = asn1ct_gen:named_bitstring_value(List, Ns),
+    ListBs = [B || <<B:1>> <= Bs],
+    IntBs = lists:foldl(fun(B, A) ->
+				(A bsl 1) bor B
+			end, 0, lists:reverse(ListBs)),
+    Args = [List,Bs,ListBs,IntBs],
+    {call,per_common,is_default_bitstring,Args};
+def_values(#type{def={'INTEGER',Ns}}, Def) ->
+    [asn1_DEFAULT,Def|case lists:keyfind(Def, 2, Ns) of
+			  false -> [];
+			  {Val,Def} -> [Val]
+		      end];
+def_values(_, Def) ->
+    [asn1_DEFAULT,Def].
+
 gen_enc_line_imm(Erule, TopType, Cname, Type, Element, DynamicEnc, Ext) ->
     Imm0 = gen_enc_line_imm_1(Erule, TopType, Cname, Type,
 			      Element, DynamicEnc),
@@ -1207,7 +1242,8 @@ gen_dec_comp_call(Comp, Erule, TopType, Tpos, OptTable, DecInfObj,
 
 comp_call_pre_post(noext, mandatory, _, _, _, _, _, _) ->
     {[],[]};
-comp_call_pre_post(noext, Prop, _, _, TextPos, OptTable, NumOptionals, Ext) ->
+comp_call_pre_post(noext, Prop, _, Type, TextPos,
+		   OptTable, NumOptionals, Ext) ->
     %% OPTIONAL or DEFAULT
     OptPos = get_optionality_pos(TextPos, OptTable),
     Element = case NumOptionals - OptPos of
@@ -1225,7 +1261,7 @@ comp_call_pre_post(noext, Prop, _, _, TextPos, OptTable, NumOptionals, Ext) ->
 	      emit([";",nl,
 		    "0 ->",nl,
 		    "{"]),
-	      gen_dec_component_no_val(Ext, Prop),
+	      gen_dec_component_no_val(Ext, Type, Prop),
 	      emit([",",{curr,bytes},"}",nl,
 		    "end"]),
 	      St
@@ -1247,10 +1283,10 @@ comp_call_pre_post({ext,_,_}, Prop, Pos, Type, _, _, _, Ext) ->
 			       components=ExtGroupCompList2}}
 		    when is_integer(Number2)->
 		      emit("{extAddGroup,"),
-		      gen_dec_extaddGroup_no_val(Ext, ExtGroupCompList2),
+		      gen_dec_extaddGroup_no_val(Ext, Type, ExtGroupCompList2),
 		      emit("}");
 		  _ ->
-		      gen_dec_component_no_val(Ext, Prop)
+		      gen_dec_component_no_val(Ext, Type, Prop)
 	      end,
 	      emit([",",{curr,bytes},"}",nl,
 		    "end"]),
@@ -1265,21 +1301,22 @@ is_mandatory_predef_tab_c(_, _, {"got objfun through args","ObjFun"}) ->
 is_mandatory_predef_tab_c(_,_,_) ->
     true.
 
-gen_dec_extaddGroup_no_val(Ext,[#'ComponentType'{prop=Prop}])->
-    gen_dec_component_no_val(Ext,Prop),
+gen_dec_extaddGroup_no_val(Ext, Type, [#'ComponentType'{prop=Prop}])->
+    gen_dec_component_no_val(Ext, Type, Prop),
     ok;
-gen_dec_extaddGroup_no_val(Ext,[#'ComponentType'{prop=Prop}|Rest])->
-    gen_dec_component_no_val(Ext,Prop),
-    emit({","}),
-    gen_dec_extaddGroup_no_val(Ext,Rest);
-gen_dec_extaddGroup_no_val(_, []) ->
+gen_dec_extaddGroup_no_val(Ext, Type, [#'ComponentType'{prop=Prop}|Rest])->
+    gen_dec_component_no_val(Ext, Type, Prop),
+    emit(","),
+    gen_dec_extaddGroup_no_val(Ext, Type, Rest);
+gen_dec_extaddGroup_no_val(_, _, []) ->
     ok.
 
-gen_dec_component_no_val(_,{'DEFAULT',DefVal}) ->
+gen_dec_component_no_val(_, Type, {'DEFAULT',DefVal0}) ->
+    DefVal = asn1ct_gen:conform_value(Type, DefVal0),
     emit([{asis,DefVal}]);
-gen_dec_component_no_val(_,'OPTIONAL') ->
+gen_dec_component_no_val(_, _, 'OPTIONAL') ->
     emit({"asn1_NOVALUE"});
-gen_dec_component_no_val({ext,_,_},mandatory) ->
+gen_dec_component_no_val({ext,_,_}, _, mandatory) ->
     emit({"asn1_NOVALUE"}).
     
 
diff --git a/lib/asn1/src/asn1ct_gen.erl b/lib/asn1/src/asn1ct_gen.erl
index 3452d29085..30d337635b 100644
--- a/lib/asn1/src/asn1ct_gen.erl
+++ b/lib/asn1/src/asn1ct_gen.erl
@@ -33,7 +33,9 @@
 	 insert_once/2,
 	 ct_gen_module/1,
 	 index2suffix/1,
-	 get_record_name_prefix/0]).
+	 get_record_name_prefix/0,
+	 conform_value/2,
+	 named_bitstring_value/2]).
 -export([pgen/5,
 	 mk_var/1, 
 	 un_hyphen_var/1]).
@@ -1485,8 +1487,14 @@ gen_prim_check_call(PrimType, Default, Element, Type) ->
 		  end,
 	    check_call(check_int, [Default,Element,{asis,NNL}]);
 	'BIT STRING' ->
-	    {_,NBL} = Type#type.def,
-	    check_call(check_bitstring, [Default,Element,{asis,NBL}]);
+	    case Type#type.def of
+		{_,[]} ->
+		    check_call(check_bitstring,
+			       [Default,Element]);
+		{_,[_|_]=NBL} ->
+		    check_call(check_named_bitstring,
+			       [Default,Element,{asis,NBL}])
+	    end;
 	'OCTET STRING' ->
 	    check_call(check_octetstring, [Default,Element]);
 	'NULL' ->
@@ -1640,9 +1648,33 @@ unify_if_string(PrimType) ->
 	Other -> Other
     end.
 
-
-	
-	
+conform_value(#type{def={'BIT STRING',[]}}, Bs) ->
+    case asn1ct:get_bit_string_format() of
+	compact when is_binary(Bs) ->
+	    {0,Bs};
+	compact when is_bitstring(Bs) ->
+	    Sz = bit_size(Bs),
+	    Unused = 8 - bit_size(Bs),
+	    {Unused,<<Bs:Sz/bits,0:Unused>>};
+	legacy ->
+	    [B || <<B:1>> <= Bs];
+	bitstring when is_bitstring(Bs) ->
+	    Bs
+    end;
+conform_value(_, Value) -> Value.
+
+named_bitstring_value(List, Names) ->
+    Int = lists:foldl(fun(N, A) ->
+			      {N,Pos} = lists:keyfind(N, 1, Names),
+			      A bor (1 bsl Pos)
+		      end, 0, List),
+    named_bitstring_value_1(<<>>, Int).
+
+named_bitstring_value_1(Bs, 0) ->
+    Bs;
+named_bitstring_value_1(Bs, Int) ->
+    B = Int band 1,
+    named_bitstring_value_1(<<Bs/bitstring,B:1>>, Int bsr 1).
 
 get_inner(A) when is_atom(A) -> A;    
 get_inner(Ext) when is_record(Ext,'Externaltypereference') -> Ext;    
diff --git a/lib/asn1/src/asn1ct_imm.erl b/lib/asn1/src/asn1ct_imm.erl
index 892178f61b..20785cda8c 100644
--- a/lib/asn1/src/asn1ct_imm.erl
+++ b/lib/asn1/src/asn1ct_imm.erl
@@ -319,14 +319,22 @@ per_enc_extensions(Val0, Pos0, NumBits, Aligned) when NumBits > 0 ->
 	{'cond',[[{eq,Bitmap,0}],
 		 ['_'|Length ++ PutBits]],{var,"Extensions"}}].
 
-per_enc_optional(Val0, {Pos,Def}, _Aligned) when is_integer(Pos) ->
+per_enc_optional(Val0, {Pos,DefVals}, _Aligned) when is_integer(Pos),
+						     is_list(DefVals) ->
     Val1 = lists:concat(["element(",Pos,", ",Val0,")"]),
     {B,[Val]} = mk_vars(Val1, []),
     Zero = {put_bits,0,1,[1]},
     One = {put_bits,1,1,[1]},
-    B++[{'cond',[[{eq,Val,asn1_DEFAULT},Zero],
-		 [{eq,Val,Def},Zero],
-		 ['_',One]]}];
+    B++[{'cond',
+	 [[{eq,Val,DefVal},Zero] || DefVal <- DefVals] ++ [['_',One]]}];
+per_enc_optional(Val0, {Pos,{call,M,F,A}}, _Aligned) when is_integer(Pos) ->
+    Val1 = lists:concat(["element(",Pos,", ",Val0,")"]),
+    {B,[Val,Tmp]} = mk_vars(Val1, [tmp]),
+    Zero = {put_bits,0,1,[1]},
+    One = {put_bits,1,1,[1]},
+    B++[{call,M,F,[Val|A],Tmp},
+	{'cond',
+	 [[{eq,Tmp,true},Zero],['_',One]]}];
 per_enc_optional(Val0, Pos, _Aligned) when is_integer(Pos) ->
     Val1 = lists:concat(["element(",Pos,", ",Val0,")"]),
     {B,[Val]} = mk_vars(Val1, []),
@@ -352,7 +360,12 @@ per_enc_sof(Val0, Constraint, ElementVar, ElementImm, Aligned) ->
 	    PreBlock ++ EncLen ++ Lc
     end.
 
-enc_absent(Val0, AbsVals, Body) ->
+enc_absent(Val0, {call,M,F,A}, Body) ->
+    {B,[Var,Tmp]} = mk_vars(Val0, [tmp]),
+    B++[{call,M,F,[Var|A],Tmp},
+	{'cond',
+	 [[{eq,Tmp,true}],['_'|Body]]}];
+enc_absent(Val0, AbsVals, Body) when is_list(AbsVals) ->
     {B,[Var]} = mk_vars(Val0, []),
     Cs = [[{eq,Var,Aval}] || Aval <- AbsVals] ++ [['_'|Body]],
     B++build_cond(Cs).
@@ -994,6 +1007,25 @@ mk_var(Base, V) ->
 
 per_enc_integer_1(Val, [], Aligned) ->
     [{'cond',[['_'|per_enc_unconstrained(Val, Aligned)]]}];
+per_enc_integer_1(Val, [{{'SingleValue',[_|_]=Svs}=Constr,[]}], Aligned) ->
+    %% An extensible constraint such as (1|17, ...).
+    %%
+    %% A subtle detail is that the extension root as described in the
+    %% ASN.1 spec should be used to determine whether a particular value
+    %% belongs to the extension root (as opposed to the effective
+    %% constraint, which will be used for the actual encoding).
+    %%
+    %% So for the example above, only the integers 1 and 17 should be
+    %% encoded as root values (extension bit = 0).
+
+    [{'ValueRange',{Lb,Ub}}] = effective_constraint(integer, [Constr]),
+    Root = [begin
+		{[],_,Put} = per_enc_constrained(Sv, Lb, Ub, Aligned),
+		[{eq,Val,Sv},{put_bits,0,1,[1]}|Put]
+	    end || Sv <- Svs],
+    Cs = Root ++ [['_',{put_bits,1,1,[1]}|
+		   per_enc_unconstrained(Val, Aligned)]],
+    build_cond(Cs);
 per_enc_integer_1(Val0, [{{_,_}=Constr,[]}], Aligned) ->
     {Prefix,Check,Action} = per_enc_integer_2(Val0, Constr, Aligned),
     Prefix++build_cond([[Check,{put_bits,0,1,[1]}|Action],
@@ -1004,7 +1036,7 @@ per_enc_integer_1(Val0, [Constr], Aligned) ->
     Prefix++build_cond([[Check|Action],
 			['_',{error,Val0}]]).
 
-per_enc_integer_2(Val, {'SingleValue',Sv}, Aligned) ->
+per_enc_integer_2(Val, {'SingleValue',Sv}, Aligned) when is_integer(Sv) ->
     per_enc_constrained(Val, Sv, Sv, Aligned);
 per_enc_integer_2(Val0, {'ValueRange',{Lb,'MAX'}}, Aligned)
   when is_integer(Lb) ->
diff --git a/lib/asn1/src/asn1ct_value.erl b/lib/asn1/src/asn1ct_value.erl
index 992210232f..862b3c4ea5 100644
--- a/lib/asn1/src/asn1ct_value.erl
+++ b/lib/asn1/src/asn1ct_value.erl
@@ -167,17 +167,16 @@ from_type_prim(M, D) ->
     case D#type.def of
 	'INTEGER' ->
 	    i_random(C);
-	{'INTEGER',NamedNumberList} ->
-	    NN = [X||{X,_} <- NamedNumberList],
-	    case NN of 
+	{'INTEGER',[_|_]=NNL} ->
+	    case C of
 		[] ->
-		    i_random(C);
+		    {N,_} = lists:nth(random(length(NNL)), NNL),
+		    N;
 		_ ->
-		    case C of
-			[] ->
-			    lists:nth(random(length(NN)),NN);
-			_ ->
-			    lists:nth((fun(0)->1;(X)->X end(i_random(C))),NN)
+		    V = i_random(C),
+		    case lists:keyfind(V, 2, NNL) of
+			false -> V;
+			{N,V} -> N
 		    end
 	    end;
 	Enum when is_tuple(Enum),element(1,Enum)=='ENUMERATED' ->
diff --git a/lib/asn1/src/asn1rtt_check.erl b/lib/asn1/src/asn1rtt_check.erl
index e78b65a8fb..be4f9c8bff 100644
--- a/lib/asn1/src/asn1rtt_check.erl
+++ b/lib/asn1/src/asn1rtt_check.erl
@@ -20,7 +20,7 @@
 
 -export([check_bool/2,
 	 check_int/3,
-	 check_bitstring/3,
+	 check_bitstring/2,check_named_bitstring/3,
 	 check_octetstring/2,
 	 check_null/2,
 	 check_objectidentifier/2,
@@ -50,31 +50,54 @@ check_int(DefValue, Value, NNL) when is_atom(Value) ->
 check_int(DefaultValue, _Value, _) ->
     throw({error,DefaultValue}).
 
-%% Two equal lists or integers
-check_bitstring(_, asn1_DEFAULT, _) ->
+%% check_bitstring(Default, UserBitstring) -> true|false
+%%  Default = bitstring()
+%%  UserBitstring = integeger() | list(0|1) | {Unused,binary()} | bitstring()
+check_bitstring(_, asn1_DEFAULT) ->
     true;
-check_bitstring(V, V, _) ->
-    true;
-%% Default value as a list of 1 and 0 and user value as an integer
-check_bitstring(L=[H|T], Int, _) when is_integer(Int), is_integer(H) ->
-    case bit_list_to_int(L, length(T)) of
-	Int -> true;
-	_ -> throw({error,L,Int})
+check_bitstring(DefVal, {Unused,Binary}) ->
+    %% User value in compact format.
+    Sz = bit_size(Binary) - Unused,
+    <<Val:Sz/bitstring,_:Unused>> = Binary,
+    check_bitstring(DefVal, Val);
+check_bitstring(DefVal, Val) when is_bitstring(Val) ->
+    case Val =:= DefVal of
+	false -> throw(error);
+	true -> true
     end;
-%% Default value as an integer, val as list
-check_bitstring(Int, Val, NBL) when is_integer(Int), is_list(Val) ->
-    BL = int_to_bit_list(Int, [], length(Val)),
-    check_bitstring(BL, Val, NBL);
+check_bitstring(Def, Val) when is_list(Val) ->
+    check_bitstring_list(Def, Val);
+check_bitstring(Def, Val) when is_integer(Val) ->
+    check_bitstring_integer(Def, Val).
+
+check_bitstring_list(<<H:1,T1/bitstring>>, [H|T2]) ->
+    check_bitstring_list(T1, T2);
+check_bitstring_list(<<>>, []) ->
+    true;
+check_bitstring_list(_, _) ->
+    throw(error).
+
+check_bitstring_integer(<<H:1,T1/bitstring>>, Int) when H =:= Int band 1 ->
+    check_bitstring_integer(T1, Int bsr 1);
+check_bitstring_integer(<<>>, 0) ->
+    true;
+check_bitstring_integer(_, _) ->
+    throw(error).
+
+check_named_bitstring(_, asn1_DEFAULT, _) ->
+    true;
+check_named_bitstring(V, V, _) ->
+    true;
 %% Default value and user value as lists of ones and zeros
-check_bitstring(L1=[H1|_T1], L2=[H2|_T2], NBL=[_H|_T]) when is_integer(H1), is_integer(H2) ->
+check_named_bitstring(L1=[H1|_T1], L2=[H2|_T2], NBL=[_H|_T]) when is_integer(H1), is_integer(H2) ->
     L2new = remove_trailing_zeros(L2),
-    check_bitstring(L1, L2new, NBL);
+    check_named_bitstring(L1, L2new, NBL);
 %% Default value as a list of 1 and 0 and user value as a list of atoms
-check_bitstring(L1=[H1|_T1], L2=[H2|_T2], NBL) when is_integer(H1), is_atom(H2) ->
+check_named_bitstring(L1=[H1|_T1], L2=[H2|_T2], NBL) when is_integer(H1), is_atom(H2) ->
     L3 = bit_list_to_nbl(L1, NBL, 0, []),
-    check_bitstring(L3, L2, NBL);
+    check_named_bitstring(L3, L2, NBL);
 %% Both default value and user value as a list of atoms
-check_bitstring(L1=[H1|T1], L2=[H2|_T2], _)
+check_named_bitstring(L1=[H1|T1], L2=[H2|_T2], _)
   when is_atom(H1), is_atom(H2), length(L1) =:= length(L2) ->
     case lists:member(H1, L2) of
 	true ->
@@ -82,27 +105,29 @@ check_bitstring(L1=[H1|T1], L2=[H2|_T2], _)
 	false -> throw({error,L2})
     end;
 %% Default value as a list of atoms and user value as a list of 1 and 0
-check_bitstring(L1=[H1|_T1], L2=[H2|_T2], NBL) when is_atom(H1), is_integer(H2) ->
+check_named_bitstring(L1=[H1|_T1], L2=[H2|_T2], NBL) when is_atom(H1), is_integer(H2) ->
     L3 = bit_list_to_nbl(L2, NBL, 0, []),
-    check_bitstring(L1, L3, NBL);
+    check_named_bitstring(L1, L3, NBL);
 %% User value in compact format
-check_bitstring(DefVal,CBS={_,_}, NBL) ->
+check_named_bitstring(DefVal,CBS={_,_}, NBL) ->
     NewVal = cbs_to_bit_list(CBS),
-    check_bitstring(DefVal, NewVal, NBL);
-check_bitstring(DV, V, _) ->
+    check_named_bitstring(DefVal, NewVal, NBL);
+%% User value as a binary
+check_named_bitstring(DefVal, CBS, NBL) when is_binary(CBS) ->
+    NewVal = cbs_to_bit_list({0,CBS}),
+    check_named_bitstring(DefVal, NewVal, NBL);
+%% User value as a bitstring
+check_named_bitstring(DefVal, CBS, NBL) when is_bitstring(CBS) ->
+    BitSize = bit_size(CBS),
+    Unused = 8 - (BitSize band 7),
+    NewVal = cbs_to_bit_list({Unused,<<CBS:BitSize/bits,0:Unused>>}),
+    check_named_bitstring(DefVal, NewVal, NBL);
+check_named_bitstring(DV, V, _) ->
     throw({error,DV,V}).
 
-
-bit_list_to_int([0|Bs], ShL)->
-    bit_list_to_int(Bs, ShL-1) + 0;
-bit_list_to_int([1|Bs], ShL) ->
-    bit_list_to_int(Bs, ShL-1) + (1 bsl ShL);
-bit_list_to_int([], _) ->
-    0.
-
 int_to_bit_list(0, Acc, 0) ->
     Acc;
-int_to_bit_list(Int, Acc, Len) ->
+int_to_bit_list(Int, Acc, Len) when Len > 0 ->
     int_to_bit_list(Int bsr 1, [Int band 1|Acc], Len - 1).
 
 bit_list_to_nbl([0|T], NBL, Pos, Acc) ->
diff --git a/lib/asn1/src/asn1rtt_per_common.erl b/lib/asn1/src/asn1rtt_per_common.erl
index 9e9fd87ec3..3309e6a4ca 100644
--- a/lib/asn1/src/asn1rtt_per_common.erl
+++ b/lib/asn1/src/asn1rtt_per_common.erl
@@ -37,6 +37,7 @@
 	 bitstring_from_positions/1,bitstring_from_positions/2,
 	 to_bitstring/1,to_bitstring/2,
 	 to_named_bitstring/1,to_named_bitstring/2,
+	 is_default_bitstring/5,
 	 extension_bitmap/3]).
 
 -define('16K',16384).
@@ -271,6 +272,36 @@ to_named_bitstring(Val, Lb) ->
     %% for correctness, not speed.
     adjust_trailing_zeroes(to_bitstring(Val), Lb).
 
+is_default_bitstring(asn1_DEFAULT, _, _, _, _) ->
+    true;
+is_default_bitstring({Unused,Bin}, V0, V1, V2, V3) when is_integer(Unused) ->
+    %% Convert compact bitstring to a bitstring.
+    Sz = bit_size(Bin) - Unused,
+    <<Bs:Sz/bitstring,_:Unused>> = Bin,
+    is_default_bitstring(Bs, V0, V1, V2, V3);
+is_default_bitstring(Named, Named, _, _, _) ->
+    true;
+is_default_bitstring(Bs, _, Bs, _, _) ->
+    true;
+is_default_bitstring(List, _, _, List, _) ->
+    true;
+is_default_bitstring(Int, _, _, _, Int) ->
+    true;
+is_default_bitstring(Val, _, Def, _, _) when is_bitstring(Val) ->
+    Sz = bit_size(Def),
+    case Val of
+	<<Def:Sz/bitstring,T/bitstring>> ->
+	    NumZeroes = bit_size(T),
+	    case T of
+		<<0:NumZeroes>> -> true;
+		_ -> false
+	    end;
+	_ ->
+	    false
+    end;
+is_default_bitstring(Val, _, _, List, _) when is_list(Val) ->
+    is_default_bitstring_list(List, Val);
+is_default_bitstring(_, _, _, _, _) -> false.
 
 extension_bitmap(Val, Pos, Limit) ->
     extension_bitmap(Val, Pos, Limit, 0).
@@ -447,6 +478,16 @@ ntz(Byte) ->
 	 4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0},
     element(Byte+1, T).
 
+is_default_bitstring_list([H|Def], [H|Val]) ->
+    is_default_bitstring_list(Def, Val);
+is_default_bitstring_list([], []) ->
+    true;
+is_default_bitstring_list([], [_|_]=Val) ->
+    lists:all(fun(0) -> true;
+		 (_) -> false
+	      end, Val);
+is_default_bitstring_list(_, _) -> false.
+
 extension_bitmap(_Val, Pos, Limit, Acc) when Pos >= Limit ->
     Acc;
 extension_bitmap(Val, Pos, Limit, Acc) ->
diff --git a/lib/asn1/src/prepare_templates.erl b/lib/asn1/src/prepare_templates.erl
index 83155b2e52..ccd15548d8 100644
--- a/lib/asn1/src/prepare_templates.erl
+++ b/lib/asn1/src/prepare_templates.erl
@@ -21,69 +21,77 @@
 -export([gen_asn1ct_rtt/1,gen_asn1ct_eval/1]).
 
 gen_asn1ct_rtt(Ms) ->
-    io:format("%% Generated by ~s. DO NOT EDIT THIS FILE.\n"
+    {ok,Fd} = file:open("asn1ct_rtt.erl", [write]),
+    io:format(Fd,
+	      "%% Generated by ~s. DO NOT EDIT THIS FILE.\n"
 	      "%%\n"
 	      "%% Input files:\n", [?MODULE]),
-    [io:put_chars(["%%  ",M,$\n]) || M <- Ms],
-    io:nl(),
-    io:put_chars("-module(asn1ct_rtt).\n"
+    [io:put_chars(Fd, ["%%  ",M,$\n]) || M <- Ms],
+    io:nl(Fd),
+    io:put_chars(Fd,
+		 "-module(asn1ct_rtt).\n"
 		 "-export([assert_defined/1,dependencies/1,code/0]).\n"
 		 "\n"),
     Forms = lists:sort(lists:append([abstract(M) || M <- Ms])),
     Exp = lists:sort(exports(Forms)),
-    defined(Exp),
-    io:nl(),
+    defined(Fd, Exp),
+    io:nl(Fd),
     Calls = calls(Forms),
     R = sofs:relation(Calls),
     Fam0 = sofs:relation_to_family(R),
     Fam = sofs:to_external(Fam0),
-    dependencies(Fam),
-    io:nl(),
+    dependencies(Fd, Fam),
+    io:nl(Fd),
     Funcs = [begin
 		 Bin = list_to_binary([$\n|erl_pp:function(Func)]),
 		 {{M,F,A},Bin}
 	     end || {M,{function,_,F,A,_}=Func} <- Forms],
-    io:format("code() ->\n~p.\n\n", [Funcs]),
+    io:format(Fd, "code() ->\n~p.\n\n", [Funcs]),
+    ok = file:close(Fd),
     halt(0).
 
 gen_asn1ct_eval([File]) ->
+    Output = filename:rootname(File, ".funcs") ++ ".erl",
+    {ok,Fd} = file:open(Output, [write]),
     {ok,Funcs} = file:consult(File),
     asn1ct_func:start_link(),
     [asn1ct_func:need(MFA) || MFA <- Funcs],
-    io:format("%% Generated by ~s. DO NOT EDIT THIS FILE.\n"
+    io:format(Fd,
+	      "%% Generated by ~s. DO NOT EDIT THIS FILE.\n"
 	      "%%\n"
 	      "%% Input file: ~s\n\n", [?MODULE,File]),
-    io:format("-module(~s).\n", [filename:rootname(File)]),
-    gen_asn1ct_eval_exp(Funcs),
-    asn1ct_func:generate(group_leader()),
+    io:format(Fd, "-module(~s).\n", [filename:rootname(File)]),
+    gen_asn1ct_eval_exp(Fd, Funcs),
+    asn1ct_func:generate(Fd),
+    ok = file:close(Fd),
     halt(0).
 
-gen_asn1ct_eval_exp(Funcs) ->
-    io:put_chars("-export(["),
-    gen_asn1ct_eval_exp_1(Funcs, ""),
-    io:put_chars("]).\n").
+gen_asn1ct_eval_exp(Fd, Funcs) ->
+    io:put_chars(Fd, "-export(["),
+    gen_asn1ct_eval_exp_1(Fd, Funcs, ""),
+    io:put_chars(Fd, "]).\n").
 
-gen_asn1ct_eval_exp_1([{_,F,A}|T], Sep) ->
-    io:put_chars(Sep),
-    io:format("~p/~p", [F,A]),
-    gen_asn1ct_eval_exp_1(T, ",\n");
-gen_asn1ct_eval_exp_1([], _) -> ok.
+gen_asn1ct_eval_exp_1(Fd, [{_,F,A}|T], Sep) ->
+    io:put_chars(Fd, Sep),
+    io:format(Fd, "~p/~p", [F,A]),
+    gen_asn1ct_eval_exp_1(Fd, T, ",\n");
+gen_asn1ct_eval_exp_1(_, [], _) -> ok.
 
-defined([H|T]) ->
-    io:format("assert_defined(~p) -> ok", [H]),
+defined(Fd, [H|T]) ->
+    io:format(Fd, "assert_defined(~p) -> ok", [H]),
     case T of
 	[] ->
-	    io:put_chars(".\n");
+	    io:put_chars(Fd, ".\n");
 	[_|_] ->
-	    io:put_chars(";\n"),
-	    defined(T)
+	    io:put_chars(Fd, ";\n"),
+	    defined(Fd, T)
     end.
 
-dependencies([{K,V}|T]) ->
-    io:format("dependencies(~p) ->\n~p;\n", [K,V]),
-    dependencies(T);
-dependencies([]) ->
-    io:put_chars("dependencies(_) -> [].\n").
+dependencies(Fd, [{K,V}|T]) ->
+    io:format(Fd, "dependencies(~p) ->\n~p;\n", [K,V]),
+    dependencies(Fd, T);
+dependencies(Fd, []) ->
+    io:put_chars(Fd, "dependencies(_) -> [].\n").
 
 abstract(File) ->
     {ok,{M0,[{abstract_code,Abstract}]}} =
diff --git a/lib/asn1/test/asn1_SUITE.erl b/lib/asn1/test/asn1_SUITE.erl
index 61b360ddf2..83bd66a631 100644
--- a/lib/asn1/test/asn1_SUITE.erl
+++ b/lib/asn1/test/asn1_SUITE.erl
@@ -96,7 +96,6 @@ groups() ->
        testChoTypeRefSeq,
        testChoTypeRefSet,
        testMultipleLevels,
-       testDef,
        testOpt,
        testSeqDefault,
        % Uses 'External'
@@ -141,9 +140,9 @@ groups() ->
        testDeepTConstr,
        testExport,
        testImport,
-       % Uses 'ParamBasic'
-       {group, [], [testParamBasic,
-                    testDER]},
+       testParamBasic,
+       testDER,
+       testDEFAULT,
        testMvrasn6,
        testContextSwitchingTypes,
        testOpenTypeImplicitTag,
@@ -326,20 +325,21 @@ testCompactBitString(Config, Rule, Opts) ->
 			  [Rule, compact_bit_string|Opts]),
     testCompactBitString:otp_4869(Rule).
 
-testPrimStrings(Config) -> test(Config, fun testPrimStrings/3).
+testPrimStrings(Config) ->
+    test(Config, fun testPrimStrings/3, [ber,{ber,[der]},per,uper]).
 testPrimStrings(Config, Rule, Opts) ->
     asn1_test_lib:compile_all(["PrimStrings", "BitStr"], Config, [Rule|Opts]),
-    testPrimStrings_cases(Rule),
+    testPrimStrings_cases(Rule, Opts),
     asn1_test_lib:compile_all(["PrimStrings", "BitStr"], Config,
 			      [legacy_bit_string,Rule|Opts]),
-    testPrimStrings:bit_string(Rule),
+    testPrimStrings:bit_string(Rule, Opts),
     asn1_test_lib:compile_all(["PrimStrings", "BitStr"], Config,
 			      [compact_bit_string,Rule|Opts]),
-    testPrimStrings:bit_string(Rule),
+    testPrimStrings:bit_string(Rule, Opts),
     testPrimStrings:more_strings(Rule).
 
-testPrimStrings_cases(Rule) ->
-    testPrimStrings:bit_string(Rule),
+testPrimStrings_cases(Rule, Opts) ->
+    testPrimStrings:bit_string(Rule, Opts),
     testPrimStrings:octet_string(Rule),
     testPrimStrings:numeric_string(Rule),
     testPrimStrings:other_strings(Rule),
@@ -429,6 +429,13 @@ testDef(Config, Rule, Opts) ->
     asn1_test_lib:compile("Def", Config, [Rule|Opts]),
     testDef:main(Rule).
 
+testDEFAULT(Config) ->
+    test(Config, fun testDEFAULT/3, [ber,{ber,[der]},per,uper]).
+testDEFAULT(Config, Rule, Opts) ->
+    asn1_test_lib:compile_all(["Def","Default"], Config, [Rule|Opts]),
+    testDef:main(Rule),
+    testSeqSetDefaultVal:main(Rule, Opts).
+
 testOpt(Config) -> test(Config, fun testOpt/3).
 testOpt(Config, Rule, Opts) ->
     asn1_test_lib:compile("Opt", Config, [Rule|Opts]),
@@ -516,7 +523,8 @@ testSetDefault(Config, Rule, Opts) ->
     asn1_test_lib:compile("SetDefault", Config, [Rule|Opts]),
     testSetDefault:main(Rule).
 
-testParamBasic(Config) -> test(Config, fun testParamBasic/3).
+testParamBasic(Config) ->
+    test(Config, fun testParamBasic/3, [ber,{ber,[der]},per,uper]).
 testParamBasic(Config, Rule, Opts) ->
     asn1_test_lib:compile("ParamBasic", Config, [Rule|Opts]),
     testParamBasic:main(Rule).
@@ -873,11 +881,7 @@ testDER(Config) ->
     test(Config, fun testDER/3, [ber]).
 testDER(Config, Rule, Opts) ->
     asn1_test_lib:compile("DERSpec", Config, [Rule, der|Opts]),
-    testDER:test(),
-    asn1_test_lib:compile("ParamBasic", Config, [Rule, der|Opts]),
-    testParamBasic:main(der),
-    asn1_test_lib:compile("Default", Config, [Rule, der|Opts]),
-    testSeqSetDefaultVal:main(Rule).
+    testDER:test().
 
 specialized_decodes(Config) ->
     test(Config, fun specialized_decodes/3, [ber]).
diff --git a/lib/asn1/test/asn1_SUITE_data/Constraints.py b/lib/asn1/test/asn1_SUITE_data/Constraints.py
index e4bc987e4c..864a471b88 100644
--- a/lib/asn1/test/asn1_SUITE_data/Constraints.py
+++ b/lib/asn1/test/asn1_SUITE_data/Constraints.py
@@ -17,6 +17,11 @@ NegSemiConstrained ::= INTEGER (-128..MAX)
 SemiConstrainedExt ::= INTEGER (42..MAX, ...)
 NegSemiConstrainedExt ::= INTEGER (-128..MAX, ...)
 
+-- Union of single values
+Sv1 ::= INTEGER (2|3|17)
+Sv2 ::= INTEGER (2|3|17, ...)
+Sv3 ::= INTEGER {a(2),b(3),z(17)} (2|3|17, ...)
+
 -- Other constraints
 FixedSize ::= OCTET STRING (SIZE(10)) 
 FixedSize2 ::= OCTET STRING (SIZE(10|20)) 
@@ -94,4 +99,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/asn1_SUITE_data/Default.asn b/lib/asn1/test/asn1_SUITE_data/Default.asn
index 6604953c1f..168ce50bb2 100644
--- a/lib/asn1/test/asn1_SUITE_data/Default.asn
+++ b/lib/asn1/test/asn1_SUITE_data/Default.asn
@@ -21,7 +21,8 @@ SeqBS ::= SEQUENCE {
   a BIT STRING DEFAULT '1010110'B,
   b BIT STRING DEFAULT 'A8A'H,
   c BIT STRING {first(0),second(1),third(2)} DEFAULT {second},
-  d BIT STRING DEFAULT onelist
+  d BIT STRING DEFAULT onelist,
+  e BIT STRING DEFAULT '01011010'B
 }
 
 SetBS ::= SET {
diff --git a/lib/asn1/test/asn1_SUITE_data/PrimStrings.asn1 b/lib/asn1/test/asn1_SUITE_data/PrimStrings.asn1
index 08e7f94ab6..a5b4c8a53d 100644
--- a/lib/asn1/test/asn1_SUITE_data/PrimStrings.asn1
+++ b/lib/asn1/test/asn1_SUITE_data/PrimStrings.asn1
@@ -46,7 +46,13 @@ BS256 ::= BIT STRING (SIZE (256))
 
 BS1024 ::= BIT STRING (SIZE (1024))
 
-  
+  BsDef1 ::= SEQUENCE {
+     s BIT STRING DEFAULT '101111'B
+  }
+
+  BsDef2 ::= SEQUENCE {
+     s BIT STRING DEFAULT 'DEADBEEF'H
+  }
 
   Os ::= OCTET STRING
   OsCon ::= [60] OCTET STRING
diff --git a/lib/asn1/test/testConstraints.erl b/lib/asn1/test/testConstraints.erl
index 9a1d62993d..23322f5e88 100644
--- a/lib/asn1/test/testConstraints.erl
+++ b/lib/asn1/test/testConstraints.erl
@@ -122,6 +122,42 @@ int_constraints(Rules) ->
     range_error(Rules, 'X1', 21),
 
     %%==========================================================
+    %%  Union of single values
+    %%  Sv1 ::= INTEGER (2|3|17)
+    %%  Sv2 ::= INTEGER (2|3|17, ...)
+    %%  Sv3 ::= INTEGER {a(2),b(3),z(17)} (2|3|17, ...)
+    %%==========================================================
+
+    range_error(Rules, 'Sv1', 1),
+    range_error(Rules, 'Sv1', 18),
+    roundtrip('Sv1', 2),
+    roundtrip('Sv1', 3),
+    roundtrip('Sv1', 7),
+
+    %% Encoded as root
+    v_roundtrip(Rules, 'Sv2', 2),
+    v_roundtrip(Rules, 'Sv2', 3),
+    v_roundtrip(Rules, 'Sv2', 17),
+
+    %% Encoded as extension
+    v_roundtrip(Rules, 'Sv2', 1),
+    v_roundtrip(Rules, 'Sv2', 4),
+    v_roundtrip(Rules, 'Sv2', 18),
+
+    %% Encoded as root
+    v_roundtrip(Rules, 'Sv3', a),
+    v_roundtrip(Rules, 'Sv3', b),
+    v_roundtrip(Rules, 'Sv3', z),
+    v_roundtrip(Rules, 'Sv3', 2, a),
+    v_roundtrip(Rules, 'Sv3', 3, b),
+    v_roundtrip(Rules, 'Sv3', 17, z),
+
+    %% Encoded as extension
+    v_roundtrip(Rules, 'Sv3', 1),
+    v_roundtrip(Rules, 'Sv3', 4),
+    v_roundtrip(Rules, 'Sv3', 18),
+
+    %%==========================================================
     %%  SemiConstrained
     %%==========================================================
 
@@ -182,6 +218,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
@@ -197,7 +242,29 @@ v(per, 'SemiConstrainedExt', 42+128) -> "000180";
 v(uper, 'SemiConstrainedExt', 42+128) -> "00C000";
 v(ber, 'NegSemiConstrainedExt', 0) -> "020100";
 v(per, 'NegSemiConstrainedExt', 0) -> "000180";
-v(uper, 'NegSemiConstrainedExt', 0) -> "00C000".
+v(uper, 'NegSemiConstrainedExt', 0) -> "00C000";
+v(ber, 'Sv2', 1) -> "020101";
+v(per, 'Sv2', 1) -> "800101";
+v(uper, 'Sv2', 1) -> "808080";
+v(ber, 'Sv2', 2) -> "020102";
+v(per, 'Sv2', 2) -> "00";
+v(uper, 'Sv2', 2) -> "00";
+v(ber, 'Sv2', 3) -> "020103";
+v(per, 'Sv2', 3) -> "08";
+v(uper, 'Sv2', 3) -> "08";
+v(ber, 'Sv2', 4) -> "020104";
+v(per, 'Sv2', 4) -> "800104";
+v(uper, 'Sv2', 4) -> "808200";
+v(ber, 'Sv2', 17) -> "020111";
+v(per, 'Sv2', 17) -> "78";
+v(uper, 'Sv2', 17) -> "78";
+v(ber, 'Sv2', 18) -> "020112";
+v(per, 'Sv2', 18) -> "800112";
+v(uper, 'Sv2', 18) -> "808900";
+v(Rule, 'Sv3', a) -> v(Rule, 'Sv2', 2);
+v(Rule, 'Sv3', b) -> v(Rule, 'Sv2', 3);
+v(Rule, 'Sv3', z) -> v(Rule, 'Sv2', 17);
+v(Rule, 'Sv3', Val) when is_integer(Val) -> v(Rule, 'Sv2', Val).
 
 shorter_ext(per, "a") -> <<16#80,16#01,16#61>>;
 shorter_ext(uper, "a") -> <<16#80,16#E1>>;
@@ -211,6 +278,10 @@ v_roundtrip(Erule, Type, Value) ->
     Encoded = asn1_test_lib:hex_to_bin(v(Erule, Type, Value)),
     Encoded = roundtrip('Constraints', Type, Value).
 
+v_roundtrip(Erule, Type, Value, Expected) ->
+    Encoded = asn1_test_lib:hex_to_bin(v(Erule, Type, Value)),
+    Encoded = asn1_test_lib:roundtrip_enc('Constraints', Type, Value, Expected).
+
 roundtrip(Type, Value) ->
     roundtrip('Constraints', Type, Value).
 
@@ -235,3 +306,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.
diff --git a/lib/asn1/test/testParamBasic.erl b/lib/asn1/test/testParamBasic.erl
index 3a55408e94..3db89ca174 100644
--- a/lib/asn1/test/testParamBasic.erl
+++ b/lib/asn1/test/testParamBasic.erl
@@ -38,7 +38,9 @@ main(Rules) ->
 	    <<48,3,128,1,11>> =
 		roundtrip_enc('T11', #'T11'{number=11,string="hej"}),
 	    <<48,3,128,1,11>> =
-		roundtrip_enc('T12', #'T12'{number=11,string=[1,0,1,0]});
+		roundtrip_enc('T12',
+			      #'T12'{number=11,string=[1,0,1,0]},
+			      #'T12'{number=11,string = <<10:4>>});
 	_ -> ok
     end,
     ok.
@@ -48,3 +50,6 @@ roundtrip(Type, Value) ->
 
 roundtrip_enc(Type, Value) ->
     asn1_test_lib:roundtrip_enc('ParamBasic', Type, Value).
+
+roundtrip_enc(Type, Value, Expected) ->
+    asn1_test_lib:roundtrip_enc('ParamBasic', Type, Value, Expected).
diff --git a/lib/asn1/test/testPrimStrings.erl b/lib/asn1/test/testPrimStrings.erl
index be5409aa92..2fe0780701 100644
--- a/lib/asn1/test/testPrimStrings.erl
+++ b/lib/asn1/test/testPrimStrings.erl
@@ -19,7 +19,7 @@
 %%
 -module(testPrimStrings).
 
--export([bit_string/1]).
+-export([bit_string/2]).
 -export([octet_string/1]).
 -export([numeric_string/1]).
 -export([other_strings/1]).
@@ -68,7 +68,7 @@ fragmented_lengths() ->
      K64-1,K64,K64+1,K64+(1 bsl 7)-1,K64+(1 bsl 7),K64+(1 bsl 7)+1,
      K64+K16-1,K64+K16,K64+K16+1].
 
-bit_string(Rules) ->
+bit_string(Rules, Opts) ->
     
     %%==========================================================
     %% Bs1 ::= BIT STRING
@@ -90,9 +90,10 @@ bit_string(Rules) ->
     bs_roundtrip('Bs1', [0,1,0,0,1,0]),
     bs_roundtrip('Bs1', [1,0,0,0,0,0,0,0,0]),
     bs_roundtrip('Bs1', [0,1,0,0,1,0,1,1,1,1,1,0,0,0,1,0,0,1,1]),
-    
-    case Rules of
-	ber ->
+
+
+    case {Rules,Opts} of
+	{ber,[]} ->
 	    bs_decode('Bs1', <<35,8,3,2,0,73,3,2,4,32>>,
 		      [0,1,0,0,1,0,0,1,0,0,1,0]),
 	    bs_decode('Bs1', <<35,9,3,2,0,234,3,3,7,156,0>>,
@@ -100,7 +101,17 @@ bit_string(Rules) ->
 	    bs_decode('Bs1', <<35,128,3,2,0,234,3,3,7,156,0,0,0>>,
 		      [1,1,1,0,1,0,1,0,1,0,0,1,1,1,0,0,0]);
 	_ ->
-	    ok
+	    %% DER, PER, UPER
+	    consistent_def_enc('BsDef1',
+			       [2#111101,
+				[1,0,1,1,1,1],
+				{2,<<2#101111:6,0:2>>},
+				<<2#101111:6>>]),
+	    consistent_def_enc('BsDef2',
+			       [[1,1,0,1, 1,1,1,0, 1,0,1,0, 1,1,0,1,
+				 1,0,1,1, 1,1,1,0, 1,1,1,0, 1,1,1,1],
+				{0,<<16#DEADBEEF:4/unit:8>>},
+				<<16#DEADBEEF:4/unit:8>>])
     end,
 
     
@@ -217,6 +228,24 @@ bit_string(Rules) ->
 	_ -> per_bs_strings()
     end.
 
+consistent_def_enc(Type, Vs) ->
+    M = 'PrimStrings',
+    {ok,Enc} = M:encode(Type, {Type,asn1_DEFAULT}),
+    {ok,Val} = M:decode(Type, Enc),
+
+    %% Ensure that the value has the correct format.
+    case {M:bit_string_format(),Val} of
+	{bitstring,{_,Bs}} when is_bitstring(Bs) -> ok;
+	{compact,{_,{Unused,Bin}}} when is_integer(Unused),
+					is_binary(Bin) -> ok;
+	{legacy,{_,Bs}} when is_list(Bs) -> ok
+    end,
+
+    %% All values should be recognized and encoded as the
+    %% the default value (i.e. not encoded at all).
+    _ = [{ok,Enc} = M:encode(Type, {Type,V}) || V <- Vs],
+    ok.
+
 %% The PER encoding rules requires that a BIT STRING with
 %% named positions should never have any trailing zeroes
 %% (except to reach the minimum number of bits as given by
diff --git a/lib/asn1/test/testSeqSetDefaultVal.erl b/lib/asn1/test/testSeqSetDefaultVal.erl
index fb61bf1647..044099199f 100644
--- a/lib/asn1/test/testSeqSetDefaultVal.erl
+++ b/lib/asn1/test/testSeqSetDefaultVal.erl
@@ -18,7 +18,7 @@
 %%
 %%
 -module(testSeqSetDefaultVal).
--export([main/1]).
+-export([main/2]).
 
 -include("External.hrl").
 -include_lib("test_server/include/test_server.hrl").
@@ -34,7 +34,8 @@
 -record('SeqBS',{a = asn1_DEFAULT, 
 		 b = asn1_DEFAULT, 
 		 c = asn1_DEFAULT,
-		 d = asn1_DEFAULT}).
+		 d = asn1_DEFAULT,
+		 e = asn1_DEFAULT}).
 -record('SetBS',{a = asn1_DEFAULT, 
 		 b = asn1_DEFAULT, 
 		 c = asn1_DEFAULT,
@@ -93,7 +94,119 @@
 -record('S4_b',{ba = asn1_DEFAULT, 
 		bb = asn1_DEFAULT}).
 
-main(_Rules) ->
+main(ber, []) ->
+    %% Nothing to test because plain BER will only use
+    %% default values when explicitly told to do so by
+    %% asn1_DEFAULT.
+    ok;
+main(Rule, Opts) ->
+    %% DER, PER, UPER. These encodings should not encode
+    %% values that are equal to the default value.
+
+    case {Rule,Opts} of
+	{ber,[der]} ->
+	    der();
+	{_,_} ->
+	    ok
+    end,
+
+    Ts = [{#'SeqInts'{},
+	   [{#'SeqInts'.c,
+	     [asn1_DEFAULT,
+	      three,
+	      3]}]},
+
+	  {#'SeqBS'{},
+	   [{#'SeqBS'.a,
+	     [asn1_DEFAULT,
+	      2#0110101,
+	      [1,0,1,0,1,1,0],
+	      {1,<<16#AC>>},
+	      <<1:1,0:1,1:1,0:1,1:1,1:1,0:1>>]},
+	    {#'SeqBS'.b,
+	     [asn1_DEFAULT,
+	      2#10100010101,
+	      [1,0,1,0,1,0,0,0,1,0,1,0],
+	      {4,<<16#A8,16#A0>>},
+	      <<16#A8:8,16#A:4>>]},
+	    {#'SeqBS'.c,
+	     [asn1_DEFAULT,
+	      [second],
+	      [0,1],
+	      {6,<<0:1,1:1,0:6>>},
+	      <<1:2>>]},
+	    {#'SeqBS'.c,			%Zeroes on the right
+	     [asn1_DEFAULT,
+	      [second],
+	      [0,1,0,0,0],
+	      {4,<<0:1,1:1,0:6>>},
+	      <<1:2,0:17>>]},
+	    {#'SeqBS'.d,
+	     [asn1_DEFAULT,
+	      2#1001,
+	      [1,0,0,1],
+	      {4,<<2#1001:4,0:4>>},
+	      <<2#1001:4>>]},
+	    {#'SeqBS'.e,
+	     [asn1_DEFAULT,
+	      [0,1,0,1,1,0,1,0],
+	      {0,<<2#01011010:8>>},
+	      <<2#01011010:8>>]},
+	    %% Not EQUAL to DEFAULT.
+	    {#'SeqBS'.b,
+	     [[1,1,0],				%Not equal to DEFAULT
+	      {5,<<6:3,0:5>>},
+	      <<6:3>>]}
+	   ]},
+
+	  {#'SeqOS'{},
+	   [{#'SeqOS'.a,
+	     [asn1_DEFAULT,
+	      [172]]}]},
+
+	  {#'SeqOI'{},
+	   [{#'SeqOI'.a,
+	     [asn1_DEFAULT,
+	      {1,2,14,15}]},
+	    {#'SeqOI'.b,
+	     [asn1_DEFAULT,
+%%	      {iso,'member-body',250,3,4},
+	      {1,2,250,3,4}]},
+	    {#'SeqOI'.c,
+	     [asn1_DEFAULT,
+%%	      {iso,standard,8571,2,250,4},
+	      {1,0,8571,2,250,4}]}]}
+	 ],
+    io:format("~p\n", [Ts]),
+    R0 = [[consistency(Rec, Pos, Vs) || {Pos,Vs} <- Fs] || {Rec,Fs} <- Ts],
+    case lists:flatten(R0) of
+	[] ->
+	    ok;
+	[_|_]=R ->
+	    io:format("~p\n", [R]),
+	    ?t:fail()
+    end.
+
+consistency(Rec0, Pos, [V|Vs]) ->
+    T = element(1, Rec0),
+    Rec = setelement(Pos, Rec0, V),
+    {ok,Enc} = 'Default':encode(T, Rec),
+    {ok,_SmokeTest} = 'Default':decode(T, Enc),
+    consistency_1(Vs, Rec0, Pos, Enc).
+
+consistency_1([V|Vs], Rec0, Pos, Enc) ->
+    Rec = setelement(Pos, Rec0, V),
+    case 'Default':encode(element(1, Rec), Rec) of
+	{ok,Enc} ->
+	    consistency_1(Vs, Rec0, Pos, Enc);
+	{ok,WrongEnc} ->
+	    [{Rec,{wrong,WrongEnc},{should_be,Enc}}|
+	     consistency_1(Vs, Rec0, Pos, Enc)]
+    end;
+consistency_1([], _, _, _) -> [].
+
+der() ->
+    io:put_chars("Peforming DER-specific tests..."),
     roundtrip(<<48,0>>,
 	      'SeqInts',
 	      #'SeqInts'{a=asn1_DEFAULT,b=asn1_DEFAULT,
@@ -117,50 +230,88 @@ main(_Rules) ->
 
     roundtrip(<<48,0>>,
 	      'SeqBS',
-	      #'SeqBS'{a=2#1010110,b=16#A8A,c=[second],d=[1,0,0,1]},
-	      #'SeqBS'{a=[1,0,1,0,1,1,0],b=16#A8A,c=[second],d=[1,0,0,1]}),
+	      #'SeqBS'{a=2#0110101,
+		       b=2#010100010101,
+		       c=[second],
+		       d=[1,0,0,1]},
+	      #'SeqBS'{a = <<2#1010110:7>>, b = <<16#A8A:12>>,
+		       c=[second], d = <<2#1001:4>>,
+		       e = <<2#01011010:8>>}),
     roundtrip(<<48,0>>,
 	      'SeqBS',
 	      #'SeqBS'{a=[1,0,1,0,1,1,0],
 		       b=[1,0,1,0,1,0,0,0,1,0,1,0],
 		       c={5,<<64>>},
 		       d=2#1001},
-	      #'SeqBS'{a=[1,0,1,0,1,1,0],b=16#A8A,c=[second],d=[1,0,0,1]}),
+	      #'SeqBS'{a = <<2#1010110:7>>, b = <<16#A8A:12>>,
+		       c=[second], d = <<2#1001:4>>,
+		       e = <<2#01011010:8>>}),
     roundtrip(<<48,3,131,1,0>>,
 	      'SeqBS',
 	      #'SeqBS'{a=[1,0,1,0,1,1,0],
 		       b=[1,0,1,0,1,0,0,0,1,0,1,0],
 		       c={5,<<64>>},
 		       d=0},
-	      #'SeqBS'{a=[1,0,1,0,1,1,0],
-		       b=16#A8A,
-		       c=[second],
-		       d = <<>>}),
+	      #'SeqBS'{a = <<2#1010110:7>>, b = <<16#A8A:12>>,
+		       c=[second], d = <<>>,
+		       e = <<2#01011010:8>>}),
+    roundtrip(<<48,3,131,1,0>>,
+	      'SeqBS',
+	      #'SeqBS'{a = <<1:1,0:1,1:1,0:1,1:1,1:1,0:1>>,
+		       b = <<1:1,0:1,1:1,0:1,1:1,0:1,0:1,0:1,1:1,0:1,1:1,0:1>>,
+		       c = <<2:3>>,
+		       d=0,
+		       e = <<16#5A:8>>},
+	      #'SeqBS'{a = <<2#1010110:7>>, b = <<16#A8A:12>>,
+		       c=[second], d = <<>>,
+		       e = <<2#01011010:8>>}),
+
+    %% None of the default values are used.
+    roundtrip(<<48,19,128,2,7,128,129,2,5,64,130,2,5,32,131,1,0,132,2,5,224>>,
+	      'SeqBS',
+	      #'SeqBS'{a = <<1:1>>,
+		       b = {5,<<64>>},
+		       c = [third],
+		       d = 0,
+		       e = <<7:3>>},
+	      #'SeqBS'{a = <<1:1>>,
+		       b = <<2:3>>,
+		       c = [third],
+		       d = <<>>,
+		       e = <<7:3>>}),
 
     roundtrip(<<49,0>>,
 	      'SetBS',
-	      #'SetBS'{a=2#1010110,b=16#A8A,c=[second],d=[1,0,0,1]},
-	      #'SetBS'{a=[1,0,1,0,1,1,0],b=16#A8A,c=[second],d=[1,0,0,1]}),
+	      #'SetBS'{a=2#0110101,
+		       b=2#010100010101,
+		       c=[second],
+		       d=[1,0,0,1]},
+	      #'SetBS'{a = <<2#1010110:7>>, b = <<16#A8A:12>>,
+		       c=[second], d = <<2#1001:4>>}),
     roundtrip(<<49,0>>,
 	      'SetBS',
 	      #'SetBS'{a=[1,0,1,0,1,1,0],
 		       b=[1,0,1,0,1,0,0,0,1,0,1,0],
 		       c={5,<<64>>},
 		       d=9},
-	      #'SetBS'{a=[1,0,1,0,1,1,0],
-		       b=16#A8A,
-		       c=[second],
-		       d=[1,0,0,1]}),
+	      #'SetBS'{a = <<2#1010110:7>>, b = <<16#A8A:12>>,
+		       c=[second], d = <<2#1001:4>>}),
     roundtrip(<<49,3,131,1,0>>,
 	      'SetBS',
 	      #'SetBS'{a=[1,0,1,0,1,1,0],
 		       b=[1,0,1,0,1,0,0,0,1,0,1,0],
 		       c={5,<<64>>},
 		       d=0},
-	      #'SetBS'{a=[1,0,1,0,1,1,0],
-		       b=16#A8A,
-		       c=[second],
-		       d = <<>>}),
+	      #'SetBS'{a = <<2#1010110:7>>, b = <<16#A8A:12>>,
+		       c=[second], d = <<>>}),
+    roundtrip(<<49,3,131,1,0>>,
+	      'SetBS',
+	      #'SetBS'{a = <<1:1,0:1,1:1,0:1,1:1,1:1,0:1>>,
+		       b = <<1:1,0:1,1:1,0:1,1:1,0:1,0:1,0:1,1:1,0:1,1:1,0:1>>,
+		       c = <<2:3>>,
+		       d=0},
+	      #'SetBS'{a = <<2#1010110:7>>, b = <<16#A8A:12>>,
+		       c=[second], d = <<>>}),
 
     roundtrip(<<48,0>>, 'SeqOS',
 	      #'SeqOS'{a=[172],b=[16#A8,16#A0],c='NULL'}),