Remove ?line macros

1 files changed, 73 insertions, 73 deletions

diff --git a/erts/emulator/test/after_SUITE.erl b/erts/emulator/test/after_SUITE.erl
index 4efc3b68a0..a72cd8deea 100644
--- a/erts/emulator/test/after_SUITE.erl
+++ b/erts/emulator/test/after_SUITE.erl
@@ -45,43 +45,43 @@ all() ->
 
 %% Tests for an old round-off error in 'receive after'."
 t_after(Config) when is_list(Config) ->
-    ?line spawn(fun frequent_process/0),
-    ?line Period = test_server:minutes(1),
-    ?line Before = erlang:monotonic_time(),
+    spawn(fun frequent_process/0),
+    Period = test_server:minutes(1),
+    Before = erlang:monotonic_time(),
     receive
-	after Period ->
-		?line After = erlang:monotonic_time(),
-		?line report(Period, Before, After)
-	end.
+    after Period ->
+                After = erlang:monotonic_time(),
+                report(Period, Before, After)
+    end.
 
 report(Period, Before, After) ->
     case erlang:convert_time_unit(After - Before, native, 100*1000) / Period of
-	Percent when Percent > 100.10 ->
-	    ct:fail({too_inaccurate, Percent});
-	Percent when Percent < 100.0 ->
-	    ct:fail({too_early, Percent});
-	Percent ->
-	    Comment = io_lib:format("Elapsed/expected: ~.2f %", [Percent]),
-	    {comment, lists:flatten(Comment)}
+        Percent when Percent > 100.10 ->
+            ct:fail({too_inaccurate, Percent});
+        Percent when Percent < 100.0 ->
+            ct:fail({too_early, Percent});
+        Percent ->
+            Comment = io_lib:format("Elapsed/expected: ~.2f %", [Percent]),
+            {comment, lists:flatten(Comment)}
     end.
 
 frequent_process() ->
     receive
-	after 100 ->
-		?line frequent_process()
-	end.
+    after 100 ->
+              frequent_process()
+    end.
 
 %%  Test that 'receive after' works (doesn't hang).
 %%  The test takes 10 seconds to complete.
 receive_after(Config) when is_list(Config) ->
-    ?line receive_after1(5000).
+    receive_after1(5000).
 
 receive_after1(1) ->
-    ?line io:format("Testing: receive after ~p~n", [1]), 
-    ?line receive after 1 -> ok end;
+    io:format("Testing: receive after ~p~n", [1]), 
+    receive after 1 -> ok end;
 receive_after1(N) -> 
-    ?line io:format("Testing: receive after ~p~n", [N]), 
-    ?line receive after N -> receive_after1(N div 2) end.
+    io:format("Testing: receive after ~p~n", [N]), 
+    receive after N -> receive_after1(N div 2) end.
 
 receive_after_big(Config) when is_list(Config) ->
     %% Test that 'receive after' with a 32 bit number works.
@@ -93,14 +93,14 @@ receive_after_big1(Timeout) ->
     erlang:yield(),
     spawn(fun() -> Self ! here_is_a_message end),
     ok = receive
-	     here_is_a_message ->
-		 ok
-	 after Timeout ->
-		 %% We test that the timeout can be set,
-		 %% not that an timeout occurs after the appropriate delay
-		 %% (48 days, 56 minutes, 48 seconds)!
-		 timeout
-	 end.
+             here_is_a_message ->
+                 ok
+         after Timeout ->
+                   %% We test that the timeout can be set,
+                   %% not that an timeout occurs after the appropriate delay
+                   %% (48 days, 56 minutes, 48 seconds)!
+                   timeout
+         end.
 
 receive_after_big2() ->
     Self = self(),
@@ -121,16 +121,16 @@ receive_after_big2() ->
 
 %% Test error cases for 'receive after'.
 receive_after_errors(Config) when is_list(Config) ->
-    ?line ?TryAfter(-1),
-    ?line ?TryAfter(0.0),
-    ?line ?TryAfter(3.14),
-    ?line ?TryAfter(16#100000000),
-    ?line ?TryAfter(392347129847294724972398472984729847129874),
-    ?line ?TryAfter(16#3fffffffffffffff),
-    ?line ?TryAfter(16#ffffffffffffffff),
-    ?line ?TryAfter(-16#100000000),
-    ?line ?TryAfter(-3891278094774921784123987129848),
-    ?line ?TryAfter(xxx),
+    ?TryAfter(-1),
+    ?TryAfter(0.0),
+    ?TryAfter(3.14),
+    ?TryAfter(16#100000000),
+    ?TryAfter(392347129847294724972398472984729847129874),
+    ?TryAfter(16#3fffffffffffffff),
+    ?TryAfter(16#ffffffffffffffff),
+    ?TryAfter(-16#100000000),
+    ?TryAfter(-3891278094774921784123987129848),
+    ?TryAfter(xxx),
     ok.
 
 try_after(Timeout) ->
@@ -142,12 +142,12 @@ receive_var_zero(Config) when is_list(Config) ->
     self() ! y,
     Z = zero(),
     timeout = receive
-		  z -> ok
-	      after Z -> timeout
-	      end,
+                  z -> ok
+              after Z -> timeout
+              end,
     timeout = receive
-	      after Z -> timeout
-	      end,
+              after Z -> timeout
+              end,
     self() ! w,
     receive
 	x -> ok;
@@ -162,43 +162,43 @@ receive_zero(Config) when is_list(Config) ->
     self() ! x,
     self() ! y,
     timeout = receive
-		  z -> ok
-	      after 0 ->
-		      timeout
-	      end,
+                  z -> ok
+              after 0 ->
+                        timeout
+              end,
     self() ! w,
     timeout = receive
               after 0 -> timeout
               end,
     receive
-	x -> ok;
-	Other ->
-	    ct:fail({bad_message,Other})
+        x -> ok;
+        Other ->
+            ct:fail({bad_message,Other})
     end.
 
 %% Test for catching invalid assertion in erl_message.c (in queue_message)
 %% This failed (dumped core) with debug-compiled emulator.
 multi_timeout(Config) when is_list(Config) ->
-    ?line P = spawn(?MODULE, timeout_g, []),
-    ?line P ! a,
-    ?line P ! b,
-    ?line receive
-	  after 1000 -> ok
-	  end,
-    ?line P ! c,
-    ?line receive
-	  after 1000 -> ok
-	  end,
-    ?line P ! d,
+    P = spawn(?MODULE, timeout_g, []),
+    P ! a,
+    P ! b,
+    receive
+    after 1000 -> ok
+    end,
+    P ! c,
+    receive
+    after 1000 -> ok
+    end,
+    P ! d,
     ok.
 
 timeout_g() ->
-    ?line receive
-	a -> ok
+    receive
+        a -> ok
+    end,
+    receive
+    after 100000 -> ok
     end,
-    ?line receive
-	  after 100000 -> ok
-	  end,
     ok.
 
 %% OTP-7493: Timeout for 32 bit numbers (such as 16#ffffFFFF) could
@@ -237,8 +237,8 @@ receive_after_blast(Config) when is_list(Config) ->
     TimeoutTime = erlang:monotonic_time(milli_seconds) + 5000,
     lists:foreach(fun ({P, _}) -> P ! {go, TimeoutTime} end, PMs),
     lists:foreach(fun ({P, M}) ->
-			  receive
-			      {'DOWN', M, process, P, normal} ->
-				  ok
-			  end
-		  end, PMs).
+                          receive
+                              {'DOWN', M, process, P, normal} ->
+                                  ok
+                          end
+                  end, PMs).