Merge branch 'bjorn/compiler/modernize-tests'

* bjorn/compiler/modernize-tests:
  Remove ?line macros
  Replace use of lists:keysearch/3 with lists:keyfind/3
  Eliminate use of doc and suite clauses
  Replace ?t with test_server
  Replace use of test_server:format/2 with io:format/2
  Eliminate use of test_server:fail/0,1
  Eliminate use of ?config() macro
  Modernize use of timetraps
  Eliminate useless helper functions

1 files changed, 125 insertions, 133 deletions

diff --git a/lib/compiler/test/compilation_SUITE.erl b/lib/compiler/test/compilation_SUITE.erl
index 6bff5e55f2..76b7e852f1 100644
--- a/lib/compiler/test/compilation_SUITE.erl
+++ b/lib/compiler/test/compilation_SUITE.erl
@@ -24,7 +24,9 @@
 
 -compile(export_all).
 
-suite() -> [{ct_hooks,[ts_install_cth]}].
+suite() ->
+    [{ct_hooks,[ts_install_cth]},
+     {timetrap,{minutes,10}}].
 
 all() -> 
     test_lib:recompile(?MODULE),
@@ -164,11 +166,9 @@ split({int, N}, <<N:16,B:N/binary,T/binary>>) ->
 ?comp(on_load).
 ?comp(on_load_inline).
 
-beam_compiler_7(doc) ->
-    "Code snippet submitted from Ulf Wiger which fails in R3 Beam.";
-beam_compiler_7(suite) -> [];
+%% Code snippet submitted from Ulf Wiger which fails in R3 Beam.
 beam_compiler_7(Config) when is_list(Config) ->
-    ?line done = empty(2, false).
+    done = empty(2, false).
 
 empty(N, Toggle) when N > 0 ->
     %% R3 Beam copies the second argument to the first before call.
@@ -194,16 +194,17 @@ redundant_case_1(4) -> d;
 redundant_case_1(_) -> d.
 
 failure(Module, Conf) ->
-    ?line Src = filename:join(?config(data_dir, Conf), atom_to_list(Module)),
-    ?line Out = ?config(priv_dir,Conf),
-    ?line io:format("Compiling: ~ts\n", [Src]),
-    ?line CompRc = compile:file(Src, [{outdir,Out},return,time]),
-    ?line io:format("Result: ~p\n",[CompRc]),
-    ?line case CompRc of
-	      error -> ok;
-	      {error,Errors,_} -> check_errors(Errors);
-	      _ -> test_server:fail({no_error, CompRc})
-	  end,
+    Src = filename:join(proplists:get_value(data_dir, Conf),
+			atom_to_list(Module)),
+    Out = proplists:get_value(priv_dir, Conf),
+    io:format("Compiling: ~ts\n", [Src]),
+    CompRc = compile:file(Src, [{outdir,Out},return,time]),
+    io:format("Result: ~p\n",[CompRc]),
+    case CompRc of
+	error -> ok;
+	{error,Errors,_} -> check_errors(Errors);
+	_ -> ct:fail({no_error, CompRc})
+    end,
     ok.
 
 check_errors([{_,Eds}|T]) ->
@@ -224,7 +225,7 @@ check_error_1(Str0) ->
     io:format("~s\n", [Str]),
     case Str of
 	"internal"++_=Str ->
-	    ?t:fail(internal_compiler_error);
+	    ct:fail(internal_compiler_error);
 	_ ->
 	    ok
     end.
@@ -234,51 +235,51 @@ check_error_1(Str0) ->
 try_it(Module, Conf) ->
     %% Change 'false' to 'true' to start a new node for every module.
     try_it(false, Module, Conf).
-		       
+
 try_it(StartNode, Module, Conf) ->
-    ?line OtherOpts = [],			%Can be changed to [time] if needed
-    ?line Src = filename:join(?config(data_dir, Conf), atom_to_list(Module)),
-    ?line Out = ?config(priv_dir,Conf),
-    ?line io:format("Compiling: ~s\n", [Src]),
-    ?line CompRc0 = compile:file(Src, [clint,{outdir,Out},report,
+    try_it(StartNode, Module, {minutes,10}, Conf).
+
+try_it(StartNode, Module, Timetrap, Conf) ->
+    OtherOpts = [],			%Can be changed to [time] if needed
+    Src = filename:join(proplists:get_value(data_dir, Conf),
+			atom_to_list(Module)),
+    Out = proplists:get_value(priv_dir,Conf),
+    io:format("Compiling: ~s\n", [Src]),
+    CompRc0 = compile:file(Src, [clint,{outdir,Out},report,
 				       bin_opt_info|OtherOpts]),
-    ?line io:format("Result: ~p\n",[CompRc0]),
-    ?line {ok,_Mod} = CompRc0,
+    io:format("Result: ~p\n",[CompRc0]),
+    {ok,_Mod} = CompRc0,
 
-    ?line Dog = test_server:timetrap(test_server:minutes(10)),
     Node = case StartNode of
 	       false ->
 		   node();
 	       true ->
-		   ?line Pa = "-pa " ++ filename:dirname(code:which(?MODULE)),
-		   ?line {ok,Node0} = start_node(compiler, Pa),
+		   Pa = "-pa " ++ filename:dirname(code:which(?MODULE)),
+		   {ok,Node0} = start_node(compiler, Pa),
 		   Node0
 	   end,
 		   
-    ?line ok = rpc:call(Node, ?MODULE, load_and_call, [Out, Module]),
-    ?line load_and_call(Out, Module),
-    ?line test_server:timetrap_cancel(Dog),
+    ok = rpc:call(Node, ?MODULE, load_and_call, [Out, Module]),
+    load_and_call(Out, Module),
 
-    ?line NewDog = test_server:timetrap(test_server:minutes(10)),
-    ?line io:format("Compiling (without optimization): ~s\n", [Src]),
-    ?line CompRc1 = compile:file(Src,
+    ct:timetrap(Timetrap),
+    io:format("Compiling (without optimization): ~s\n", [Src]),
+    CompRc1 = compile:file(Src,
 				 [no_copt,no_postopt,{outdir,Out},report|OtherOpts]),
 
-    ?line io:format("Result: ~p\n",[CompRc1]),
-    ?line {ok,_Mod} = CompRc1,
-    ?line ok = rpc:call(Node, ?MODULE, load_and_call, [Out, Module]),
-    ?line test_server:timetrap_cancel(NewDog),
+    io:format("Result: ~p\n",[CompRc1]),
+    {ok,_Mod} = CompRc1,
+    ok = rpc:call(Node, ?MODULE, load_and_call, [Out, Module]),
 
-    ?line LastDog = test_server:timetrap(test_server:minutes(10)),
-    ?line io:format("Compiling (with old inliner): ~s\n", [Src]),
-    ?line CompRc2 = compile:file(Src, [{outdir,Out},report,bin_opt_info,
+    ct:timetrap(Timetrap),
+    io:format("Compiling (with old inliner): ~s\n", [Src]),
+    CompRc2 = compile:file(Src, [{outdir,Out},report,bin_opt_info,
 				       {inline,1000}|OtherOpts]),
-    ?line io:format("Result: ~p\n",[CompRc2]),
-    ?line {ok,_Mod} = CompRc2,
-    ?line ok = rpc:call(Node, ?MODULE, load_and_call, [Out, Module]),
-    ?line test_server:timetrap_cancel(LastDog),
+    io:format("Result: ~p\n",[CompRc2]),
+    {ok,_Mod} = CompRc2,
+    ok = rpc:call(Node, ?MODULE, load_and_call, [Out, Module]),
 
-    AsmDog = test_server:timetrap(test_server:minutes(10)),
+    ct:timetrap(Timetrap),
     io:format("Compiling (from assembly): ~s\n", [Src]),
     {ok,_} = compile:file(Src, [to_asm,{outdir,Out},report|OtherOpts]),
     Asm = filename:join(Out, lists:concat([Module, ".S"])),
@@ -286,28 +287,26 @@ try_it(StartNode, Module, Conf) ->
     io:format("Result: ~p\n",[CompRc3]),
     {ok,_} = CompRc3,
     ok = rpc:call(Node, ?MODULE, load_and_call, [Out, Module]),
-    test_server:timetrap_cancel(AsmDog),
 
     case StartNode of
 	false -> ok;
-	true -> ?line test_server:stop_node(Node)
+	true -> test_server:stop_node(Node)
     end,
-    ?line test_server:timetrap_cancel(LastDog),
     ok.
 
 load_and_call(Out, Module) ->
-    ?line io:format("Loading...\n",[]),
-    ?line {module,Module} = code:load_abs(filename:join(Out, Module)),
+    io:format("Loading...\n",[]),
+    {module,Module} = code:load_abs(filename:join(Out, Module)),
 
-    ?line io:format("Calling...\n",[]),
+    io:format("Calling...\n",[]),
     %% Call M:M, and expect ok back, that's our interface
-    ?line CallRc = Module:Module(),
-    ?line io:format("Got value: ~p\n",[CallRc]),
+    CallRc = Module:Module(),
+    io:format("Got value: ~p\n",[CallRc]),
 
-    ?line ok = CallRc,
+    ok = CallRc,
 
     %% Smoke-test of beam disassembler.
-    ?line test_lib:smoke_disasm(Module),
+    test_lib:smoke_disasm(Module),
 
     _ = code:delete(Module),
     _ = code:purge(Module),
@@ -330,7 +329,7 @@ start_node(Name, Args) ->
 	{ok, Node} ->
 	    {ok, Node};
 	Error  ->
-	    ?line test_server:fail(Error)
+	    ct:fail(Error)
     end.
 
 from(H, [H | T]) -> T;
@@ -338,84 +337,78 @@ from(H, [_ | T]) -> from(H, T);
 from(_, []) -> [].
 
 
-vsn_1(doc) ->
-    "Test generation of 'vsn' attribute";
-vsn_1(suite) -> [];
+%% Test generation of 'vsn' attribute.
 vsn_1(Conf) when is_list(Conf) ->
-    ?line M = vsn_1,
-
-    ?line compile_load(M, ?config(data_dir, Conf), Conf),
-    ?line Vsn1 = get_vsn(M),
-    ?line timer:sleep(1000),
-
-    ?line compile_load(M, ?config(data_dir, Conf), Conf),
-    ?line Vsn2 = get_vsn(M),
-
-    ?line compile_load(M, filename:join(?config(data_dir, Conf), "other"),
-		       Conf),
-    ?line Vsn3 = get_vsn(M),
-    ?line if
-	      Vsn1 == Vsn2, Vsn2 == Vsn3 ->
-		  ok;
-	      true ->
-		  test_server:fail({vsn, Vsn1, Vsn2, Vsn3})
-	  end,
+    M = vsn_1,
+
+    compile_load(M, proplists:get_value(data_dir, Conf), Conf),
+    Vsn1 = get_vsn(M),
+    timer:sleep(1000),
+
+    compile_load(M, proplists:get_value(data_dir, Conf), Conf),
+    Vsn2 = get_vsn(M),
+
+    compile_load(M, filename:join(proplists:get_value(data_dir, Conf),
+				  "other"),
+		 Conf),
+    Vsn3 = get_vsn(M),
+    if
+	Vsn1 == Vsn2, Vsn2 == Vsn3 ->
+	    ok;
+	true ->
+	    ct:fail({vsn, Vsn1, Vsn2, Vsn3})
+    end,
     ok.
 
-vsn_2(doc) ->
-    "Test overriding of generation of 'vsn' attribute";
-vsn_2(suite) -> [];
+%% Test overriding of generation of 'vsn' attribute.
 vsn_2(Conf) when is_list(Conf) ->
-    ?line M = vsn_2,
-
-    ?line compile_load(M, ?config(data_dir, Conf), Conf),
-    ?line Vsn = get_vsn(M),
-    ?line case Vsn of
-	      [34] ->
-		  ok;
-	      _ ->
-		  test_server:fail({vsn, Vsn})
-	  end,
+    M = vsn_2,
+
+    compile_load(M, proplists:get_value(data_dir, Conf), Conf),
+    Vsn = get_vsn(M),
+    case Vsn of
+	[34] ->
+	    ok;
+	_ ->
+	    ct:fail({vsn, Vsn})
+    end,
     ok.
 
-vsn_3(doc) ->
-    "Test that different code yields different generated 'vsn'";
-vsn_3(suite) -> [];
+%% Test that different code yields different generated 'vsn'.
 vsn_3(Conf) when is_list(Conf) ->
-    ?line M = vsn_3,
-
-    ?line compile_load(M, ?config(data_dir, Conf), Conf),
-    ?line Vsn1 = get_vsn(M),
-
-    ?line compile_load(M, filename:join(?config(data_dir, Conf), "other"),
-		       Conf),
-    ?line Vsn2 = get_vsn(M),
-    ?line if
-	      Vsn1 /= Vsn2 ->
-		  ok;
-	      true ->
-		  test_server:fail({vsn, Vsn1, Vsn2})
-	  end,
+    M = vsn_3,
+
+    compile_load(M, proplists:get_value(data_dir, Conf), Conf),
+    Vsn1 = get_vsn(M),
+
+    compile_load(M, filename:join(proplists:get_value(data_dir, Conf),
+				  "other"),
+		 Conf),
+    Vsn2 = get_vsn(M),
+    if
+	Vsn1 /= Vsn2 ->
+	    ok;
+	true ->
+	    ct:fail({vsn, Vsn1, Vsn2})
+    end,
     ok.
 
 get_vsn(M) ->
-    {value, {vsn, V}} = lists:keysearch(vsn, 1, M:module_info(attributes)),
+    {vsn,V} = lists:keyfind(vsn, 1, M:module_info(attributes)),
     V.
 
 long_string(Config) when is_list(Config) ->
     %% The test must complete in one minute - it should be plenty of time.
-    ?line Dog = test_server:timetrap(test_server:minutes(1)),
-    ?line try_it(long_string, Config),
-    ?line test_server:timetrap_cancel(Dog),
+    try_it(false, long_string, {minutes,1}, Config),
     ok.
 
 compile_load(Module, Dir, Conf) ->
-    ?line Src = filename:join(Dir, atom_to_list(Module)),
-    ?line Out = ?config(priv_dir,Conf),
-    ?line CompRc = compile:file(Src, [{outdir,Out}]),
-    ?line {ok, Module} = CompRc,
-    ?line code:purge(Module),
-    ?line {module, Module} =
+    Src = filename:join(Dir, atom_to_list(Module)),
+    Out = proplists:get_value(priv_dir,Conf),
+    CompRc = compile:file(Src, [{outdir,Out}]),
+    {ok, Module} = CompRc,
+    code:purge(Module),
+    {module, Module} =
 	code:load_abs(filename:join(Out, atom_to_list(Module))),
     ok.
 
@@ -428,9 +421,9 @@ self_compile_old_inliner(Config) when is_list(Config) ->
     self_compile_1(Config, "old", [verbose,{inline,500}]).
 
 self_compile_1(Config, Prefix, Opts) ->
-    Dog = test_server:timetrap(test_server:minutes(40)),
+    ct:timetrap({minutes,40}),
 
-    Priv = ?config(priv_dir,Config),
+    Priv = proplists:get_value(priv_dir,Config),
     Version = compiler_version(),
 
     %% Compile the compiler. (In this node to get better coverage.)
@@ -449,11 +442,10 @@ self_compile_1(Config, Prefix, Opts) ->
     %% be equal (except for beam_asm that contains the compiler version).
     compare_compilers(CompA, CompB),
 
-    test_server:timetrap_cancel(Dog),
     ok.
 
 self_compile_node(CompilerDir, OutDir, Version, Opts) ->
-    Dog = test_server:timetrap(test_server:minutes(15)),
+    ct:timetrap({minutes,15}),
     Pa = "-pa " ++ filename:dirname(code:which(?MODULE)) ++
 	" -pa " ++ CompilerDir,
     Files = compiler_src(),
@@ -462,11 +454,11 @@ self_compile_node(CompilerDir, OutDir, Version, Opts) ->
     %% because it will load the same cover-compiled code as on this
     %% node. Use a shielded node to prevent the cover server from
     %% being started.
-    ?t:run_on_shielded_node(
-       fun() ->
-	       compile_compiler(Files, OutDir, Version, Opts)
-       end, Pa),
-    test_server:timetrap_cancel(Dog),
+    test_server:run_on_shielded_node(
+      fun() ->
+	      compile_compiler(Files, OutDir, Version, Opts)
+      end, Pa),
+
     ok.
 
 compile_compiler(Files, OutDir, Version, InlineOpts) ->
@@ -619,11 +611,11 @@ otp_7345(ObjRef, _RdEnv, Args) ->
 %% Check the generation of the string table.
 
 string_table(Config) when is_list(Config) ->
-    ?line DataDir = ?config(data_dir, Config),
-    ?line File = filename:join(DataDir, "string_table.erl"),
-    ?line {ok,string_table,Beam,[]} = compile:file(File, [return, binary]),
-    ?line {ok,{string_table,[StringTableChunk]}} = beam_lib:chunks(Beam, ["StrT"]),
-    ?line {"StrT", <<"stringtable">>} = StringTableChunk,
+    DataDir = proplists:get_value(data_dir, Config),
+    File = filename:join(DataDir, "string_table.erl"),
+    {ok,string_table,Beam,[]} = compile:file(File, [return, binary]),
+    {ok,{string_table,[StringTableChunk]}} = beam_lib:chunks(Beam, ["StrT"]),
+    {"StrT", <<"stringtable">>} = StringTableChunk,
     ok.
 
 otp_8949_a(Config) when is_list(Config) ->
@@ -650,8 +642,8 @@ do_otp_8949_a() ->
     
 otp_8949_b(Config) when is_list(Config) ->
     self() ! something,
-    ?line value = otp_8949_b([], false),
-    ?line {'EXIT',_} = (catch otp_8949_b([], true)),
+    value = otp_8949_b([], false),
+    {'EXIT',_} = (catch otp_8949_b([], true)),
     ok.
 
 %% Would cause an endless loop in beam_utils.