Merge branch 'alind/asn1/parallel-tests' into maint

* alind/asn1/parallel-tests:
  [asn1] Refactor test cases and remove extra suites
  [asn1] Replace 'driver' option with 'nif'
  [asn1] Correct test suite dependencies
  [asn1] Parallelize test suites
  [asn1] Make tables and processes unnamed
  [asn1] Abstract out table access to new module
  [asn1] Run asn1 compilation in a separate process

1 files changed, 43 insertions, 36 deletions

diff --git a/lib/asn1/src/asn1ct_value.erl b/lib/asn1/src/asn1ct_value.erl
index d099376b1b..9013baef92 100644
--- a/lib/asn1/src/asn1ct_value.erl
+++ b/lib/asn1/src/asn1ct_value.erl
@@ -1,7 +1,7 @@
 %%
 %% %CopyrightBegin%
 %% 
-%% Copyright Ericsson AB 1997-2011. All Rights Reserved.
+%% Copyright Ericsson AB 1997-2012. All Rights Reserved.
 %% 
 %% The contents of this file are subject to the Erlang Public License,
 %% Version 1.1, (the "License"); you may not use this file except in
@@ -25,58 +25,58 @@
 -include("asn1_records.hrl").
 %-compile(export_all).
 
--export([get_type/3]).
--export([i_random/1]).
-
+-export([from_type/2]).
 
 %% Generate examples of values ******************************
 %%****************************************x
 
 
-get_type(M,Typename,Tellname) ->
+from_type(M,Typename) ->
     case asn1_db:dbget(M,Typename) of
 	undefined -> 
-	    {asn1_error,{not_found,{M,Typename}}};
+	    {error,{not_found,{M,Typename}}};
 	Tdef when is_record(Tdef,typedef) ->
 	    Type = Tdef#typedef.typespec,
-	    get_type(M,[Typename],Type,Tellname);
+	    from_type(M,[Typename],Type);
+    Vdef when is_record(Vdef,valuedef) ->
+        from_value(Vdef);
 	Err ->
-	    {asn1_error,{other,Err}}
+	    {error,{other,Err}}
     end.
 
-get_type(M,Typename,Type,Tellname) when is_record(Type,type) ->
+from_type(M,Typename,Type) when is_record(Type,type) ->
     InnerType = get_inner(Type#type.def),
     case asn1ct_gen:type(InnerType) of
 	#'Externaltypereference'{module=Emod,type=Etype} ->
-	    get_type(Emod,Etype,Tellname);
+	    from_type(Emod,Etype);
 	{_,user} ->
-	    case Tellname of
-		yes -> {Typename,get_type(M,InnerType,no)};
-		no -> get_type(M,InnerType,no)
-	    end;
+		from_type(M,InnerType);
 	{notype,_} ->
 	    true;
 	{primitive,bif} ->
-	    get_type_prim(Type,get_encoding_rule(M));
+	    from_type_prim(Type,get_encoding_rule(M));
 	'ASN1_OPEN_TYPE' ->
 	    case  Type#type.constraint of
 		[#'Externaltypereference'{type=TrefConstraint}] ->
-		    get_type(M,TrefConstraint,no);
+		    from_type(M,TrefConstraint);
 		_ ->
 		    ERule = get_encoding_rule(M),
 		    open_type_value(ERule)
 	    end;
 	{constructed,bif} when Typename == ['EXTERNAL'] ->
-	    Val=get_type_constructed(M,Typename,InnerType,Type),
+	    Val=from_type_constructed(M,Typename,InnerType,Type),
 	    asn1rt_check:transform_to_EXTERNAL1994(Val);
 	{constructed,bif} ->
-	    get_type_constructed(M,Typename,InnerType,Type)
+	    from_type_constructed(M,Typename,InnerType,Type)
     end;
-get_type(M,Typename,#'ComponentType'{name = Name,typespec = Type},_)  ->
-    get_type(M,[Name|Typename],Type,no);
-get_type(_,_,_,_) -> % 'EXTENSIONMARK'
+from_type(M,Typename,#'ComponentType'{name = Name,typespec = Type})  ->
+    from_type(M,[Name|Typename],Type);
+from_type(_,_,_) -> % 'EXTENSIONMARK'
     undefined.
 
+from_value(#valuedef{type = #type{def = 'INTEGER'}, value = Val}) ->
+    Val.
+
 get_inner(A) when is_atom(A) -> A;    
 get_inner(Ext) when is_record(Ext,'Externaltypereference') -> Ext;    
 get_inner({typereference,_Pos,Name}) -> Name;
@@ -93,7 +93,7 @@ get_inner(T) when is_tuple(T) ->
 
 
 
-get_type_constructed(M,Typename,InnerType,D) when is_record(D,type) ->
+from_type_constructed(M,Typename,InnerType,D) when is_record(D,type) ->
     case InnerType of
 	'SET' ->
 	    get_sequence(M,Typename,D);
@@ -132,7 +132,7 @@ get_components(M,Typename,{Root,Ext}) ->
 %% Should enhance this *** HERE *** with proper handling of extensions
 
 get_components(M,Typename,[H|T]) ->
-    [get_type(M,Typename,H,no)|
+    [from_type(M,Typename,H)|
     get_components(M,Typename,T)];
 get_components(_,_,[]) ->
     [].
@@ -145,10 +145,10 @@ get_choice(M,Typename,Type) ->
 	{CompList,ExtList} -> % Should be enhanced to handle extensions too
 	    CList = CompList ++ ExtList,
 	    C = lists:nth(random(length(CList)),CList),
-	    {C#'ComponentType'.name,get_type(M,Typename,C,no)};
+	    {C#'ComponentType'.name,from_type(M,Typename,C)};
 	CompList when is_list(CompList) ->
 	    C = lists:nth(random(length(CompList)),CompList),
-	    {C#'ComponentType'.name,get_type(M,Typename,C,no)}
+	    {C#'ComponentType'.name,from_type(M,Typename,C)}
     end.
     
 get_sequence_of(M,Typename,Type,TypeSuffix) ->
@@ -157,14 +157,14 @@ get_sequence_of(M,Typename,Type,TypeSuffix) ->
     C = Type#type.constraint,
     S = size_random(C),
     NewTypeName = [TypeSuffix|Typename],
-    gen_list(M,NewTypeName,Oftype,no,S).
+    gen_list(M,NewTypeName,Oftype,S).
 
-gen_list(_,_,_,_,0) ->
+gen_list(_,_,_,0) ->
     [];
-gen_list(M,Typename,Oftype,Tellname,N) ->
-    [get_type(M,Typename,Oftype,no)|gen_list(M,Typename,Oftype,Tellname,N-1)].
+gen_list(M,Typename,Oftype,N) ->
+    [from_type(M,Typename,Oftype)|gen_list(M,Typename,Oftype,N-1)].
     
-get_type_prim(D,Erule) ->
+from_type_prim(D,Erule) ->
     C = D#type.constraint,
     case D#type.def of
 	'INTEGER' ->
@@ -198,6 +198,7 @@ get_type_prim(D,Erule) ->
 	    NN = [X||{X,_} <- NNew],
 	    case NN of
 		[] ->
+            io:format(user, "Enum = ~p~n", [Enum]),
 		    asn1_EMPTY;
 		_ ->
 		    case C of
@@ -412,14 +413,20 @@ adjust_list1(Len,Orig,[Oh|Ot],Acc) ->
     adjust_list1(Len-1,Orig,Ot,[Oh|Acc]).
 
 
-get_constraint(C,Key) ->
-    case lists:keysearch(Key,1,C) of
-	false ->
-	     no;
-	{value,{_,V}} -> 
-	    V
+get_constraint(C, Key) ->
+    case lists:keyfind(Key, 1, C) of
+        false                    -> no;
+        {'ValueRange', {Lb, Ub}} -> {check_external(Lb), check_external(Ub)};
+        {'SizeConstraint', N}    -> N;
+        {Key, Value}             -> Value
     end.
 
+check_external(ExtRef) when is_record(ExtRef, 'Externalvaluereference') ->
+    #'Externalvaluereference'{module = Emod, value = Evalue} = ExtRef,
+    from_type(Emod, Evalue);
+check_external(Value) ->
+    Value.
+
 get_encoding_rule(M) ->
     Mod =
 	if is_list(M) ->