Remove ?line macros

1 files changed, 120 insertions, 125 deletions

diff --git a/erts/emulator/test/z_SUITE.erl b/erts/emulator/test/z_SUITE.erl
index 755fa5ea99..93a03e8f91 100644
--- a/erts/emulator/test/z_SUITE.erl
+++ b/erts/emulator/test/z_SUITE.erl
@@ -52,97 +52,95 @@ all() ->
 
 %% Tests that all schedulers are actually used
 schedulers_alive(Config) when is_list(Config) ->
-    ?line Master = self(),
-    ?line NoSchedulersOnline = erlang:system_flag(
-				 schedulers_online,
-				 erlang:system_info(schedulers)),
-    ?line NoSchedulers = erlang:system_info(schedulers),
+    Master = self(),
+    NoSchedulersOnline = erlang:system_flag(
+                           schedulers_online,
+                           erlang:system_info(schedulers)),
+    NoSchedulers = erlang:system_info(schedulers),
     UsedScheds =
-	try
-	    ?line io:format("Number of schedulers configured: ~p~n", [NoSchedulers]),
-	    ?line case erlang:system_info(multi_scheduling) of
-		      blocked ->
-			  ?line ct:fail(multi_scheduling_blocked);
-		      disabled ->
-			  ?line ok;
-		      enabled ->
-			  io:format("Testing blocking process exit~n"),
-			  BF = fun () ->
-				       blocked = erlang:system_flag(multi_scheduling,
-								    block),
-				       Master ! {self(), blocking},
-				       receive after infinity -> ok end
-			       end,
-			  ?line Blocker = spawn_link(BF),
-			  ?line Mon = erlang:monitor(process, Blocker),
-			  ?line receive {Blocker, blocking} -> ok end,
-			  ?line [Blocker]
-			      = erlang:system_info(multi_scheduling_blockers),
-			  ?line unlink(Blocker),
-			  ?line exit(Blocker, kill),
-			  ?line receive {'DOWN', Mon, _, _, _} -> ok end,
-			  ?line enabled = erlang:system_info(multi_scheduling),
-			  ?line [] = erlang:system_info(multi_scheduling_blockers),
-			  ?line ok
-		  end,
-	    io:format("Testing blocked~n"),
-	    ?line erlang:system_flag(multi_scheduling, block),
-	    ?line case erlang:system_info(multi_scheduling) of
-		      enabled ->
-			  ?line ct:fail(multi_scheduling_enabled);
-		      blocked ->
-			  ?line [Master] = erlang:system_info(multi_scheduling_blockers);
-		      disabled -> ?line ok
-		  end,
-	    ?line Ps = lists:map(
-			 fun (_) ->
-				 spawn_link(fun () ->
-						    run_on_schedulers(none,
-								      [],
-								      Master)
-					    end)
-			 end,
-			 lists:seq(1,NoSchedulers)),
-	    ?line receive after 1000 -> ok end,
-	    ?line {_, 1} = verify_all_schedulers_used({[],0}, 1),
-	    ?line lists:foreach(fun (P) ->
-					unlink(P),
-					exit(P, bang)
-				end,
-				Ps),
-	    ?line case erlang:system_flag(multi_scheduling, unblock) of
-		      blocked -> ?line ct:fail(multi_scheduling_blocked);
-		      disabled -> ?line ok;
-		      enabled -> ?line ok
-		  end,
-	    erts_debug:set_internal_state(available_internal_state, true),
-	    %% node_and_dist_references will use emulator interal thread blocking...
-	    erts_debug:get_internal_state(node_and_dist_references), 
-	    erts_debug:set_internal_state(available_internal_state, false),
-	    io:format("Testing not blocked~n"),
-	    ?line Ps2 = lists:map(
-			  fun (_) ->
-				  spawn_link(fun () ->
-						     run_on_schedulers(none,
-								       [],
-								       Master)
-					     end)
-			  end,
-			  lists:seq(1,NoSchedulers)),
-	    ?line receive after 1000 -> ok end,
-	    ?line {_, NoSIDs} = verify_all_schedulers_used({[],0},NoSchedulers),
-	    ?line lists:foreach(fun (P) ->
-					unlink(P),
-					exit(P, bang)
-				end,
-				Ps2),
-	    NoSIDs
-	after
-	    NoSchedulers = erlang:system_flag(schedulers_online,
-					      NoSchedulersOnline),
-	    NoSchedulersOnline = erlang:system_info(schedulers_online)
-	end,
-    ?line {comment, "Number of schedulers " ++ integer_to_list(UsedScheds)}.
+      try
+          io:format("Number of schedulers configured: ~p~n", [NoSchedulers]),
+          case erlang:system_info(multi_scheduling) of
+              blocked ->
+                  ct:fail(multi_scheduling_blocked);
+              disabled ->
+                  ok;
+              enabled ->
+                  io:format("Testing blocking process exit~n"),
+                  BF = fun () ->
+                               blocked = erlang:system_flag(multi_scheduling,
+                                                            block),
+                               Master ! {self(), blocking},
+                               receive after infinity -> ok end
+                       end,
+                  Blocker = spawn_link(BF),
+                  Mon = erlang:monitor(process, Blocker),
+                  receive {Blocker, blocking} -> ok end,
+                  [Blocker]
+                  = erlang:system_info(multi_scheduling_blockers),
+                  unlink(Blocker),
+                  exit(Blocker, kill),
+                  receive {'DOWN', Mon, _, _, _} -> ok end,
+                  enabled = erlang:system_info(multi_scheduling),
+                  [] = erlang:system_info(multi_scheduling_blockers),
+                  ok
+          end,
+          io:format("Testing blocked~n"),
+          erlang:system_flag(multi_scheduling, block),
+          case erlang:system_info(multi_scheduling) of
+              enabled ->
+                  ct:fail(multi_scheduling_enabled);
+              blocked ->
+                  [Master] = erlang:system_info(multi_scheduling_blockers);
+              disabled -> ok
+          end,
+          Ps = lists:map(
+                 fun (_) ->
+                         spawn_link(fun () ->
+                                            run_on_schedulers(none,
+                                                              [],
+                                                              Master)
+                                    end)
+                 end,
+                 lists:seq(1,NoSchedulers)),
+          receive after 1000 -> ok end,
+          {_, 1} = verify_all_schedulers_used({[],0}, 1),
+          lists:foreach(fun (P) ->
+                                unlink(P),
+                                exit(P, bang)
+                        end, Ps),
+          case erlang:system_flag(multi_scheduling, unblock) of
+              blocked -> ct:fail(multi_scheduling_blocked);
+              disabled -> ok;
+              enabled -> ok
+          end,
+          erts_debug:set_internal_state(available_internal_state, true),
+          %% node_and_dist_references will use emulator interal thread blocking...
+          erts_debug:get_internal_state(node_and_dist_references), 
+          erts_debug:set_internal_state(available_internal_state, false),
+          io:format("Testing not blocked~n"),
+          Ps2 = lists:map(
+                  fun (_) ->
+                          spawn_link(fun () ->
+                                             run_on_schedulers(none,
+                                                               [],
+                                                               Master)
+                                     end)
+                  end,
+                  lists:seq(1,NoSchedulers)),
+          receive after 1000 -> ok end,
+          {_, NoSIDs} = verify_all_schedulers_used({[],0},NoSchedulers),
+          lists:foreach(fun (P) ->
+                                unlink(P),
+                                exit(P, bang)
+                        end, Ps2),
+          NoSIDs
+      after
+          NoSchedulers = erlang:system_flag(schedulers_online,
+                                            NoSchedulersOnline),
+          NoSchedulersOnline = erlang:system_info(schedulers_online)
+      end,
+        {comment, "Number of schedulers " ++ integer_to_list(UsedScheds)}.
 
 
 run_on_schedulers(LastSID, SIDs, ReportTo) ->
@@ -175,50 +173,50 @@ wait_on_used_scheduler({SIDs, SIDsLen} = State) ->
     end.
 
 verify_all_schedulers_used({UsedSIDs, UsedSIDsLen} = State, NoSchedulers) ->
-    ?line case NoSchedulers of
+    case NoSchedulers of
 	      UsedSIDsLen ->
-		  ?line State;
+		  State;
 	      NoSchdlrs when NoSchdlrs < UsedSIDsLen ->
-		  ?line ct:fail({more_schedulers_used_than_exist,
+		  ct:fail({more_schedulers_used_than_exist,
 				 {existing_schedulers, NoSchdlrs},
 				 {used_schedulers, UsedSIDsLen},
 				 {used_scheduler_ids, UsedSIDs}});
 	      _ ->
-		  ?line NewState = wait_on_used_scheduler(State),
-		  ?line verify_all_schedulers_used(NewState, NoSchedulers)
+		  NewState = wait_on_used_scheduler(State),
+		  verify_all_schedulers_used(NewState, NoSchedulers)
 	  end.
 
 node_container_refc_check(Config) when is_list(Config) ->
-    ?line node_container_SUITE:node_container_refc_check(node()),
-    ?line ok.
+    node_container_SUITE:node_container_refc_check(node()),
+    ok.
 
 long_timers(Config) when is_list(Config) ->
-    ?line ok = long_timers_test:check_result().
+    ok = long_timers_test:check_result().
 
 pollset_size(Config) when is_list(Config) ->
-    ?line Name = pollset_size_testcase_initial_state_holder,
-    ?line Mon = erlang:monitor(process, Name),
-    ?line (catch Name ! {get_initial_check_io_result, self()}),
-    ?line InitChkIo = receive
+    Name = pollset_size_testcase_initial_state_holder,
+    Mon = erlang:monitor(process, Name),
+    (catch Name ! {get_initial_check_io_result, self()}),
+    InitChkIo = receive
 			  {initial_check_io_result, ICIO} ->
-			      ?line erlang:demonitor(Mon, [flush]),
-			      ?line ICIO;
+			      erlang:demonitor(Mon, [flush]),
+			      ICIO;
 			  {'DOWN', Mon, _, _, Reason} ->
-			      ?line ct:fail({non_existing, Name, Reason})
+			      ct:fail({non_existing, Name, Reason})
 		      end,
-    ?line FinChkIo = get_check_io_info(),
-    ?line io:format("Initial: ~p~nFinal: ~p~n", [InitChkIo, FinChkIo]),
-    ?line InitPollsetSize = lists:keysearch(total_poll_set_size, 1, InitChkIo),
-    ?line FinPollsetSize = lists:keysearch(total_poll_set_size, 1, FinChkIo),
+    FinChkIo = get_check_io_info(),
+    io:format("Initial: ~p~nFinal: ~p~n", [InitChkIo, FinChkIo]),
+    InitPollsetSize = lists:keysearch(total_poll_set_size, 1, InitChkIo),
+    FinPollsetSize = lists:keysearch(total_poll_set_size, 1, FinChkIo),
     HasGethost = case has_gethost() of true -> 1; _ -> 0 end,
-    ?line case InitPollsetSize =:= FinPollsetSize of
+    case InitPollsetSize =:= FinPollsetSize of
 	      true ->
 		  case InitPollsetSize of
 		      {value, {total_poll_set_size, Size}} ->
-			  ?line {comment,
+			  {comment,
 				 "Pollset size: " ++ integer_to_list(Size)};
 		      _ ->
-			  ?line {skipped,
+			  {skipped,
 				 "Pollset size information not available"}
 		  end;
 	      false ->
@@ -227,13 +225,13 @@ pollset_size(Config) when is_list(Config) ->
 		  %% that is ok as long as there are at least 2
 		  %% descriptors (dist listen socket and
 		  %% epmd socket) in the pollset.
-		  ?line {value, {total_poll_set_size, InitSize}}
+		  {value, {total_poll_set_size, InitSize}}
 		      = InitPollsetSize,
-		  ?line {value, {total_poll_set_size, FinSize}}
+		  {value, {total_poll_set_size, FinSize}}
 		      = FinPollsetSize,
-		  ?line true = FinSize < (InitSize + HasGethost),
-		  ?line true = 2 =< FinSize,
-		  ?line {comment,
+		  true = FinSize < (InitSize + HasGethost),
+		  true = 2 =< FinSize,
+		  {comment,
 			 "Start pollset size: "
 			 ++ integer_to_list(InitSize)
 			 ++ " End pollset size: "
@@ -241,9 +239,9 @@ pollset_size(Config) when is_list(Config) ->
 	  end.
 
 check_io_debug(Config) when is_list(Config) ->
-    ?line case lists:keysearch(name, 1, erlang:system_info(check_io)) of
-	      {value, {name, erts_poll}} -> ?line check_io_debug_test();
-	      _ -> ?line {skipped, "Not implemented in this emulator"}
+    case lists:keysearch(name, 1, erlang:system_info(check_io)) of
+	      {value, {name, erts_poll}} -> check_io_debug_test();
+	      _ -> {skipped, "Not implemented in this emulator"}
 	  end.
 
 check_io_debug_test() ->
@@ -266,8 +264,8 @@ check_io_debug_test() ->
             %% port returns an EAGAIN
             ok
     end,
-    ?line 0 = NoDrvEvStructs,
-    ?line ok.
+    0 = NoDrvEvStructs,
+    ok.
 
 has_gethost() ->
     has_gethost(erlang:ports()).
@@ -313,6 +311,3 @@ get_check_io_info() ->
 	    receive after 100 -> ok end,
 	    get_check_io_info()
     end.
-
-
-