Remove ?line macros

1 files changed, 561 insertions, 563 deletions

diff --git a/erts/emulator/test/nif_SUITE.erl b/erts/emulator/test/nif_SUITE.erl
index c5921ca859..84f5699890 100644
--- a/erts/emulator/test/nif_SUITE.erl
+++ b/erts/emulator/test/nif_SUITE.erl
@@ -22,7 +22,7 @@
 
 %%-define(line_trace,true).
 -define(CHECK(Exp,Got), check(Exp,Got,?LINE)).
-%%-define(CHECK(Exp,Got), ?line Exp = Got).
+%%-define(CHECK(Exp,Got), Exp = Got).
 
 -include_lib("common_test/include/ct.hrl").
 
@@ -42,8 +42,7 @@
 	 dirty_nif_exception/1, call_dirty_nif_exception/1, nif_schedule/1,
 	 nif_exception/1, call_nif_exception/1,
 	 nif_nan_and_inf/1, nif_atom_too_long/1,
-	 nif_monotonic_time/1, nif_time_offset/1, nif_convert_time_unit/1
-	]).
+	 nif_monotonic_time/1, nif_time_offset/1, nif_convert_time_unit/1]).
 
 -export([many_args_100/100]).
 
@@ -88,10 +87,10 @@ end_per_testcase(_Func, _Config) ->
 %% Basic smoke test of load_nif and a simple NIF call
 basic(Config) when is_list(Config) ->
     ensure_lib_loaded(Config),
-    ?line true = (lib_version() =/= undefined),
-    ?line [{load,1,1,101},{lib_version,1,2,102}] = call_history(),
-    ?line [] = call_history(),
-    ?line true = lists:member(?MODULE, erlang:system_info(taints)),
+    true = (lib_version() =/= undefined),
+    [{load,1,1,101},{lib_version,1,2,102}] = call_history(),
+    [] = call_history(),
+    true = lists:member(?MODULE, erlang:system_info(taints)),
     ok.
 
 %% Test reload callback in nif lib
@@ -99,34 +98,34 @@ reload(Config) when is_list(Config) ->
     TmpMem = tmpmem(),
     ensure_lib_loaded(Config),
 
-    ?line Data = proplists:get_value(data_dir, Config),
-    ?line File = filename:join(Data, "nif_mod"),
-    ?line {ok,nif_mod,Bin} = compile:file(File, [binary,return_errors]),
-    ?line {module,nif_mod} = erlang:load_module(nif_mod,Bin),
+    Data = proplists:get_value(data_dir, Config),
+    File = filename:join(Data, "nif_mod"),
+    {ok,nif_mod,Bin} = compile:file(File, [binary,return_errors]),
+    {module,nif_mod} = erlang:load_module(nif_mod,Bin),
 
-    ?line ok = nif_mod:load_nif_lib(Config, 1),
+    ok = nif_mod:load_nif_lib(Config, 1),
 
-    ?line hold_nif_mod_priv_data(nif_mod:get_priv_data_ptr()),
-    ?line [{load,1,1,101},{get_priv_data_ptr,1,2,102}] = nif_mod_call_history(),    
+    hold_nif_mod_priv_data(nif_mod:get_priv_data_ptr()),
+    [{load,1,1,101},{get_priv_data_ptr,1,2,102}] = nif_mod_call_history(),    
         
-    ?line ok = nif_mod:load_nif_lib(Config, 2),
-    ?line 2 = nif_mod:lib_version(),
-    ?line [{reload,2,1,201},{lib_version,2,2,202}] = nif_mod_call_history(),    
+    ok = nif_mod:load_nif_lib(Config, 2),
+    2 = nif_mod:lib_version(),
+    [{reload,2,1,201},{lib_version,2,2,202}] = nif_mod_call_history(),    
 
-    ?line ok = nif_mod:load_nif_lib(Config, 1),
-    ?line 1 = nif_mod:lib_version(),
-    ?line [{reload,1,1,101},{lib_version,1,2,102}] = nif_mod_call_history(),    
+    ok = nif_mod:load_nif_lib(Config, 1),
+    1 = nif_mod:lib_version(),
+    [{reload,1,1,101},{lib_version,1,2,102}] = nif_mod_call_history(),    
 
-    ?line true = erlang:delete_module(nif_mod),
-    ?line [] = nif_mod_call_history(),    
+    true = erlang:delete_module(nif_mod),
+    [] = nif_mod_call_history(),    
 
-    %%?line false= check_process_code(Pid, nif_mod),
-    ?line true = erlang:purge_module(nif_mod),
-    ?line [{unload,1,3,103}] = nif_mod_call_history(),    
+    %%false= check_process_code(Pid, nif_mod),
+    true = erlang:purge_module(nif_mod),
+    [{unload,1,3,103}] = nif_mod_call_history(),    
 
-    ?line true = lists:member(?MODULE, erlang:system_info(taints)),
-    ?line true = lists:member(nif_mod, erlang:system_info(taints)),
-    ?line verify_tmpmem(TmpMem),
+    true = lists:member(?MODULE, erlang:system_info(taints)),
+    true = lists:member(nif_mod, erlang:system_info(taints)),
+    verify_tmpmem(TmpMem),
     ok.
 
 %% Test upgrade callback in nif lib
@@ -134,89 +133,89 @@ upgrade(Config) when is_list(Config) ->
     TmpMem = tmpmem(),
     ensure_lib_loaded(Config),
 
-    ?line Data = proplists:get_value(data_dir, Config),
-    ?line File = filename:join(Data, "nif_mod"),
-    ?line {ok,nif_mod,Bin} = compile:file(File, [binary,return_errors]),
-    ?line {module,nif_mod} = erlang:load_module(nif_mod,Bin),
+    Data = proplists:get_value(data_dir, Config),
+    File = filename:join(Data, "nif_mod"),
+    {ok,nif_mod,Bin} = compile:file(File, [binary,return_errors]),
+    {module,nif_mod} = erlang:load_module(nif_mod,Bin),
 
-    ?line ok = nif_mod:load_nif_lib(Config, 1),
-    ?line {Pid,MRef} = nif_mod:start(),
-    ?line 1 = call(Pid,lib_version),
+    ok = nif_mod:load_nif_lib(Config, 1),
+    {Pid,MRef} = nif_mod:start(),
+    1 = call(Pid,lib_version),
 
-    ?line hold_nif_mod_priv_data(nif_mod:get_priv_data_ptr()),
-    ?line [{load,1,1,101},{lib_version,1,2,102},{get_priv_data_ptr,1,3,103}] = nif_mod_call_history(),    
+    hold_nif_mod_priv_data(nif_mod:get_priv_data_ptr()),
+    [{load,1,1,101},{lib_version,1,2,102},{get_priv_data_ptr,1,3,103}] = nif_mod_call_history(),    
         
     %% Module upgrade with same lib-version
-    ?line {module,nif_mod} = erlang:load_module(nif_mod,Bin),
-    ?line undefined = nif_mod:lib_version(),
-    ?line 1 = call(Pid,lib_version),
-    ?line [{lib_version,1,4,104}] = nif_mod_call_history(),
+    {module,nif_mod} = erlang:load_module(nif_mod,Bin),
+    undefined = nif_mod:lib_version(),
+    1 = call(Pid,lib_version),
+    [{lib_version,1,4,104}] = nif_mod_call_history(),
 
-    ?line ok = nif_mod:load_nif_lib(Config, 1),
-    ?line 1 = nif_mod:lib_version(),
-    ?line [{upgrade,1,5,105},{lib_version,1,6,106}] = nif_mod_call_history(),
+    ok = nif_mod:load_nif_lib(Config, 1),
+    1 = nif_mod:lib_version(),
+    [{upgrade,1,5,105},{lib_version,1,6,106}] = nif_mod_call_history(),
 
-    ?line upgraded = call(Pid,upgrade),
-    ?line false = check_process_code(Pid, nif_mod),
-    ?line true = erlang:purge_module(nif_mod),
-    ?line [{unload,1,7,107}] = nif_mod_call_history(),
+    upgraded = call(Pid,upgrade),
+    false = check_process_code(Pid, nif_mod),
+    true = erlang:purge_module(nif_mod),
+    [{unload,1,7,107}] = nif_mod_call_history(),
 
-    ?line 1 = nif_mod:lib_version(),
-    ?line [{lib_version,1,8,108}] = nif_mod_call_history(),
+    1 = nif_mod:lib_version(),
+    [{lib_version,1,8,108}] = nif_mod_call_history(),
 
-    ?line true = erlang:delete_module(nif_mod),
-    ?line [] = nif_mod_call_history(),    
+    true = erlang:delete_module(nif_mod),
+    [] = nif_mod_call_history(),    
 
-    ?line Pid ! die,
-    ?line {'DOWN', MRef, process, Pid, normal} = receive_any(),
-    ?line false = check_process_code(Pid, nif_mod),
-    ?line true = erlang:purge_module(nif_mod),
-    ?line [{unload,1,9,109}] = nif_mod_call_history(),    
+    Pid ! die,
+    {'DOWN', MRef, process, Pid, normal} = receive_any(),
+    false = check_process_code(Pid, nif_mod),
+    true = erlang:purge_module(nif_mod),
+    [{unload,1,9,109}] = nif_mod_call_history(),    
 
     %% Module upgrade with different lib version
-    ?line {module,nif_mod} = erlang:load_module(nif_mod,Bin),
-    ?line undefined = nif_mod:lib_version(),
-    ?line {Pid2,MRef2} = nif_mod:start(),
-    ?line undefined = call(Pid2,lib_version),
-
-    ?line ok = nif_mod:load_nif_lib(Config, 1),
-    ?line hold_nif_mod_priv_data(nif_mod:get_priv_data_ptr()),
-    ?line 1 = call(Pid2,lib_version),
-    ?line [{load,1,1,101},{get_priv_data_ptr,1,2,102},{lib_version,1,3,103}] = nif_mod_call_history(),
-
-    ?line {module,nif_mod} = erlang:load_module(nif_mod,Bin),
-    ?line undefined = nif_mod:lib_version(),
-    ?line [] = nif_mod_call_history(),
-    ?line 1 = call(Pid2,lib_version),
-    ?line [{lib_version,1,4,104}] = nif_mod_call_history(),
-
-    ?line ok = nif_mod:load_nif_lib(Config, 2),
-    ?line 2 = nif_mod:lib_version(),
-    ?line [{upgrade,2,1,201},{lib_version,2,2,202}] = nif_mod_call_history(),
-
-    ?line 1 = call(Pid2,lib_version),
-    ?line [{lib_version,1,5,105}] = nif_mod_call_history(),
-
-    ?line upgraded = call(Pid2,upgrade),
-    ?line false = check_process_code(Pid2, nif_mod),
-    ?line true = erlang:purge_module(nif_mod),
-    ?line [{unload,1,6,106}] = nif_mod_call_history(),
-
-    ?line 2 = nif_mod:lib_version(),
-    ?line [{lib_version,2,3,203}] = nif_mod_call_history(),
-
-    ?line true = erlang:delete_module(nif_mod),
-    ?line [] = nif_mod_call_history(),    
-
-    ?line Pid2 ! die,
-    ?line {'DOWN', MRef2, process, Pid2, normal} = receive_any(),
-    ?line false= check_process_code(Pid2, nif_mod),
-    ?line true = erlang:purge_module(nif_mod),
-    ?line [{unload,2,4,204}] = nif_mod_call_history(),    
-
-    ?line true = lists:member(?MODULE, erlang:system_info(taints)),
-    ?line true = lists:member(nif_mod, erlang:system_info(taints)),
-    ?line verify_tmpmem(TmpMem),
+    {module,nif_mod} = erlang:load_module(nif_mod,Bin),
+    undefined = nif_mod:lib_version(),
+    {Pid2,MRef2} = nif_mod:start(),
+    undefined = call(Pid2,lib_version),
+
+    ok = nif_mod:load_nif_lib(Config, 1),
+    hold_nif_mod_priv_data(nif_mod:get_priv_data_ptr()),
+    1 = call(Pid2,lib_version),
+    [{load,1,1,101},{get_priv_data_ptr,1,2,102},{lib_version,1,3,103}] = nif_mod_call_history(),
+
+    {module,nif_mod} = erlang:load_module(nif_mod,Bin),
+    undefined = nif_mod:lib_version(),
+    [] = nif_mod_call_history(),
+    1 = call(Pid2,lib_version),
+    [{lib_version,1,4,104}] = nif_mod_call_history(),
+
+    ok = nif_mod:load_nif_lib(Config, 2),
+    2 = nif_mod:lib_version(),
+    [{upgrade,2,1,201},{lib_version,2,2,202}] = nif_mod_call_history(),
+
+    1 = call(Pid2,lib_version),
+    [{lib_version,1,5,105}] = nif_mod_call_history(),
+
+    upgraded = call(Pid2,upgrade),
+    false = check_process_code(Pid2, nif_mod),
+    true = erlang:purge_module(nif_mod),
+    [{unload,1,6,106}] = nif_mod_call_history(),
+
+    2 = nif_mod:lib_version(),
+    [{lib_version,2,3,203}] = nif_mod_call_history(),
+
+    true = erlang:delete_module(nif_mod),
+    [] = nif_mod_call_history(),    
+
+    Pid2 ! die,
+    {'DOWN', MRef2, process, Pid2, normal} = receive_any(),
+    false= check_process_code(Pid2, nif_mod),
+    true = erlang:purge_module(nif_mod),
+    [{unload,2,4,204}] = nif_mod_call_history(),    
+
+    true = lists:member(?MODULE, erlang:system_info(taints)),
+    true = lists:member(nif_mod, erlang:system_info(taints)),
+    verify_tmpmem(TmpMem),
     ok.
 
 %% Test NIF building heap fragments
@@ -225,7 +224,7 @@ heap_frag(Config) when is_list(Config) ->
     ensure_lib_loaded(Config),
     
     heap_frag_do(1,1000000),
-    ?line verify_tmpmem(TmpMem),
+    verify_tmpmem(TmpMem),
     ok.
 
 heap_frag_do(N, Max) when N > Max ->
@@ -240,7 +239,7 @@ heap_frag_do(N, Max) ->
 types(Config) when is_list(Config) ->
     TmpMem = tmpmem(),
     ensure_lib_loaded(Config),
-    ?line ok = type_test(),
+    ok = type_test(),
     lists:foreach(fun(Tpl) ->
                     Lst = erlang:tuple_to_list(Tpl),                 
                     Lst = tuple_2_list(Tpl)
@@ -265,18 +264,18 @@ types(Config) when is_list(Config) ->
 			  R1 = echo_int(I),
 			  %%io:format("echo_int(~p) -> ~p\n", [I, R1]),
 			  R2 = my_echo_int(I, Limits),
-			  ?line R1 = R2,
-			  ?line true = (R1 =:= R2),
-			  ?line true = (R1 == R2)
+			  R1 = R2,
+			  true = (R1 =:= R2),
+			  true = (R1 == R2)
 		  end, int_list()),
 
-    ?line verify_tmpmem(TmpMem),
-    ?line true = (compare(-1294536544000, -1178704800000) < 0),
-    ?line true = (compare(-1178704800000, -1294536544000) > 0),
-    ?line true = (compare(-295147905179352825856, -36893488147419103232) < 0),
-    ?line true = (compare(-36893488147419103232, -295147905179352825856) > 0),
-    ?line true = (compare(-29514790517935282585612345678, -36893488147419103232) < 0),
-    ?line true = (compare(-36893488147419103232, -29514790517935282585612345678) > 0),
+    verify_tmpmem(TmpMem),
+    true = (compare(-1294536544000, -1178704800000) < 0),
+    true = (compare(-1178704800000, -1294536544000) > 0),
+    true = (compare(-295147905179352825856, -36893488147419103232) < 0),
+    true = (compare(-36893488147419103232, -295147905179352825856) > 0),
+    true = (compare(-29514790517935282585612345678, -36893488147419103232) < 0),
+    true = (compare(-36893488147419103232, -29514790517935282585612345678) > 0),
     ok.
 
 int_list() ->
@@ -306,13 +305,13 @@ eq_cmp(A,B) ->
 eq_cmp_do(A,B) ->
     %%io:format("compare ~p and ~p\n",[A,B]),
     Eq = (A =:= B),
-    ?line Eq = is_identical(A,B),
-    ?line Cmp = if
+    Eq = is_identical(A,B),
+    Cmp = if
             A < B -> -1;
             A == B -> 0;
             A > B -> 1
         end,
-    ?line Cmp = case compare(A,B) of
+    Cmp = case compare(A,B) of
                     C when is_integer(C), C < 0 -> -1;
                     0 -> 0;
                     C when is_integer(C) -> 1
@@ -323,42 +322,42 @@ eq_cmp_do(A,B) ->
 %% Test NIF with many arguments
 many_args(Config) when is_list(Config) ->
     TmpMem = tmpmem(),
-    ?line ensure_lib_loaded(Config ,1),
-    ?line ok = apply(?MODULE,many_args_100,lists:seq(1,100)),
-    ?line ok = many_args_100(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100),
-    ?line verify_tmpmem(TmpMem),
+    ensure_lib_loaded(Config ,1),
+    ok = apply(?MODULE,many_args_100,lists:seq(1,100)),
+    ok = many_args_100(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100),
+    verify_tmpmem(TmpMem),
     ok.
 
 %% Test NIF binary handling.
 binaries(Config) when is_list(Config) ->
     TmpMem = tmpmem(),
-    ?line ensure_lib_loaded(Config, 1),
-    ?line RefcBin = list_to_binary(lists:seq(1,255)),
-    ?line RefcBin = clone_bin(RefcBin),
-    ?line HeapBin = list_to_binary(lists:seq(1,20)),
-    ?line HeapBin = clone_bin(HeapBin),
-    ?line <<_:8,Sub1:6/binary,_/binary>> = RefcBin, 
-    ?line <<_:8,Sub2:6/binary,_/binary>> = HeapBin,
-    ?line Sub1 = Sub2,
-    ?line Sub1 = clone_bin(Sub1),
-    ?line Sub2 = clone_bin(Sub2),
-    ?line <<_:9,Sub3:6/binary,_/bitstring>> = RefcBin, 
-    ?line <<_:9,Sub4:6/binary,_/bitstring>> = HeapBin,
-    ?line Sub3 = Sub4,
-    ?line Sub3 = clone_bin(Sub3),
-    ?line Sub4 = clone_bin(Sub4),
+    ensure_lib_loaded(Config, 1),
+    RefcBin = list_to_binary(lists:seq(1,255)),
+    RefcBin = clone_bin(RefcBin),
+    HeapBin = list_to_binary(lists:seq(1,20)),
+    HeapBin = clone_bin(HeapBin),
+    <<_:8,Sub1:6/binary,_/binary>> = RefcBin, 
+    <<_:8,Sub2:6/binary,_/binary>> = HeapBin,
+    Sub1 = Sub2,
+    Sub1 = clone_bin(Sub1),
+    Sub2 = clone_bin(Sub2),
+    <<_:9,Sub3:6/binary,_/bitstring>> = RefcBin, 
+    <<_:9,Sub4:6/binary,_/bitstring>> = HeapBin,
+    Sub3 = Sub4,
+    Sub3 = clone_bin(Sub3),
+    Sub4 = clone_bin(Sub4),
     %% When NIFs get bitstring support
-    %%?line <<_:8,Sub5:27/bitstring,_/bitstring>> = RefcBin, 
-    %%?line <<_:8,Sub6:27/bitstring,_/bitstring>> = HeapBin,
-    %%?line Sub5 = Sub6,
-    %%?line Sub5 = clone_bin(Sub5),
-    %%?line Sub6 = clone_bin(Sub6),
-    %%?line <<_:9,Sub7:27/bitstring,_/bitstring>> = RefcBin, 
-    %%?line <<_:9,Sub8:27/bitstring,_/bitstring>> = HeapBin,
-    %%?line Sub7 = Sub8,
-    %%?line Sub7 = clone_bin(Sub7),
-    %%?line Sub8 = clone_bin(Sub8),
-    %%?line <<>> = clone_bin(<<>>),
+    %%<<_:8,Sub5:27/bitstring,_/bitstring>> = RefcBin, 
+    %%<<_:8,Sub6:27/bitstring,_/bitstring>> = HeapBin,
+    %%Sub5 = Sub6,
+    %%Sub5 = clone_bin(Sub5),
+    %%Sub6 = clone_bin(Sub6),
+    %%<<_:9,Sub7:27/bitstring,_/bitstring>> = RefcBin, 
+    %%<<_:9,Sub8:27/bitstring,_/bitstring>> = HeapBin,
+    %%Sub7 = Sub8,
+    %%Sub7 = clone_bin(Sub7),
+    %%Sub8 = clone_bin(Sub8),
+    %%<<>> = clone_bin(<<>>),
 
     <<_:8,SubBinA:200/binary,_/binary>> = RefcBin,
     <<_:9,SubBinB:200/binary,_/bitstring>> = RefcBin,
@@ -371,50 +370,50 @@ binaries(Config) when is_list(Config) ->
     test_make_sub_bin(SubBinC),
     test_make_sub_bin(SubBinD),
     
-    ?line verify_tmpmem(TmpMem),
+    verify_tmpmem(TmpMem),
     ok.
 
 test_make_sub_bin(Bin) ->
     Size = byte_size(Bin),
     Rest10 = Size - 10,
     Rest1 = Size - 1,
-    ?line Bin = make_sub_bin(Bin, 0, Size),
+    Bin = make_sub_bin(Bin, 0, Size),
     <<_:10/binary,Sub0:Rest10/binary>> = Bin,
-    ?line Sub0 = make_sub_bin(Bin, 10, Rest10),
+    Sub0 = make_sub_bin(Bin, 10, Rest10),
     <<Sub1:10/binary,_/binary>> = Bin,
-    ?line Sub1 = make_sub_bin(Bin, 0, 10),
+    Sub1 = make_sub_bin(Bin, 0, 10),
     <<_:7/binary,Sub2:10/binary,_/binary>> = Bin,
-    ?line Sub2 = make_sub_bin(Bin, 7, 10),
-    ?line <<>> = make_sub_bin(Bin, 0, 0),
-    ?line <<>> = make_sub_bin(Bin, 10, 0),
-    ?line <<>> = make_sub_bin(Bin, Rest1, 0),
-    ?line <<>> = make_sub_bin(Bin, Size, 0),
+    Sub2 = make_sub_bin(Bin, 7, 10),
+    <<>> = make_sub_bin(Bin, 0, 0),
+    <<>> = make_sub_bin(Bin, 10, 0),
+    <<>> = make_sub_bin(Bin, Rest1, 0),
+    <<>> = make_sub_bin(Bin, Size, 0),
     ok.
     
 %% Test enif_get_string
 get_string(Config) when is_list(Config) ->
-    ?line ensure_lib_loaded(Config, 1),
-    ?line {7, <<"hejsan",0,_:3/binary>>} = string_to_bin("hejsan",10),
-    ?line {7, <<"hejsan",0,_>>} = string_to_bin("hejsan",8),
-    ?line {7, <<"hejsan",0>>} = string_to_bin("hejsan",7),
-    ?line {-6, <<"hejsa",0>>} = string_to_bin("hejsan",6),
-    ?line {-5, <<"hejs",0>>} = string_to_bin("hejsan",5),
-    ?line {-1, <<0>>} = string_to_bin("hejsan",1),
-    ?line {0, <<>>} = string_to_bin("hejsan",0),
-    ?line {1, <<0>>} = string_to_bin("",1),
-    ?line {0, <<>>} = string_to_bin("",0),
+    ensure_lib_loaded(Config, 1),
+    {7, <<"hejsan",0,_:3/binary>>} = string_to_bin("hejsan",10),
+    {7, <<"hejsan",0,_>>} = string_to_bin("hejsan",8),
+    {7, <<"hejsan",0>>} = string_to_bin("hejsan",7),
+    {-6, <<"hejsa",0>>} = string_to_bin("hejsan",6),
+    {-5, <<"hejs",0>>} = string_to_bin("hejsan",5),
+    {-1, <<0>>} = string_to_bin("hejsan",1),
+    {0, <<>>} = string_to_bin("hejsan",0),
+    {1, <<0>>} = string_to_bin("",1),
+    {0, <<>>} = string_to_bin("",0),
     ok.
 
 %% Test enif_get_atom
 get_atom(Config) when is_list(Config) ->
-    ?line ensure_lib_loaded(Config, 1),
-    ?line {7, <<"hejsan",0,_:3/binary>>} = atom_to_bin(hejsan,10),
-    ?line {7, <<"hejsan",0,_>>} = atom_to_bin(hejsan,8),
-    ?line {7, <<"hejsan",0>>} = atom_to_bin(hejsan,7),
-    ?line {0, <<_:6/binary>>} = atom_to_bin(hejsan,6),
-    ?line {0, <<>>} = atom_to_bin(hejsan,0),
-    ?line {1, <<0>>} = atom_to_bin('',1),
-    ?line {0, <<>>} = atom_to_bin('',0),
+    ensure_lib_loaded(Config, 1),
+    {7, <<"hejsan",0,_:3/binary>>} = atom_to_bin(hejsan,10),
+    {7, <<"hejsan",0,_>>} = atom_to_bin(hejsan,8),
+    {7, <<"hejsan",0>>} = atom_to_bin(hejsan,7),
+    {0, <<_:6/binary>>} = atom_to_bin(hejsan,6),
+    {0, <<>>} = atom_to_bin(hejsan,0),
+    {1, <<0>>} = atom_to_bin('',1),
+    {0, <<>>} = atom_to_bin('',0),
     ok.
 
 %% Test NIF maps handling.
@@ -466,26 +465,26 @@ maps(Config) when is_list(Config) ->
  
 %% Test macros enif_make_list<N> and enif_make_tuple<N>
 api_macros(Config) when is_list(Config) ->
-    ?line ensure_lib_loaded(Config, 1),
+    ensure_lib_loaded(Config, 1),
     Expected = {[lists:seq(1,N) || N <- lists:seq(1,9)],
 		[list_to_tuple(lists:seq(1,N)) || N <- lists:seq(1,9)]
 	       },
-    ?line Expected = macros(list_to_tuple(lists:seq(1,9))),
+    Expected = macros(list_to_tuple(lists:seq(1,9))),
     ok.
 
 %% enif_make_[tuple|list]_from_array
 from_array(Config) when is_list(Config) ->
-    ?line ensure_lib_loaded(Config, 1),
+    ensure_lib_loaded(Config, 1),
     lists:foreach(fun(Tpl) ->
 			  Lst = tuple_to_list(Tpl),
-			  ?line {Lst,Tpl} = tuple_2_list_and_tuple(Tpl)
+			  {Lst,Tpl} = tuple_2_list_and_tuple(Tpl)
 		  end,
 		  [{}, {1,2,3}, {[4,5],[],{},{6,7}}, {{}}, {[]}]),
     ok.
 
 %% enif_inspect_iolist_as_binary
 iolist_as_binary(Config) when is_list(Config) ->
-    ?line ensure_lib_loaded(Config, 1),
+    ensure_lib_loaded(Config, 1),
     TmpMem = tmpmem(),
     List = [<<"hejsan">>, <<>>, [], [17], [<<>>],
 	    [127,128,255,0],
@@ -494,17 +493,17 @@ iolist_as_binary(Config) when is_list(Config) ->
 	    
     lists:foreach(fun(IoL) ->
 			  B1 = erlang:iolist_to_binary(IoL),
-			  ?line B2 = iolist_2_bin(IoL),
-			  ?line B1 = B2
+			  B2 = iolist_2_bin(IoL),
+			  B1 = B2
 		  end,
 		  List),
-    ?line verify_tmpmem(TmpMem),
+    verify_tmpmem(TmpMem),
     ok.
 
 %% Test memory managed objects, aka 'resources'
 resource(Config) when is_list(Config) ->
-    ?line ensure_lib_loaded(Config, 1),
-    ?line Type = get_resource_type(0),
+    ensure_lib_loaded(Config, 1),
+    Type = get_resource_type(0),
     resource_hugo(Type),
     resource_otto(Type),
     resource_new(Type),
@@ -514,75 +513,75 @@ resource(Config) when is_list(Config) ->
 resource_hugo(Type) ->
     DtorCall = resource_hugo_do(Type),
     erlang:garbage_collect(),
-    ?line DtorCall = last_resource_dtor_call(),
+    DtorCall = last_resource_dtor_call(),
     ok.
 
 resource_hugo_do(Type) ->
     HugoBin = <<"Hugo Hacker">>,
-    ?line HugoPtr = alloc_resource(Type, HugoBin),
-    ?line Hugo = make_resource(HugoPtr),
-    ?line <<>> = Hugo,
+    HugoPtr = alloc_resource(Type, HugoBin),
+    Hugo = make_resource(HugoPtr),
+    <<>> = Hugo,
     release_resource(HugoPtr),
     erlang:garbage_collect(),
-    ?line {HugoPtr,HugoBin} = get_resource(Type,Hugo),
+    {HugoPtr,HugoBin} = get_resource(Type,Hugo),
     Pid = spawn_link(fun() -> 			     
-			     receive {Pid, Type, Resource, Ptr, Bin} ->
-				     Pid ! {self(), got_it},
-				     receive {Pid, check_it} ->
-					     ?line {Ptr,Bin} = get_resource(Type,Resource),
-					     Pid ! {self(), ok}
-				     end
-			     end
-		     end),
+                             receive {Pid, Type, Resource, Ptr, Bin} ->
+                                         Pid ! {self(), got_it},
+                                         receive {Pid, check_it} ->
+                                                     {Ptr,Bin} = get_resource(Type,Resource),
+                                                     Pid ! {self(), ok}
+                                         end
+                             end
+                     end),
     Pid ! {self(), Type, Hugo, HugoPtr, HugoBin},
-    ?line {Pid, got_it} = receive_any(),
+    {Pid, got_it} = receive_any(),
     erlang:garbage_collect(),   % just to make our ProcBin move in memory
     Pid ! {self(), check_it},
-    ?line {Pid, ok} = receive_any(),
-    ?line [] = last_resource_dtor_call(),
-    ?line {HugoPtr,HugoBin} = get_resource(Type,Hugo),
+    {Pid, ok} = receive_any(),
+    [] = last_resource_dtor_call(),
+    {HugoPtr,HugoBin} = get_resource(Type,Hugo),
     {HugoPtr, HugoBin, 1}.
 
 resource_otto(Type) ->
     {OttoPtr, OttoBin} = resource_otto_do(Type),
     erlang:garbage_collect(),
-    ?line [] = last_resource_dtor_call(),
+    [] = last_resource_dtor_call(),
     release_resource(OttoPtr),
-    ?line {OttoPtr,OttoBin,1} = last_resource_dtor_call(),
+    {OttoPtr,OttoBin,1} = last_resource_dtor_call(),
     ok.
     
 resource_otto_do(Type) ->
     OttoBin = <<"Otto Ordonnans">>,
-    ?line OttoPtr = alloc_resource(Type, OttoBin),
-    ?line Otto = make_resource(OttoPtr),
-    ?line <<>> = Otto,
+    OttoPtr = alloc_resource(Type, OttoBin),
+    Otto = make_resource(OttoPtr),
+    <<>> = Otto,
     %% forget resource term but keep referenced by NIF
     {OttoPtr, OttoBin}.    
 
 resource_new(Type) ->
-    ?line {PtrB,BinB} = resource_new_do1(Type),
+    {PtrB,BinB} = resource_new_do1(Type),
     erlang:garbage_collect(),
-    ?line {PtrB,BinB,1} = last_resource_dtor_call(),
+    {PtrB,BinB,1} = last_resource_dtor_call(),
     ok.
     
 resource_new_do1(Type) ->
-    ?line {{PtrA,BinA}, {ResB,PtrB,BinB}} = resource_new_do2(Type),
+    {{PtrA,BinA}, {ResB,PtrB,BinB}} = resource_new_do2(Type),
     erlang:garbage_collect(),
-    ?line {PtrA,BinA,1} = last_resource_dtor_call(),
-    ?line {PtrB,BinB} = get_resource(Type, ResB),
+    {PtrA,BinA,1} = last_resource_dtor_call(),
+    {PtrB,BinB} = get_resource(Type, ResB),
     %% forget ResB and make it garbage
     {PtrB,BinB}.
     
 resource_new_do2(Type) ->
     BinA = <<"NewA">>,
     BinB = <<"NewB">>,
-    ?line ResA = make_new_resource(Type, BinA),
-    ?line ResB = make_new_resource(Type, BinB),
-    ?line <<>> = ResA,
-    ?line <<>> = ResB,
-    ?line {PtrA,BinA} = get_resource(Type, ResA),
-    ?line {PtrB,BinB} = get_resource(Type, ResB),
-    ?line true = (PtrA =/= PtrB),
+    ResA = make_new_resource(Type, BinA),
+    ResB = make_new_resource(Type, BinB),
+    <<>> = ResA,
+    <<>> = ResB,
+    {PtrA,BinA} = get_resource(Type, ResA),
+    {PtrB,BinB} = get_resource(Type, ResB),
+    true = (PtrA =/= PtrB),
     %% forget ResA and make it garbage
     {{PtrA,BinA}, {ResB,PtrB,BinB}}.
 
@@ -591,21 +590,21 @@ resource_neg(TypeA) ->
 
     catch exit(42), % dummy exception to purge saved stacktraces from earlier exception
     erlang:garbage_collect(),
-    ?line {_,_,2} = last_resource_dtor_call(),
+    {_,_,2} = last_resource_dtor_call(),
     ok.
 
 resource_neg_do(TypeA) ->
     TypeB = get_resource_type(1),
     ResA = make_new_resource(TypeA, <<"Arnold">>),
     ResB= make_new_resource(TypeB, <<"Bobo">>),
-    ?line {'EXIT',{badarg,_}} = (catch get_resource(TypeA, ResB)),
-    ?line {'EXIT',{badarg,_}} = (catch get_resource(TypeB, ResA)),
+    {'EXIT',{badarg,_}} = (catch get_resource(TypeA, ResB)),
+    {'EXIT',{badarg,_}} = (catch get_resource(TypeB, ResA)),
     ok.
 
 %% Test enif_make_resource_binary
 resource_binary(Config) when is_list(Config) ->
-    ?line ensure_lib_loaded(Config, 1),
-    ?line {Ptr,Bin} = resource_binary_do(),
+    ensure_lib_loaded(Config, 1),
+    {Ptr,Bin} = resource_binary_do(),
     erlang:garbage_collect(),
     Last = last_resource_dtor_call(),
     ?CHECK({Ptr,Bin,1}, Last),
@@ -613,22 +612,22 @@ resource_binary(Config) when is_list(Config) ->
 
 resource_binary_do() ->
     Bin = <<"Hej Hopp i lingonskogen">>,
-    ?line {Ptr,ResBin1} = make_new_resource_binary(Bin),
-    ?line ResBin1 = Bin,          
-    ?line ResInfo = {Ptr,_} = get_resource(binary_resource_type,ResBin1),
+    {Ptr,ResBin1} = make_new_resource_binary(Bin),
+    ResBin1 = Bin,          
+    ResInfo = {Ptr,_} = get_resource(binary_resource_type,ResBin1),
 
     Papa = self(),
     Forwarder = spawn_link(fun() -> forwarder(Papa) end),
     io:format("sending to forwarder pid=~p\n",[Forwarder]),  
     Forwarder ! ResBin1,
     ResBin2 = receive_any(),
-    ?line ResBin2 = ResBin1,
-    ?line ResInfo = get_resource(binary_resource_type,ResBin2),
+    ResBin2 = ResBin1,
+    ResInfo = get_resource(binary_resource_type,ResBin2),
     Forwarder ! terminate,
-    ?line {Forwarder, 1} = receive_any(),
+    {Forwarder, 1} = receive_any(),
     erlang:garbage_collect(),
-    ?line ResInfo = get_resource(binary_resource_type,ResBin1),
-    ?line ResInfo = get_resource(binary_resource_type,ResBin2),
+    ResInfo = get_resource(binary_resource_type,ResBin1),
+    ResInfo = get_resource(binary_resource_type,ResBin2),
     ResInfo.
 
     
@@ -640,30 +639,30 @@ resource_takeover(Config) when is_list(Config) ->
     TmpMem = tmpmem(),
     ensure_lib_loaded(Config),
 
-    ?line Data = proplists:get_value(data_dir, Config),
-    ?line File = filename:join(Data, "nif_mod"),
-    ?line {ok,nif_mod,ModBin} = compile:file(File, [binary,return_errors]),
-    ?line {module,nif_mod} = erlang:load_module(nif_mod,ModBin),
-
-    ?line ok = nif_mod:load_nif_lib(Config, 1, 
-				    [{resource_type, 0, ?RT_CREATE, "resource_type_A",resource_dtor_A,
-				      ?RT_CREATE},
-				     {resource_type, 1, ?RT_CREATE, "resource_type_null_A",null,
-				      ?RT_CREATE},
-				     {resource_type, 2, ?RT_CREATE bor ?RT_TAKEOVER, "resource_type_A_null",resource_dtor_A,
-				      ?RT_CREATE},
-				     {resource_type, 3, ?RT_CREATE, "resource_type_B_goneX",resource_dtor_B,
-				      ?RT_CREATE},
-				     {resource_type, 4, ?RT_CREATE, "resource_type_null_goneX",null,
-				      ?RT_CREATE},
-				     {resource_type, null, ?RT_TAKEOVER, "Pink unicorn", resource_dtor_A,
-				      ?RT_TAKEOVER}
-				    ]),
-
-    ?line hold_nif_mod_priv_data(nif_mod:get_priv_data_ptr()),
-    ?line [{load,1,1,101},{get_priv_data_ptr,1,2,102}] = nif_mod_call_history(),
+    Data = proplists:get_value(data_dir, Config),
+    File = filename:join(Data, "nif_mod"),
+    {ok,nif_mod,ModBin} = compile:file(File, [binary,return_errors]),
+    {module,nif_mod} = erlang:load_module(nif_mod,ModBin),
 
-    ?line {Holder, _MRef} = spawn_opt(fun resource_holder/0, [link, monitor]),
+    ok = nif_mod:load_nif_lib(Config, 1, 
+                              [{resource_type, 0, ?RT_CREATE, "resource_type_A",resource_dtor_A,
+                                ?RT_CREATE},
+                               {resource_type, 1, ?RT_CREATE, "resource_type_null_A",null,
+                                ?RT_CREATE},
+                               {resource_type, 2, ?RT_CREATE bor ?RT_TAKEOVER, "resource_type_A_null",resource_dtor_A,
+                                ?RT_CREATE},
+                               {resource_type, 3, ?RT_CREATE, "resource_type_B_goneX",resource_dtor_B,
+                                ?RT_CREATE},
+                               {resource_type, 4, ?RT_CREATE, "resource_type_null_goneX",null,
+                                ?RT_CREATE},
+                               {resource_type, null, ?RT_TAKEOVER, "Pink unicorn", resource_dtor_A,
+                                ?RT_TAKEOVER}
+                              ]),
+
+    hold_nif_mod_priv_data(nif_mod:get_priv_data_ptr()),
+    [{load,1,1,101},{get_priv_data_ptr,1,2,102}] = nif_mod_call_history(),
+
+    {Holder, _MRef} = spawn_opt(fun resource_holder/0, [link, monitor]),
 
     {A1,BinA1} = make_resource(0,Holder,"A1"),
     {A2,BinA2} = make_resource(0,Holder,"A2"),
@@ -683,91 +682,91 @@ resource_takeover(Config) when is_list(Config) ->
     {NGX1,_BinNGX1} = make_resource(4,Holder,"NGX1"),
     {NGX2,_BinNGX2} = make_resource(4,Holder,"NGX2"),
 
-    ?line [] = nif_mod_call_history(),
+    [] = nif_mod_call_history(),
 
-    ?line ok = forget_resource(A1),
-    ?line [{{resource_dtor_A_v1,BinA1},1,3,103}] = nif_mod_call_history(),    
+    ok = forget_resource(A1),
+    [{{resource_dtor_A_v1,BinA1},1,3,103}] = nif_mod_call_history(),    
 
-    ?line ok = forget_resource(NA1),
-    ?line [] = nif_mod_call_history(), % no dtor
+    ok = forget_resource(NA1),
+    [] = nif_mod_call_history(), % no dtor
 
-    ?line ok = forget_resource(AN1),
+    ok = forget_resource(AN1),
     ?CHECK([{{resource_dtor_A_v1,BinAN1},1,4,104}] , nif_mod_call_history()),
 
-    ?line ok = forget_resource(BGX1),
+    ok = forget_resource(BGX1),
     ?CHECK([{{resource_dtor_B_v1,BinBGX1},1,5,105}], nif_mod_call_history()),
 
-    ?line ok = forget_resource(NGX1),
+    ok = forget_resource(NGX1),
     ?CHECK([], nif_mod_call_history()), % no dtor
 
-    ?line ok = nif_mod:load_nif_lib(Config, 2,
-				    [{resource_type, 0, ?RT_TAKEOVER, "resource_type_A",resource_dtor_A,
-				      ?RT_TAKEOVER},
-				     {resource_type, 1, ?RT_TAKEOVER bor ?RT_CREATE, "resource_type_null_A",resource_dtor_A,
-				      ?RT_TAKEOVER},
-				     {resource_type, 2, ?RT_TAKEOVER, "resource_type_A_null",null,
-				      ?RT_TAKEOVER},
-				     {resource_type, null, ?RT_TAKEOVER, "Pink unicorn", resource_dtor_A,
-				      ?RT_TAKEOVER},
-				     {resource_type, null, ?RT_CREATE, "resource_type_B_goneX",resource_dtor_B,
-				      ?RT_CREATE},
-				     {resource_type, null, ?RT_CREATE, "resource_type_null_goneX",null,
-				      ?RT_CREATE},
-				     {resource_type, 3, ?RT_CREATE, "resource_type_B_goneY",resource_dtor_B,
-				      ?RT_CREATE},
-				     {resource_type, 4, ?RT_CREATE, "resource_type_null_goneY",null,
-				      ?RT_CREATE}
-				    ]),
+    ok = nif_mod:load_nif_lib(Config, 2,
+                              [{resource_type, 0, ?RT_TAKEOVER, "resource_type_A",resource_dtor_A,
+                                ?RT_TAKEOVER},
+                               {resource_type, 1, ?RT_TAKEOVER bor ?RT_CREATE, "resource_type_null_A",resource_dtor_A,
+                                ?RT_TAKEOVER},
+                               {resource_type, 2, ?RT_TAKEOVER, "resource_type_A_null",null,
+                                ?RT_TAKEOVER},
+                               {resource_type, null, ?RT_TAKEOVER, "Pink unicorn", resource_dtor_A,
+                                ?RT_TAKEOVER},
+                               {resource_type, null, ?RT_CREATE, "resource_type_B_goneX",resource_dtor_B,
+                                ?RT_CREATE},
+                               {resource_type, null, ?RT_CREATE, "resource_type_null_goneX",null,
+                                ?RT_CREATE},
+                               {resource_type, 3, ?RT_CREATE, "resource_type_B_goneY",resource_dtor_B,
+                                ?RT_CREATE},
+                               {resource_type, 4, ?RT_CREATE, "resource_type_null_goneY",null,
+                                ?RT_CREATE}
+                              ]),
     ?CHECK([{reload,2,1,201}], nif_mod_call_history()),
 
-    ?line BinA2 = read_resource(0,A2),
-    ?line ok = forget_resource(A2),
+    BinA2 = read_resource(0,A2),
+    ok = forget_resource(A2),
     ?CHECK([{{resource_dtor_A_v2,BinA2},2,2,202}], nif_mod_call_history()),    
 
-    ?line ok = forget_resource(NA2),
+    ok = forget_resource(NA2),
     ?CHECK([{{resource_dtor_A_v2,BinNA2},2,3,203}], nif_mod_call_history()),    
 
-    ?line ok = forget_resource(AN2),
+    ok = forget_resource(AN2),
     ?CHECK([], nif_mod_call_history()),    % no dtor
 
-    ?line ok = forget_resource(BGX2),  % calling dtor in orphan library v1 still loaded
+    ok = forget_resource(BGX2),  % calling dtor in orphan library v1 still loaded
     ?CHECK([{{resource_dtor_B_v1,BinBGX2},1,6,106}], nif_mod_call_history()),
     % How to test that lib v1 is closed here?
 
-    ?line ok = forget_resource(NGX2),
+    ok = forget_resource(NGX2),
     ?CHECK([], nif_mod_call_history()),  % no dtor
 
     {BGY1,BinBGY1} = make_resource(3,Holder,"BGY1"),
     {NGY1,_BinNGY1} = make_resource(4,Holder,"NGY1"),
 
     %% Module upgrade with same lib-version
-    ?line {module,nif_mod} = erlang:load_module(nif_mod,ModBin),
-    ?line undefined = nif_mod:lib_version(),
-    ?line ok = nif_mod:load_nif_lib(Config, 2,
-				    [{resource_type, 2, ?RT_TAKEOVER, "resource_type_A",resource_dtor_B,
-				      ?RT_TAKEOVER},
-				     {resource_type, 0, ?RT_TAKEOVER bor ?RT_CREATE, "resource_type_null_A",null,
-				      ?RT_TAKEOVER},
-				     {resource_type, 1, ?RT_TAKEOVER, "resource_type_A_null",resource_dtor_A,
-				      ?RT_TAKEOVER},
-				     {resource_type, null, ?RT_TAKEOVER, "Pink elephant", resource_dtor_A,
-				      ?RT_TAKEOVER},
-				     {resource_type, 3, ?RT_CREATE, "resource_type_B_goneZ",resource_dtor_B,
-				      ?RT_CREATE},
-				     {resource_type, 4, ?RT_CREATE, "resource_type_null_goneZ",null,
-				      ?RT_CREATE}
-				    ]),
-
-    ?line 2 = nif_mod:lib_version(),
+    {module,nif_mod} = erlang:load_module(nif_mod,ModBin),
+    undefined = nif_mod:lib_version(),
+    ok = nif_mod:load_nif_lib(Config, 2,
+                              [{resource_type, 2, ?RT_TAKEOVER, "resource_type_A",resource_dtor_B,
+                                ?RT_TAKEOVER},
+                               {resource_type, 0, ?RT_TAKEOVER bor ?RT_CREATE, "resource_type_null_A",null,
+                                ?RT_TAKEOVER},
+                               {resource_type, 1, ?RT_TAKEOVER, "resource_type_A_null",resource_dtor_A,
+                                ?RT_TAKEOVER},
+                               {resource_type, null, ?RT_TAKEOVER, "Pink elephant", resource_dtor_A,
+                                ?RT_TAKEOVER},
+                               {resource_type, 3, ?RT_CREATE, "resource_type_B_goneZ",resource_dtor_B,
+                                ?RT_CREATE},
+                               {resource_type, 4, ?RT_CREATE, "resource_type_null_goneZ",null,
+                                ?RT_CREATE}
+                              ]),
+
+    2 = nif_mod:lib_version(),
     ?CHECK([{upgrade,2,4,204},{lib_version,2,5,205}], nif_mod_call_history()),
 
-    ?line ok = forget_resource(A3),
+    ok = forget_resource(A3),
     ?CHECK([{{resource_dtor_B_v2,BinA3},2,6,206}], nif_mod_call_history()),    
 
-    ?line ok = forget_resource(NA3),
+    ok = forget_resource(NA3),
     ?CHECK([], nif_mod_call_history()),    
 
-    ?line ok = forget_resource(AN3),
+    ok = forget_resource(AN3),
     ?CHECK([{{resource_dtor_A_v2,BinAN3},2,7,207}], nif_mod_call_history()),
 
     {A4,BinA4} = make_resource(2,Holder, "A4"),
@@ -777,19 +776,19 @@ resource_takeover(Config) when is_list(Config) ->
     {BGZ1,BinBGZ1} = make_resource(3,Holder,"BGZ1"),
     {NGZ1,_BinNGZ1} = make_resource(4,Holder,"NGZ1"),
 
-    ?line false = code:purge(nif_mod),
-    ?line [] = nif_mod_call_history(),
+    false = code:purge(nif_mod),
+    [] = nif_mod_call_history(),
 
-    ?line ok = forget_resource(NGY1),
-    ?line [] = nif_mod_call_history(),
+    ok = forget_resource(NGY1),
+    [] = nif_mod_call_history(),
 
-    ?line ok = forget_resource(BGY1),  % calling dtor in orphan library v2 still loaded
-    ?line [{{resource_dtor_B_v2,BinBGY1},2,8,208},{unload,2,9,209}] = nif_mod_call_history(),
+    ok = forget_resource(BGY1),  % calling dtor in orphan library v2 still loaded
+    [{{resource_dtor_B_v2,BinBGY1},2,8,208},{unload,2,9,209}] = nif_mod_call_history(),
 
     %% Module upgrade with other lib-version
-    ?line {module,nif_mod} = erlang:load_module(nif_mod,ModBin),
-    ?line undefined = nif_mod:lib_version(),
-    ?line ok = nif_mod:load_nif_lib(Config, 1,
+    {module,nif_mod} = erlang:load_module(nif_mod,ModBin),
+    undefined = nif_mod:lib_version(),
+    ok = nif_mod:load_nif_lib(Config, 1,
 				    [{resource_type, 2, ?RT_TAKEOVER, "resource_type_A",resource_dtor_A,
 				      ?RT_TAKEOVER},
 				     {resource_type, 0, ?RT_TAKEOVER bor ?RT_CREATE, "resource_type_null_A",resource_dtor_A,
@@ -800,28 +799,28 @@ resource_takeover(Config) when is_list(Config) ->
 				      ?RT_TAKEOVER}
 				    ]),
 
-    ?line 1 = nif_mod:lib_version(),
-    ?line [{upgrade,1,1,101},{lib_version,1,2,102}] = nif_mod_call_history(),
+    1 = nif_mod:lib_version(),
+    [{upgrade,1,1,101},{lib_version,1,2,102}] = nif_mod_call_history(),
 
-    %%?line false= check_process_code(Pid, nif_mod),
-    ?line false = code:purge(nif_mod),
+    %%false= check_process_code(Pid, nif_mod),
+    false = code:purge(nif_mod),
     %% no unload here as we still have instances with destructors
-    ?line [] = nif_mod_call_history(),
+    [] = nif_mod_call_history(),
 
-    ?line ok = forget_resource(BGZ1),  % calling dtor in orphan library v2 still loaded
-    ?line [{{resource_dtor_B_v2,BinBGZ1},2,10,210},{unload,2,11,211}] = nif_mod_call_history(),
+    ok = forget_resource(BGZ1),  % calling dtor in orphan library v2 still loaded
+    [{{resource_dtor_B_v2,BinBGZ1},2,10,210},{unload,2,11,211}] = nif_mod_call_history(),
 
-    ?line ok = forget_resource(NGZ1),
-    ?line [] = nif_mod_call_history(),
+    ok = forget_resource(NGZ1),
+    [] = nif_mod_call_history(),
 
-    ?line ok = forget_resource(A4),
-    ?line [{{resource_dtor_A_v1,BinA4},1,3,103}] = nif_mod_call_history(),
+    ok = forget_resource(A4),
+    [{{resource_dtor_A_v1,BinA4},1,3,103}] = nif_mod_call_history(),
 
-    ?line ok = forget_resource(NA4),
-    ?line [{{resource_dtor_A_v1,BinNA4},1,4,104}] = nif_mod_call_history(),
+    ok = forget_resource(NA4),
+    [{{resource_dtor_A_v1,BinNA4},1,4,104}] = nif_mod_call_history(),
 
-    ?line ok = forget_resource(AN4),
-    ?line [] = nif_mod_call_history(),
+    ok = forget_resource(AN4),
+    [] = nif_mod_call_history(),
 
 
     %%
@@ -943,8 +942,8 @@ resource_takeover(Config) when is_list(Config) ->
 			       {return, 0}  % SUCCESS
 			      ]),
 
-    ?line hold_nif_mod_priv_data(nif_mod:get_priv_data_ptr()),
-    ?line [{load,1,1,101},{get_priv_data_ptr,1,2,102}] = nif_mod_call_history(),
+    hold_nif_mod_priv_data(nif_mod:get_priv_data_ptr()),
+    [{load,1,1,101},{get_priv_data_ptr,1,2,102}] = nif_mod_call_history(),
 
     {NA7,BinNA7} = make_resource(0, Holder, "NA7"),
     {AN7,BinAN7} = make_resource(1, Holder, "AN7"),
@@ -955,15 +954,15 @@ resource_takeover(Config) when is_list(Config) ->
     ok = forget_resource(AN7),
     [] = nif_mod_call_history(),
 
-    ?line true = lists:member(?MODULE, erlang:system_info(taints)),
-    ?line true = lists:member(nif_mod, erlang:system_info(taints)),
-    ?line verify_tmpmem(TmpMem),    
+    true = lists:member(?MODULE, erlang:system_info(taints)),
+    true = lists:member(nif_mod, erlang:system_info(taints)),
+    verify_tmpmem(TmpMem),    
     ok.
 
 make_resource(Type,Holder,Str) when is_list(Str) ->
     Bin = list_to_binary(Str),
     A1 = make_resource_do(Type,Holder,Bin),
-    ?line Bin = read_resource(Type,A1),
+    Bin = read_resource(Type,A1),
     {A1,Bin}.
 
 make_resource_do(Type, Holder, Bin) ->
@@ -990,7 +989,7 @@ resource_holder(List) ->
     %%io:format("resource_holder got ~p with list = ~p\n", [Msg,List]),
     case Msg of
 	{Pid, make, Type, Bin} ->	    
-	    ?line Resource = nif_mod:make_new_resource(Type, Bin),
+	    Resource = nif_mod:make_new_resource(Type, Bin),
 	    Id = {make_ref(),Bin},
 	    Pid ! {self(), make_ok, Id},
 	    resource_holder([{Id,Resource} | List]);
@@ -1020,19 +1019,19 @@ threading(Config) when is_list(Config) ->
     end.
 
 threading_do(Config) ->
-    ?line Data = proplists:get_value(data_dir, Config),
-    ?line File = filename:join(Data, "tester"),
-    ?line {ok,tester,ModBin} = compile:file(File, [binary,return_errors]),
-    ?line {module,tester} = erlang:load_module(tester,ModBin),
+    Data = proplists:get_value(data_dir, Config),
+    File = filename:join(Data, "tester"),
+    {ok,tester,ModBin} = compile:file(File, [binary,return_errors]),
+    {module,tester} = erlang:load_module(tester,ModBin),
 
-    ?line ok = tester:load_nif_lib(Config, "basic"),   
-    ?line ok = tester:run(),
+    ok = tester:load_nif_lib(Config, "basic"),   
+    ok = tester:run(),
 
-    ?line ok = tester:load_nif_lib(Config, "rwlock"),
-    ?line ok = tester:run(),
+    ok = tester:load_nif_lib(Config, "rwlock"),
+    ok = tester:run(),
 
-    ?line ok = tester:load_nif_lib(Config, "tsd"),
-    ?line ok = tester:run().
+    ok = tester:load_nif_lib(Config, "tsd"),
+    ok = tester:run().
 
 %% Test NIF message sending
 send(Config) when is_list(Config) ->    
@@ -1040,22 +1039,22 @@ send(Config) when is_list(Config) ->
 
     N = 1500,
     List = lists:seq(1,N),
-    ?line {ok,1} = send_list_seq(N, self),
-    ?line {ok,1} = send_list_seq(N, self()),
-    ?line List = receive_any(),
-    ?line List = receive_any(),
+    {ok,1} = send_list_seq(N, self),
+    {ok,1} = send_list_seq(N, self()),
+    List = receive_any(),
+    List = receive_any(),
     Papa = self(),
-    spawn_link(fun() -> ?line {ok,1} = send_list_seq(N, Papa) end),
-    ?line List = receive_any(),
+    spawn_link(fun() -> {ok,1} = send_list_seq(N, Papa) end),
+    List = receive_any(),
 
-    ?line {ok, 1, BlobS} = send_new_blob(self(), other_term()),
-    ?line BlobR = receive_any(),
+    {ok, 1, BlobS} = send_new_blob(self(), other_term()),
+    BlobR = receive_any(),
     io:format("Sent ~p\nGot ~p\n", [BlobS, BlobR]),
-    ?line BlobR = BlobS,
+    BlobR = BlobS,
 
     %% send to dead pid
     {DeadPid, DeadMon} = spawn_monitor(fun() -> void end),
-    ?line {'DOWN', DeadMon, process, DeadPid, normal} = receive_any(),
+    {'DOWN', DeadMon, process, DeadPid, normal} = receive_any(),
     {ok,0} = send_list_seq(7, DeadPid),
     ok.
 
@@ -1087,44 +1086,44 @@ send2_do1(SendBlobF) ->
     io:format("sending to forwarder pid=~p\n",[Forwarder]),
     send2_do2(SendBlobF, Forwarder),
     Forwarder ! terminate,
-    ?line {Forwarder, 4} = receive_any(),
+    {Forwarder, 4} = receive_any(),
     ok.
 
 send2_do2(SendBlobF, To) ->   
     MsgEnv = alloc_msgenv(),
     repeat(50, fun(_) -> grow_blob(MsgEnv,other_term()) end, []),
-    ?line {ok,1,Blob0} = SendBlobF(MsgEnv, To),
-    ?line Blob1 = receive_any(),
-    ?line Blob1 = Blob0,
+    {ok,1,Blob0} = SendBlobF(MsgEnv, To),
+    Blob1 = receive_any(),
+    Blob1 = Blob0,
     
     clear_msgenv(MsgEnv),
     repeat(50, fun(_) -> grow_blob(MsgEnv,other_term()) end, []),
-    ?line {ok,1,Blob2} = SendBlobF(MsgEnv, To),
-    ?line Blob3 = receive_any(),
-    ?line Blob3 = Blob2,
+    {ok,1,Blob2} = SendBlobF(MsgEnv, To),
+    Blob3 = receive_any(),
+    Blob3 = Blob2,
 
     clear_msgenv(MsgEnv),
     repeat(50, fun(_) -> grow_blob(MsgEnv,other_term()) end, []),
 
     clear_msgenv(MsgEnv),
     repeat(50, fun(_) -> grow_blob(MsgEnv,other_term()) end, []),
-    ?line {ok,1,Blob4} = SendBlobF(MsgEnv, To),
-    ?line Blob5 = receive_any(),
-    ?line Blob5 = Blob4,
+    {ok,1,Blob4} = SendBlobF(MsgEnv, To),
+    Blob5 = receive_any(),
+    Blob5 = Blob4,
 
     clear_msgenv(MsgEnv),
     clear_msgenv(MsgEnv),
     repeat(50, fun(_) -> grow_blob(MsgEnv,other_term()) end, []),
-    ?line {ok,1,Blob6} = SendBlobF(MsgEnv, To),
-    ?line Blob7 = receive_any(),
-    ?line Blob7 = Blob6,
+    {ok,1,Blob6} = SendBlobF(MsgEnv, To),
+    Blob7 = receive_any(),
+    Blob7 = Blob6,
 
     ok.
 
 
 send_blob_thread_and_join(MsgEnv, To) ->
-    ?line {ok,Blob} = send_blob_thread_dbg(MsgEnv, To, no_join),
-    ?line {ok,SendRes} = join_send_thread(MsgEnv),
+    {ok,Blob} = send_blob_thread_dbg(MsgEnv, To, no_join),
+    {ok,SendRes} = join_send_thread(MsgEnv),
     {ok,SendRes,Blob}.
 
 send_blob_dbg(MsgEnv, To) ->
@@ -1160,10 +1159,10 @@ send3(Config) when is_list(Config) ->
     rand:seed(exsplus),
     io:format("seed: ~p\n",[rand:export_seed()]),
     ets:new(nif_SUITE,[named_table,public]),
-    ?line true = ets:insert(nif_SUITE,{send3,0,0,0,0}),
+    true = ets:insert(nif_SUITE,{send3,0,0,0,0}),
     timer:send_after(10000, timeout), % Run for 10 seconds
     SpawnCnt = send3_controller(0, [], [], 20),
-    ?line [{_,Rcv,SndOk,SndFail,Balance}] = ets:lookup(nif_SUITE,send3),
+    [{_,Rcv,SndOk,SndFail,Balance}] = ets:lookup(nif_SUITE,send3),
     io:format("spawns=~p received=~p, sent=~p send-failure=~p balance=~p\n",
               [SpawnCnt,Rcv,SndOk,SndFail,Balance]),
     ets:delete(nif_SUITE).
@@ -1197,7 +1196,7 @@ send3_controller(SpawnCnt0, Mons0, Pids0, Tick) ->
             true ->
                 {NewPid,Mon} = spawn_opt(fun send3_proc/0, [link,monitor]),                
                 lists:foreach(fun(P) -> P ! {is_born,NewPid} end, Pids0),
-                ?line Balance = ets:lookup_element(nif_SUITE,send3,5),
+                Balance = ets:lookup_element(nif_SUITE,send3,5),
                 Inject = (Balance =< 0),
                 case Inject of
                     true ->  ok;
@@ -1223,7 +1222,7 @@ send3_proc(Pids0, Counters={Rcv,SndOk,SndFail}, State0) ->
     receive 
         {pids, Pids1, Inject} ->
             %%io:format("~p: got ~p Inject=~p\n", [self(), Pids1, Inject]), 
-            ?line Pids0 = [self()],
+            Pids0 = [self()],
             Pids2 = [self() | Pids1],
             case Inject of
                 true -> send3_proc_send(Pids2, Counters, State0);
@@ -1311,93 +1310,93 @@ send3_new_state(State, Blob) ->
 %% Negative testing of load_nif
 neg(Config) when is_list(Config) ->
     TmpMem = tmpmem(),
-    ?line {'EXIT',{badarg,_}} = (catch erlang:load_nif(badarg, 0)),
-    ?line {error,{load_failed,_}} = erlang:load_nif("pink_unicorn", 0),
+    {'EXIT',{badarg,_}} = (catch erlang:load_nif(badarg, 0)),
+    {error,{load_failed,_}} = erlang:load_nif("pink_unicorn", 0),
     
-    ?line Data = proplists:get_value(data_dir, Config),
-    ?line File = filename:join(Data, "nif_mod"),
-    ?line {ok,nif_mod,Bin} = compile:file(File, [binary,return_errors]),
-    ?line {module,nif_mod} = erlang:load_module(nif_mod,Bin),
+    Data = proplists:get_value(data_dir, Config),
+    File = filename:join(Data, "nif_mod"),
+    {ok,nif_mod,Bin} = compile:file(File, [binary,return_errors]),
+    {module,nif_mod} = erlang:load_module(nif_mod,Bin),
 
-    ?line {error,{bad_lib,_}} = nif_mod:load_nif_lib(Config, no_init),    
-    ?line verify_tmpmem(TmpMem),
-    ?line ok.
+    {error,{bad_lib,_}} = nif_mod:load_nif_lib(Config, no_init),    
+    verify_tmpmem(TmpMem),
+    ok.
 
 %% Test all enif_is functions
 is_checks(Config) when is_list(Config) ->
-    ?line ensure_lib_loaded(Config, 1),
-    ?line ok = check_is(hejsan, <<19,98>>, make_ref(), ok, fun() -> ok end,
+    ensure_lib_loaded(Config, 1),
+    ok = check_is(hejsan, <<19,98>>, make_ref(), ok, fun() -> ok end,
 			self(), hd(erlang:ports()), [], [1,9,9,8],
 			{hejsan, "hejsan", [$h,"ejs",<<"an">>]}, 12),
-    ?line ok = check_is(hejsan, <<19,98>>, make_ref(), ok, fun() -> ok end,
+    ok = check_is(hejsan, <<19,98>>, make_ref(), ok, fun() -> ok end,
 			self(), hd(erlang:ports()), [], [1,9,9,8],
 			{hejsan, "hejsan", [$h,"ejs",<<"an">>]}, -12),
-    ?line ok = check_is(hejsan, <<19,98>>, make_ref(), ok, fun() -> ok end,
+    ok = check_is(hejsan, <<19,98>>, make_ref(), ok, fun() -> ok end,
 			self(), hd(erlang:ports()), [], [1,9,9,8],
 			{hejsan, "hejsan", [$h,"ejs",<<"an">>]}, 18446744073709551617),
-    ?line ok = check_is(hejsan, <<19,98>>, make_ref(), ok, fun() -> ok end,
+    ok = check_is(hejsan, <<19,98>>, make_ref(), ok, fun() -> ok end,
 			self(), hd(erlang:ports()), [], [1,9,9,8],
 			{hejsan, "hejsan", [$h,"ejs",<<"an">>]}, -18446744073709551617),
-    ?line ok = check_is(hejsan, <<19,98>>, make_ref(), ok, fun() -> ok end,
+    ok = check_is(hejsan, <<19,98>>, make_ref(), ok, fun() -> ok end,
 			self(), hd(erlang:ports()), [], [1,9,9,8],
 			{hejsan, "hejsan", [$h,"ejs",<<"an">>]}, 99.146),
-    ?line ok = check_is(hejsan, <<19,98>>, make_ref(), ok, fun() -> ok end,
+    ok = check_is(hejsan, <<19,98>>, make_ref(), ok, fun() -> ok end,
 			self(), hd(erlang:ports()), [], [1,9,9,8],
 			{hejsan, "hejsan", [$h,"ejs",<<"an">>]}, -99.146),
-    ?line ok = check_is(hejsan, <<19,98>>, make_ref(), ok, fun() -> ok end,
+    ok = check_is(hejsan, <<19,98>>, make_ref(), ok, fun() -> ok end,
 			self(), hd(erlang:ports()), [], [1,9,9,8],
 			{hejsan, "hejsan", [$h,"ejs",<<"an">>]}, 18446744073709551616.2e2),
-    ?line ok = check_is(hejsan, <<19,98>>, make_ref(), ok, fun() -> ok end,
+    ok = check_is(hejsan, <<19,98>>, make_ref(), ok, fun() -> ok end,
 			self(), hd(erlang:ports()), [], [1,9,9,8],
 			{hejsan, "hejsan", [$h,"ejs",<<"an">>]}, -18446744073709551616.2e2),
     try
-        ?line check_is_exception(),
-        ?line throw(expected_badarg)
+        check_is_exception(),
+        throw(expected_badarg)
     catch
         error:badarg ->
-            ?line ok
+            ok
     end.
 
 %% Test all enif_get_length functions
 get_length(Config) when is_list(Config) ->
-    ?line ensure_lib_loaded(Config, 1),
-    ?line ok = length_test(hejsan, "hejsan", [], [], not_a_list, [1,2|3]).
+    ensure_lib_loaded(Config, 1),
+    ok = length_test(hejsan, "hejsan", [], [], not_a_list, [1,2|3]).
 
 ensure_lib_loaded(Config) ->
     ensure_lib_loaded(Config, 1).
 ensure_lib_loaded(Config, Ver) ->
-    ?line case lib_version() of
+    case lib_version() of
 	      undefined ->
-		  ?line Path = proplists:get_value(data_dir, Config),
-		  ?line Lib = "nif_SUITE." ++ integer_to_list(Ver),
-		  ?line ok = erlang:load_nif(filename:join(Path,Lib), []);
+		  Path = proplists:get_value(data_dir, Config),
+		  Lib = "nif_SUITE." ++ integer_to_list(Ver),
+		  ok = erlang:load_nif(filename:join(Path,Lib), []);
 	      Ver when is_integer(Ver) ->
 		  ok
 	  end.
 
 make_atom(Config) when is_list(Config) ->
-    ?line ensure_lib_loaded(Config, 1),
+    ensure_lib_loaded(Config, 1),
     An0Atom = an0atom,
     An0Atom0 = 'an\000atom\000',
-    ?line Atoms = make_atoms(),
-    ?line 7 = size(Atoms),
-    ?line Atoms = {An0Atom,An0Atom,An0Atom,An0Atom0,An0Atom,An0Atom,An0Atom0}.
+    Atoms = make_atoms(),
+    7 = size(Atoms),
+    Atoms = {An0Atom,An0Atom,An0Atom,An0Atom0,An0Atom,An0Atom,An0Atom0}.
 
 make_string(Config) when is_list(Config) ->
-    ?line ensure_lib_loaded(Config, 1),
-    ?line Strings = make_strings(),
-    ?line 5 = size(Strings),
+    ensure_lib_loaded(Config, 1),
+    Strings = make_strings(),
+    5 = size(Strings),
     A0String = "a0string",
     A0String0 = [$a,0,$s,$t,$r,$i,$n,$g,0],
     AStringWithAccents = [$E,$r,$l,$a,$n,$g,$ ,16#e4,$r,$ ,$e,$t,$t,$ ,$g,$e,$n,$e,$r,$e,$l,$l,$t,$ ,$p,$r,$o,$g,$r,$a,$m,$s,$p,$r,16#e5,$k],
-    ?line Strings = {A0String,A0String,A0String,A0String0, AStringWithAccents}.
+    Strings = {A0String,A0String,A0String,A0String0, AStringWithAccents}.
 
 reverse_list_test(Config) ->
-    ?line ensure_lib_loaded(Config, 1),
+    ensure_lib_loaded(Config, 1),
     List = lists:seq(1,100),
     RevList = lists:reverse(List),
-    ?line RevList = reverse_list(List),
-    ?line badarg = reverse_list(foo).
+    RevList = reverse_list(List),
+    badarg = reverse_list(foo).
 
 %% Memory leak of tmp-buffer when inspecting iolist or unaligned binary in unbound environment
 otp_9668(Config) ->
@@ -1409,13 +1408,12 @@ otp_9668(Config) ->
     <<_:5/bitstring,UnalignedBin:10/binary,_/bitstring>> = <<"Abuse me as unaligned">>,
     otp_9668_nif(UnalignedBin),
 
-    ?line verify_tmpmem(TmpMem),
+    verify_tmpmem(TmpMem),
     ok.
 
 %% Copy of writable binary
 otp_9828(Config) ->
     ensure_lib_loaded(Config, 1),
-
     otp_9828_loop(<<"I'm alive!">>, 1000).
 
 otp_9828_loop(Bin, 0) ->
@@ -1434,68 +1432,68 @@ consume_timeslice(Config) when is_list(Config) ->
     Done = make_ref(),
     DummyMFA = {?MODULE,dummy_call,1},
     P = spawn(fun () ->
-		      receive Go -> ok end,
-		      {reductions, R1} = process_info(self(), reductions),
-		      1 = consume_timeslice_nif(100, false),
-		      dummy_call(111),
-		      0 = consume_timeslice_nif(90, false),
-		      dummy_call(222),
-		      1 = consume_timeslice_nif(10, false),
-		      dummy_call(333),
-		      0 = consume_timeslice_nif(25, false),
-		      0 = consume_timeslice_nif(25, false),
-		      0 = consume_timeslice_nif(25, false),
-		      1 = consume_timeslice_nif(25, false),
-		      0 = consume_timeslice_nif(25, false),
-
-		      ok = case consume_timeslice_nif(1, true) of
-			       Cnt when Cnt > 70, Cnt < 80 -> ok;
-			       Other -> Other
-			   end,
-		      dummy_call(444),
-
-		      {reductions, R2} = process_info(self(), reductions),
-		      Me ! {RedDiff, R2 - R1},
-		      exit(Done)
-	end),
+                      receive Go -> ok end,
+                      {reductions, R1} = process_info(self(), reductions),
+                      1 = consume_timeslice_nif(100, false),
+                      dummy_call(111),
+                      0 = consume_timeslice_nif(90, false),
+                      dummy_call(222),
+                      1 = consume_timeslice_nif(10, false),
+                      dummy_call(333),
+                      0 = consume_timeslice_nif(25, false),
+                      0 = consume_timeslice_nif(25, false),
+                      0 = consume_timeslice_nif(25, false),
+                      1 = consume_timeslice_nif(25, false),
+                      0 = consume_timeslice_nif(25, false),
+
+                      ok = case consume_timeslice_nif(1, true) of
+                               Cnt when Cnt > 70, Cnt < 80 -> ok;
+                               Other -> Other
+                           end,
+                      dummy_call(444),
+
+                      {reductions, R2} = process_info(self(), reductions),
+                      Me ! {RedDiff, R2 - R1},
+                      exit(Done)
+              end),
     erlang:yield(),
 
     erlang:trace_pattern(DummyMFA, [], [local]),
-    ?line 1 = erlang:trace(P, true, [call, running, procs, {tracer, self()}]),
+    1 = erlang:trace(P, true, [call, running, procs, {tracer, self()}]),
 
     P ! Go,
 
     %% receive Go -> ok end,
-    ?line {trace, P, in, _} = next_tmsg(P),
+    {trace, P, in, _} = next_tmsg(P),
     
     %% consume_timeslice_nif(100),
     %% dummy_call(111)
-    ?line {trace, P, out, _} = next_tmsg(P),
-    ?line {trace, P, in, _} = next_tmsg(P),
-    ?line {trace, P, call, {?MODULE,dummy_call,[111]}} = next_tmsg(P),
+    {trace, P, out, _} = next_tmsg(P),
+    {trace, P, in, _} = next_tmsg(P),
+    {trace, P, call, {?MODULE,dummy_call,[111]}} = next_tmsg(P),
 
     %% consume_timeslice_nif(90),
     %% dummy_call(222)
-    ?line {trace, P, call, {?MODULE,dummy_call,[222]}} = next_tmsg(P),
+    {trace, P, call, {?MODULE,dummy_call,[222]}} = next_tmsg(P),
 
     %% consume_timeslice_nif(10),
     %% dummy_call(333)
-    ?line {trace, P, out, _} = next_tmsg(P),
-    ?line {trace, P, in, _} = next_tmsg(P),
-    ?line {trace, P, call, {?MODULE,dummy_call,[333]}} = next_tmsg(P),
+    {trace, P, out, _} = next_tmsg(P),
+    {trace, P, in, _} = next_tmsg(P),
+    {trace, P, call, {?MODULE,dummy_call,[333]}} = next_tmsg(P),
 
     %% 25,25,25,25, 25
-    ?line {trace, P, out, {?MODULE,consume_timeslice_nif,2}} = next_tmsg(P),
-    ?line {trace, P, in, {?MODULE,consume_timeslice_nif,2}} = next_tmsg(P),
+    {trace, P, out, {?MODULE,consume_timeslice_nif,2}} = next_tmsg(P),
+    {trace, P, in, {?MODULE,consume_timeslice_nif,2}} = next_tmsg(P),
 
     %% consume_timeslice(1,true)
     %% dummy_call(444)
-    ?line {trace, P, out, DummyMFA} = next_tmsg(P),
-    ?line {trace, P, in, DummyMFA} = next_tmsg(P),
-    ?line {trace, P, call, {?MODULE,dummy_call,[444]}} = next_tmsg(P),
+    {trace, P, out, DummyMFA} = next_tmsg(P),
+    {trace, P, in, DummyMFA} = next_tmsg(P),
+    {trace, P, call, {?MODULE,dummy_call,[444]}} = next_tmsg(P),
 
     %% exit(Done)
-    ?line {trace, P, exit, Done} = next_tmsg(P),
+    {trace, P, exit, Done} = next_tmsg(P),
 
     ExpReds = (100 + 90 + 10 + 25*5 + 75) * CONTEXT_REDS div 100,
     receive
@@ -1560,38 +1558,38 @@ dirty_nif_send(Config) when is_list(Config) ->
 
 dirty_nif_exception(Config) when is_list(Config) ->
     try erlang:system_info(dirty_cpu_schedulers) of
-	N when is_integer(N) ->
-	    ensure_lib_loaded(Config),
-	    try
-		%% this checks that the expected exception occurs when the
-		%% dirty NIF returns the result of enif_make_badarg
-		%% directly
-	        call_dirty_nif_exception(1),
-	        ct:fail(expected_badarg)
-	    catch
-	        error:badarg ->
-		    [{?MODULE,call_dirty_nif_exception,[1],_}|_] =
-			erlang:get_stacktrace(),
-		    ok
-	    end,
-	    try
-		%% this checks that the expected exception occurs when the
-		%% dirty NIF calls enif_make_badarg at some point but then
-		%% returns a value that isn't an exception
-	        call_dirty_nif_exception(0),
-	        ct:fail(expected_badarg)
-	    catch
-	        error:badarg ->
-		    [{?MODULE,call_dirty_nif_exception,[0],_}|_] =
-			erlang:get_stacktrace(),
-		    ok
-	    end,
-	    %% this checks that a dirty NIF can raise various terms as
-	    %% exceptions
-	    ok = nif_raise_exceptions(call_dirty_nif_exception)
+        N when is_integer(N) ->
+            ensure_lib_loaded(Config),
+            try
+                %% this checks that the expected exception occurs when the
+                %% dirty NIF returns the result of enif_make_badarg
+                %% directly
+                call_dirty_nif_exception(1),
+                ct:fail(expected_badarg)
+            catch
+                error:badarg ->
+                    [{?MODULE,call_dirty_nif_exception,[1],_}|_] =
+                    erlang:get_stacktrace(),
+                    ok
+            end,
+            try
+                %% this checks that the expected exception occurs when the
+                %% dirty NIF calls enif_make_badarg at some point but then
+                %% returns a value that isn't an exception
+                call_dirty_nif_exception(0),
+                ct:fail(expected_badarg)
+            catch
+                error:badarg ->
+                    [{?MODULE,call_dirty_nif_exception,[0],_}|_] =
+                    erlang:get_stacktrace(),
+                    ok
+            end,
+            %% this checks that a dirty NIF can raise various terms as
+            %% exceptions
+            ok = nif_raise_exceptions(call_dirty_nif_exception)
     catch
-	error:badarg ->
-	    {skipped,"No dirty scheduler support"}
+        error:badarg ->
+            {skipped,"No dirty scheduler support"}
     end.
 
 nif_exception(Config) when is_list(Config) ->
@@ -1653,19 +1651,19 @@ nif_atom_too_long(Config) when is_list(Config) ->
 
 next_msg(_Pid) ->
     receive
-	M -> M
+        M -> M
     after 100 ->
-	  none
+              none
     end.
 
 next_tmsg(Pid) ->    
     receive TMsg when is_tuple(TMsg),
-		      element(1, TMsg) == trace,
-		      element(2, TMsg) == Pid ->
-     	    TMsg
-     after 100 ->
-     	    none
-     end.
+                      element(1, TMsg) == trace,
+                      element(2, TMsg) == Pid ->
+                TMsg
+    after 100 ->
+              none
+    end.
 
 dummy_call(_) ->    
     ok.
@@ -1733,17 +1731,17 @@ check(Exp,Got,Line) ->
 
 nif_raise_exceptions(NifFunc) ->
     ExcTerms = [{error, test}, "a string", <<"a binary">>,
-		42, [1,2,3,4,5], [{p,1},{p,2},{p,3}]],
+                42, [1,2,3,4,5], [{p,1},{p,2},{p,3}]],
     lists:foldl(fun(Term, ok) ->
-			try
-			    erlang:apply(?MODULE,NifFunc,[Term]),
-			    ct:fail({expected,Term})
-			catch
-			    error:Term ->
-				[{?MODULE,NifFunc,[Term],_}|_] = erlang:get_stacktrace(),
-				ok
-			end
-		end, ok, ExcTerms).
+                        try
+                            erlang:apply(?MODULE,NifFunc,[Term]),
+                            ct:fail({expected,Term})
+                        catch
+                            error:Term ->
+                                [{?MODULE,NifFunc,[Term],_}|_] = erlang:get_stacktrace(),
+                                ok
+                        end
+                end, ok, ExcTerms).
 
 -define(ERL_NIF_TIME_ERROR, -9223372036854775808).
 -define(TIME_UNITS, [seconds, milli_seconds, micro_seconds, nano_seconds]).
@@ -1789,25 +1787,25 @@ chk_toffs([TU|TUs]) ->
     TO = erlang:time_offset(TU),
     NifTO = time_offset(TU),
     case TO =:= NifTO of
-	true ->
-	    ok;
-	false ->
-	    case erlang:system_info(time_warp_mode) of
-		no_time_warp ->
-		    ct:fail({time_offset_mismatch, TU, TO, NifTO});
-		_ ->
-		    %% Most frequent time offset change
-		    %% is currently only every 15:th
-		    %% second so this should currently
-		    %% work...
-		    NTO = erlang:time_offset(TU),
-		    case NifTO =:= NTO of
-			true ->
-			    ok;
-			false ->
-			    ct:fail({time_offset_mismatch, TU, TO, NifTO, NTO})
-		    end
-	    end
+        true ->
+            ok;
+        false ->
+            case erlang:system_info(time_warp_mode) of
+                no_time_warp ->
+                    ct:fail({time_offset_mismatch, TU, TO, NifTO});
+                _ ->
+                    %% Most frequent time offset change
+                    %% is currently only every 15:th
+                    %% second so this should currently
+                    %% work...
+                    NTO = erlang:time_offset(TU),
+                    case NifTO =:= NTO of
+                        true ->
+                            ok;
+                        false ->
+                            ct:fail({time_offset_mismatch, TU, TO, NifTO, NTO})
+                    end
+            end
     end,
     chk_toffs(TUs).
 
@@ -1816,47 +1814,47 @@ nif_convert_time_unit(Config) ->
     ?ERL_NIF_TIME_ERROR = convert_time_unit(0, invalid_time_unit, seconds),
     ?ERL_NIF_TIME_ERROR = convert_time_unit(0, invalid_time_unit, invalid_time_unit),
     lists:foreach(fun (Offset) ->
-			  lists:foreach(fun (Diff) ->
-						chk_ctu(Diff+(Offset*1000*1000*1000))
-					end,
-					[999999999999,
-					 99999999999,
-					 9999999999,
-					 999999999,
-					 99999999,
-					 9999999,
-					 999999,
-					 99999,
-					 999,
-					 99,
-					 9,
-					 1,
-					 11,
-					 101,
-					 1001,
-					 10001,
-					 100001,
-					 1000001,
-					 10000001,
-					 100000001,
-					 1000000001,
-					 100000000001,
-					 1000000000001,
-					 5,
-					 50,
-					 500,
-					 5000,
-					 50000,
-					 500000,
-					 5000000,
-					 50000000,
-					 500000000,
-					 5000000000,
-					 50000000000,
-					 500000000000])
-		  end,
-		  [-4711, -1000, -475, -5, -4, -3, -2, -1, 0,
-		   1, 2, 3, 4, 5, 475, 1000, 4711]),
+                          lists:foreach(fun (Diff) ->
+                                                chk_ctu(Diff+(Offset*1000*1000*1000))
+                                        end,
+                                        [999999999999,
+                                         99999999999,
+                                         9999999999,
+                                         999999999,
+                                         99999999,
+                                         9999999,
+                                         999999,
+                                         99999,
+                                         999,
+                                         99,
+                                         9,
+                                         1,
+                                         11,
+                                         101,
+                                         1001,
+                                         10001,
+                                         100001,
+                                         1000001,
+                                         10000001,
+                                         100000001,
+                                         1000000001,
+                                         100000000001,
+                                         1000000000001,
+                                         5,
+                                         50,
+                                         500,
+                                         5000,
+                                         50000,
+                                         500000,
+                                         5000000,
+                                         50000000,
+                                         500000000,
+                                         5000000000,
+                                         50000000000,
+                                         500000000000])
+                  end,
+                  [-4711, -1000, -475, -5, -4, -3, -2, -1, 0,
+                   1, 2, 3, 4, 5, 475, 1000, 4711]),
     ctu_loop(1000000).
 
 ctu_loop(0) ->