Remove ?line macros

While we are it, also re-ident the files.

1 files changed, 322 insertions, 322 deletions

diff --git a/lib/kernel/test/ram_file_SUITE.erl b/lib/kernel/test/ram_file_SUITE.erl
index f6d02c67eb..d90995923a 100644
--- a/lib/kernel/test/ram_file_SUITE.erl
+++ b/lib/kernel/test/ram_file_SUITE.erl
@@ -73,12 +73,12 @@ end_per_testcase(_Func, Config) ->
 
 %% Test that the basic read, write and binary options works for open/2.
 open_modes(Config) when is_list(Config) ->
-    ?line Str1 = "The quick brown fox ",
-    ?line Str2 = "jumps over a lazy dog ",
-    ?line Str  = Str1 ++ Str2,
-    ?line Bin1 = list_to_binary(Str1),
-    ?line Bin2 = list_to_binary(Str2),
-    ?line Bin  = list_to_binary(Str),
+    Str1 = "The quick brown fox ",
+    Str2 = "jumps over a lazy dog ",
+    Str  = Str1 ++ Str2,
+    Bin1 = list_to_binary(Str1),
+    Bin2 = list_to_binary(Str2),
+    Bin  = list_to_binary(Str),
     %%
     open_read_write(?FILE_MODULE, Str1, [ram, read, write], Str2),
     open_read(?FILE_MODULE, Str, [ram]),
@@ -90,12 +90,12 @@ open_modes(Config) when is_list(Config) ->
 %% Test that the old style read, write and binary options
 %% works for open/2.
 open_old_modes(Config) when is_list(Config) ->
-    ?line Str1 = "The quick brown fox ",
-    ?line Str2 = "jumps over a lazy dog ",
-    ?line Str  = Str1 ++ Str2,
-    ?line Bin1 = list_to_binary(Str1),
-    ?line Bin2 = list_to_binary(Str2),
-    ?line Bin  = list_to_binary(Str),
+    Str1 = "The quick brown fox ",
+    Str2 = "jumps over a lazy dog ",
+    Str  = Str1 ++ Str2,
+    Bin1 = list_to_binary(Str1),
+    Bin2 = list_to_binary(Str2),
+    Bin  = list_to_binary(Str),
     %%
     open_read_write(?RAM_FILE_MODULE, Str1, read_write, Str2),
     open_read(?RAM_FILE_MODULE, Str, read),
@@ -105,54 +105,54 @@ open_old_modes(Config) when is_list(Config) ->
     ok.
 
 open_read_write(Module, Data1, Options, Data2) ->
-    ?line io:format("~p:open_read_write(~p, ~p, ~p, ~p)~n", 
-		    [?MODULE, Module, Data1, Options, Data2]),
-    %%
-    ?line Size1 = sizeof(Data1),
-    ?line Size2 = sizeof(Data2),
-    ?line Data  = append(Data1, Data2),
-    ?line Size  = Size1 + Size2,
-    %%
-    ?line {ok, Fd}    = Module:open(Data1, Options),
-    ?line {ok, Data1} = Module:read(Fd, Size1),
-    ?line eof         = Module:read(Fd, 1),
-    ?line {ok, Zero}  = Module:read(Fd, 0),
-    ?line 0           = sizeof(Zero),
-    ?line ok          = Module:write(Fd, Data2),
-    ?line {ok, 0}     = Module:position(Fd, bof),
-    ?line {ok, Data}  = Module:read(Fd, Size),
-    ?line eof         = Module:read(Fd, 1),
-    ?line {ok, Zero}  = Module:read(Fd, 0),
-    ?line ok          = Module:close(Fd),
-    %%
-    ?line ok.
+    io:format("~p:open_read_write(~p, ~p, ~p, ~p)~n",
+	      [?MODULE, Module, Data1, Options, Data2]),
+    %%
+    Size1 = sizeof(Data1),
+    Size2 = sizeof(Data2),
+    Data  = append(Data1, Data2),
+    Size  = Size1 + Size2,
+    %%
+    {ok, Fd}    = Module:open(Data1, Options),
+    {ok, Data1} = Module:read(Fd, Size1),
+    eof         = Module:read(Fd, 1),
+    {ok, Zero}  = Module:read(Fd, 0),
+    0           = sizeof(Zero),
+    ok          = Module:write(Fd, Data2),
+    {ok, 0}     = Module:position(Fd, bof),
+    {ok, Data}  = Module:read(Fd, Size),
+    eof         = Module:read(Fd, 1),
+    {ok, Zero}  = Module:read(Fd, 0),
+    ok          = Module:close(Fd),
+    %%
+    ok.
 
 open_read(Module, Data, Options) ->
-    ?line io:format("~p:open_read(~p, ~p, ~p)~n", 
-		    [?MODULE, Module, Data, Options]),
-    %%
-    ?line Size = sizeof(Data),
+    io:format("~p:open_read(~p, ~p, ~p)~n",
+	      [?MODULE, Module, Data, Options]),
+    %%
+    Size = sizeof(Data),
+    %%
+    {ok, Fd}         = Module:open(Data, Options),
+    {ok, Data}       = Module:read(Fd, Size),
+    eof              = Module:read(Fd, 1),
+    {ok, Zero}       = Module:read(Fd, 0),
+    0                = sizeof(Zero),
+    {error, ebadf}   = Module:write(Fd, Data),
+    {ok, 0}          = Module:position(Fd, bof),
+    {ok, Data}       = Module:read(Fd, Size),
+    eof              = Module:read(Fd, 1),
+    {ok, Zero}       = Module:read(Fd, 0),
+    ok               = Module:close(Fd),
     %%
-    ?line {ok, Fd}         = Module:open(Data, Options),
-    ?line {ok, Data}       = Module:read(Fd, Size),
-    ?line eof              = Module:read(Fd, 1),
-    ?line {ok, Zero}       = Module:read(Fd, 0),
-    ?line 0                = sizeof(Zero),
-    ?line {error, ebadf}   = Module:write(Fd, Data),
-    ?line {ok, 0}          = Module:position(Fd, bof),
-    ?line {ok, Data}       = Module:read(Fd, Size),
-    ?line eof              = Module:read(Fd, 1),
-    ?line {ok, Zero}       = Module:read(Fd, 0),
-    ?line ok               = Module:close(Fd),
-    %%
-    ?line ok.
+    ok.
 
 
 
 %% Test that pread/2,3 and pwrite/2,3 works.
 pread_pwrite(Config) when is_list(Config) ->
-    ?line Str = "Flygande bäckaziner söka hwila på mjuqa tuvor x",
-    ?line Bin = list_to_binary(Str),
+    Str = "Flygande bäckaziner söka hwila på mjuqa tuvor x",
+    Bin = list_to_binary(Str),
     %%
     pread_pwrite_test(?FILE_MODULE, Str, [ram, read, write]),
     pread_pwrite_test(?FILE_MODULE, Bin, [ram, binary, read, write]),
@@ -162,33 +162,33 @@ pread_pwrite(Config) when is_list(Config) ->
     ok.
 
 pread_pwrite_test(Module, Data, Options) ->
-    ?line io:format("~p:pread_pwrite_test(~p, ~p, ~p)~n", 
-		    [?MODULE, Module, Data, Options]),
-    %%
-    ?line Size = sizeof(Data),
-    %%
-    ?line {ok, Fd}         = Module:open([], Options),
-    ?line ok               = Module:pwrite(Fd, 0, Data),
-    ?line {ok, Data}       = Module:pread(Fd, 0, Size+1),
-    ?line eof              = Module:pread(Fd, Size+1, 1),
-    ?line {ok, Zero}       = Module:pread(Fd, Size+1, 0),
-    ?line 0                = sizeof(Zero),
-    ?line ok               = Module:pwrite(Fd, [{0, Data}, {Size+17, Data}]),
-    ?line {ok, [Data, 
-		eof, 
-		Data,
-		Zero]}     = Module:pread(Fd, [{Size+17, Size+1},
-					       {2*Size+17+1, 1},
-					       {0, Size},
-					       {2*Size+17+1, 0}]),
-    ?line ok               = Module:close(Fd),
-    %%
-    ?line ok.
+    io:format("~p:pread_pwrite_test(~p, ~p, ~p)~n",
+	      [?MODULE, Module, Data, Options]),
+    %%
+    Size = sizeof(Data),
+    %%
+    {ok, Fd}         = Module:open([], Options),
+    ok               = Module:pwrite(Fd, 0, Data),
+    {ok, Data}       = Module:pread(Fd, 0, Size+1),
+    eof              = Module:pread(Fd, Size+1, 1),
+    {ok, Zero}       = Module:pread(Fd, Size+1, 0),
+    0                = sizeof(Zero),
+    ok               = Module:pwrite(Fd, [{0, Data}, {Size+17, Data}]),
+    {ok, [Data,
+	  eof,
+	  Data,
+	  Zero]}     = Module:pread(Fd, [{Size+17, Size+1},
+					 {2*Size+17+1, 1},
+					 {0, Size},
+					 {2*Size+17+1, 0}]),
+    ok               = Module:close(Fd),
+    %%
+    ok.
 
 %% Test that position/2 works.
 position(Config) when is_list(Config) ->
-    ?line Str = "Att vara eller icke vara, det är frågan. ",
-    ?line Bin = list_to_binary(Str),
+    Str = "Att vara eller icke vara, det är frågan. ",
+    Bin = list_to_binary(Str),
     %%
     position_test(?FILE_MODULE, Str, [ram, read]),
     position_test(?FILE_MODULE, Bin, [ram, binary]),
@@ -198,76 +198,76 @@ position(Config) when is_list(Config) ->
     ok.
 
 position_test(Module, Data, Options) ->
-    ?line io:format("~p:position_test(~p, ~p, ~p)~n", 
-		    [?MODULE, Module, Data, Options]),
-    %%
-    ?line Size = sizeof(Data),
-    ?line Size_7 = Size+7,
-    %%
-    ?line Slice_0_2 = slice(Data, 0, 2),
-    ?line Slice_0_3 = slice(Data, 0, 3),
-    ?line Slice_2_5 = slice(Data, 2, 5),
-    ?line Slice_3_4 = slice(Data, 3, 4),
-    ?line Slice_5   = slice(Data, 5, Size),
-    %%
-    ?line {ok, Fd}          = Module:open(Data, Options),
-    %%
-    ?line io:format("CUR positions"),
-    ?line {ok, Slice_0_2}   = Module:read(Fd, 2),
-    ?line {ok, 2}           = Module:position(Fd, cur),
-    ?line {ok, Slice_2_5}   = Module:read(Fd, 5),
-    ?line {ok, 3}           = Module:position(Fd, {cur, -4}),
-    ?line {ok, Slice_3_4}   = Module:read(Fd, 4),
-    ?line {ok, 0}           = Module:position(Fd, {cur, -7}),
-    ?line {ok, Slice_0_3}   = Module:read(Fd, 3),
-    ?line {ok, 0}           = Module:position(Fd, {cur, -3}),
-    ?line {error, einval}   = Module:position(Fd, {cur, -1}),
-    ?line {ok, 0}           = Module:position(Fd, 0),
-    ?line {ok, 2}           = Module:position(Fd, {cur, 2}),
-    ?line {ok, Slice_2_5}   = Module:read(Fd, 5),
-    ?line {ok, Size_7}      = Module:position(Fd, {cur, Size}),
-    ?line {ok, Zero}        = Module:read(Fd, 0),
-    ?line 0                 = sizeof(Zero),
-    ?line eof               = Module:read(Fd, 1),
-    %%
-    ?line io:format("Absolute and BOF positions"),
-    ?line {ok, Size}        = Module:position(Fd, Size),
-    ?line eof               = Module:read(Fd, 1),
-    ?line {ok, 5}           = Module:position(Fd, 5),
-    ?line {ok, Slice_5}     = Module:read(Fd, Size),
-    ?line {ok, 2}           = Module:position(Fd, {bof, 2}),
-    ?line {ok, Slice_2_5}   = Module:read(Fd, 5),
-    ?line {ok, 3}           = Module:position(Fd, 3),
-    ?line {ok, Slice_3_4}   = Module:read(Fd, 4),
-    ?line {ok, 0}           = Module:position(Fd, bof),
-    ?line {ok, Slice_0_2}   = Module:read(Fd, 2),
-    ?line {ok, Size_7}      = Module:position(Fd, {bof, Size_7}),
-    ?line {ok, Zero}        = Module:read(Fd, 0),
-    %%
-    ?line io:format("EOF positions"),
-    ?line {ok, Size}        = Module:position(Fd, eof),
-    ?line eof               = Module:read(Fd, 1),
-    ?line {ok, 5}           = Module:position(Fd, {eof, -Size+5}),
-    ?line {ok, Slice_5}     = Module:read(Fd, Size),
-    ?line {ok, 2}           = Module:position(Fd, {eof, -Size+2}),
-    ?line {ok, Slice_2_5}   = Module:read(Fd, 5),
-    ?line {ok, 3}           = Module:position(Fd, {eof, -Size+3}),
-    ?line {ok, Slice_3_4}   = Module:read(Fd, 4),
-    ?line {ok, 0}           = Module:position(Fd, {eof, -Size}),
-    ?line {ok, Slice_0_2}   = Module:read(Fd, 2),
-    ?line {ok, Size_7}      = Module:position(Fd, {eof, 7}),
-    ?line {ok, Zero}        = Module:read(Fd, 0),
-    ?line eof               = Module:read(Fd, 1),
-    %%
-    ?line ok.
+    io:format("~p:position_test(~p, ~p, ~p)~n",
+	      [?MODULE, Module, Data, Options]),
+    %%
+    Size = sizeof(Data),
+    Size_7 = Size+7,
+    %%
+    Slice_0_2 = slice(Data, 0, 2),
+    Slice_0_3 = slice(Data, 0, 3),
+    Slice_2_5 = slice(Data, 2, 5),
+    Slice_3_4 = slice(Data, 3, 4),
+    Slice_5   = slice(Data, 5, Size),
+    %%
+    {ok, Fd}          = Module:open(Data, Options),
+    %%
+    io:format("CUR positions"),
+    {ok, Slice_0_2}   = Module:read(Fd, 2),
+    {ok, 2}           = Module:position(Fd, cur),
+    {ok, Slice_2_5}   = Module:read(Fd, 5),
+    {ok, 3}           = Module:position(Fd, {cur, -4}),
+    {ok, Slice_3_4}   = Module:read(Fd, 4),
+    {ok, 0}           = Module:position(Fd, {cur, -7}),
+    {ok, Slice_0_3}   = Module:read(Fd, 3),
+    {ok, 0}           = Module:position(Fd, {cur, -3}),
+    {error, einval}   = Module:position(Fd, {cur, -1}),
+    {ok, 0}           = Module:position(Fd, 0),
+    {ok, 2}           = Module:position(Fd, {cur, 2}),
+    {ok, Slice_2_5}   = Module:read(Fd, 5),
+    {ok, Size_7}      = Module:position(Fd, {cur, Size}),
+    {ok, Zero}        = Module:read(Fd, 0),
+    0                 = sizeof(Zero),
+    eof               = Module:read(Fd, 1),
+    %%
+    io:format("Absolute and BOF positions"),
+    {ok, Size}        = Module:position(Fd, Size),
+    eof               = Module:read(Fd, 1),
+    {ok, 5}           = Module:position(Fd, 5),
+    {ok, Slice_5}     = Module:read(Fd, Size),
+    {ok, 2}           = Module:position(Fd, {bof, 2}),
+    {ok, Slice_2_5}   = Module:read(Fd, 5),
+    {ok, 3}           = Module:position(Fd, 3),
+    {ok, Slice_3_4}   = Module:read(Fd, 4),
+    {ok, 0}           = Module:position(Fd, bof),
+    {ok, Slice_0_2}   = Module:read(Fd, 2),
+    {ok, Size_7}      = Module:position(Fd, {bof, Size_7}),
+    {ok, Zero}        = Module:read(Fd, 0),
+    %%
+    io:format("EOF positions"),
+    {ok, Size}        = Module:position(Fd, eof),
+    eof               = Module:read(Fd, 1),
+    {ok, 5}           = Module:position(Fd, {eof, -Size+5}),
+    {ok, Slice_5}     = Module:read(Fd, Size),
+    {ok, 2}           = Module:position(Fd, {eof, -Size+2}),
+    {ok, Slice_2_5}   = Module:read(Fd, 5),
+    {ok, 3}           = Module:position(Fd, {eof, -Size+3}),
+    {ok, Slice_3_4}   = Module:read(Fd, 4),
+    {ok, 0}           = Module:position(Fd, {eof, -Size}),
+    {ok, Slice_0_2}   = Module:read(Fd, 2),
+    {ok, Size_7}      = Module:position(Fd, {eof, 7}),
+    {ok, Zero}        = Module:read(Fd, 0),
+    eof               = Module:read(Fd, 1),
+    %%
+    ok.
 
 
 
 %% Test that truncate/1 works.
 truncate(Config) when is_list(Config) ->
-    ?line Str = "Mån ädlare att lida och fördraga "
+    Str = "Mån ädlare att lida och fördraga "
 	++ "ett bittert ödes stygn av pilar, ",
-    ?line Bin = list_to_binary(Str),
+    Bin = list_to_binary(Str),
     %%
     ok = truncate_test(?FILE_MODULE, Str, [ram, read, write]),
     ok = truncate_test(?FILE_MODULE, Bin, [ram, binary, read, write]),
@@ -282,32 +282,32 @@ truncate(Config) when is_list(Config) ->
     ok.
 
 truncate_test(Module, Data, Options) ->
-    ?line io:format("~p:truncate_test(~p, ~p, ~p)~n", 
-		    [?MODULE, Module, Data, Options]),
-    %%
-    ?line Size = sizeof(Data),
-    ?line Size1 = Size-2,
-    ?line Data1 = slice(Data, 0, Size1),
-    %%
-    ?line {ok, Fd}    = Module:open(Data, Options),
-    ?line {ok, Size1} = Module:position(Fd, Size1),
-    ?line case Module:truncate(Fd) of
-	      ok ->
-		  ?line {ok, 0}     = Module:position(Fd, 0),
-		  ?line {ok, Data1} = Module:read(Fd, Size),
-		  ?line ok          = Module:close(Fd),
-		  ?line ok;
-	      Error ->
-		  ?line ok      = Module:close(Fd),
-		  ?line Error
-	  end.
+    io:format("~p:truncate_test(~p, ~p, ~p)~n",
+	      [?MODULE, Module, Data, Options]),
+    %%
+    Size = sizeof(Data),
+    Size1 = Size-2,
+    Data1 = slice(Data, 0, Size1),
+    %%
+    {ok, Fd}    = Module:open(Data, Options),
+    {ok, Size1} = Module:position(Fd, Size1),
+    case Module:truncate(Fd) of
+	ok ->
+	    {ok, 0}     = Module:position(Fd, 0),
+	    {ok, Data1} = Module:read(Fd, Size),
+	    ok          = Module:close(Fd),
+	    ok;
+	Error ->
+	    ok      = Module:close(Fd),
+	    Error
+    end.
 
 
 
 %% Test that sync/1 at least does not crash.
 sync(Config) when is_list(Config) ->
-    ?line Str = "än att ta till vapen mot ett hav av kval. ",
-    ?line Bin = list_to_binary(Str),
+    Str = "än att ta till vapen mot ett hav av kval. ",
+    Bin = list_to_binary(Str),
     %%
     sync_test(?FILE_MODULE, Str, [ram, read, write]),
     sync_test(?FILE_MODULE, Bin, [ram, binary, read, write]),
@@ -322,25 +322,25 @@ sync(Config) when is_list(Config) ->
     ok.
 
 sync_test(Module, Data, Options) ->
-    ?line io:format("~p:sync_test(~p, ~p, ~p)~n", 
-		    [?MODULE, Module, Data, Options]),
+    io:format("~p:sync_test(~p, ~p, ~p)~n",
+	      [?MODULE, Module, Data, Options]),
     %%
-    ?line Size = sizeof(Data),
+    Size = sizeof(Data),
     %%
-    ?line {ok, Fd}    = Module:open(Data, Options),
-    ?line ok          = Module:sync(Fd),
-    ?line {ok, Data}  = Module:read(Fd, Size+1),
-    ?line ok.
+    {ok, Fd}    = Module:open(Data, Options),
+    ok          = Module:sync(Fd),
+    {ok, Data}  = Module:read(Fd, Size+1),
+    ok.
 
 
 
 %% Tests get_file/1, set_file/2, get_file_close/1 and get_size/1.
 get_set_file(Config) when is_list(Config) ->
     %% These two strings should not be of equal length.
-    ?line Str  = "När högan nord blir snöbetäckt, ",
-    ?line Str2 = "får alla harar byta dräkt. ",
-    ?line Bin  = list_to_binary(Str),
-    ?line Bin2 = list_to_binary(Str2),
+    Str  = "När högan nord blir snöbetäckt, ",
+    Str2 = "får alla harar byta dräkt. ",
+    Bin  = list_to_binary(Str),
+    Bin2 = list_to_binary(Str2),
     %%
     ok = get_set_file_test(Str, read_write, Str2),
     ok = get_set_file_test(Bin, [binary, read, write], Bin2),
@@ -350,84 +350,84 @@ get_set_file(Config) when is_list(Config) ->
     ok.
 
 get_set_file_test(Data, Options, Data2) ->
-    ?line io:format("~p:get_set_file_test(~p, ~p, ~p)~n", 
-		    [?MODULE, Data, Options, Data2]),
-    %%
-    ?line Size  = sizeof(Data),
-    ?line Size2 = sizeof(Data2),
-    %%
-    ?line {ok, Fd}        = ?RAM_FILE_MODULE:open(Data, Options),
-    ?line {ok, Size}      = ?RAM_FILE_MODULE:get_size(Fd),
-    ?line {ok, Data}      = ?RAM_FILE_MODULE:get_file(Fd),
-    ?line {ok, Data}      = ?RAM_FILE_MODULE:get_file_close(Fd),
-    ?line {error, einval} = ?RAM_FILE_MODULE:get_size(Fd),
-    ?line {ok, Fd2}       = ?RAM_FILE_MODULE:open(Data, Options),
-    ?line case ?RAM_FILE_MODULE:set_file(Fd2, Data2) of
-	      {ok, Size2} ->
-		  ?line {ok, Size2} = ?RAM_FILE_MODULE:get_size(Fd2),
-		  ?line {ok, Data2} = ?RAM_FILE_MODULE:get_file(Fd2),
-		  ?line {ok, Data2} = ?RAM_FILE_MODULE:get_file_close(Fd2),
-		  ?line ok;
-	      {error, _} = Error ->
-		  ?line {ok, Data}  = ?RAM_FILE_MODULE:get_file_close(Fd2),
-		  ?line Error
-	  end.
-    
-
-    
+    io:format("~p:get_set_file_test(~p, ~p, ~p)~n",
+	      [?MODULE, Data, Options, Data2]),
+    %%
+    Size  = sizeof(Data),
+    Size2 = sizeof(Data2),
+    %%
+    {ok, Fd}        = ?RAM_FILE_MODULE:open(Data, Options),
+    {ok, Size}      = ?RAM_FILE_MODULE:get_size(Fd),
+    {ok, Data}      = ?RAM_FILE_MODULE:get_file(Fd),
+    {ok, Data}      = ?RAM_FILE_MODULE:get_file_close(Fd),
+    {error, einval} = ?RAM_FILE_MODULE:get_size(Fd),
+    {ok, Fd2}       = ?RAM_FILE_MODULE:open(Data, Options),
+    case ?RAM_FILE_MODULE:set_file(Fd2, Data2) of
+	{ok, Size2} ->
+	    {ok, Size2} = ?RAM_FILE_MODULE:get_size(Fd2),
+	    {ok, Data2} = ?RAM_FILE_MODULE:get_file(Fd2),
+	    {ok, Data2} = ?RAM_FILE_MODULE:get_file_close(Fd2),
+	    ok;
+	{error, _} = Error ->
+	    {ok, Data}  = ?RAM_FILE_MODULE:get_file_close(Fd2),
+	    Error
+    end.
+
+
+
 %% Test that compress/1 and uncompress/1 works.
 compress(Config) when is_list(Config) ->
     Data   = proplists:get_value(data_dir, Config),
-    ?line Real   = filename:join(Data, "realmen.html"),
-    ?line RealGz = filename:join(Data, "realmen.html.gz"),
+    Real   = filename:join(Data, "realmen.html"),
+    RealGz = filename:join(Data, "realmen.html.gz"),
     %%
     %% Uncompress test
     %%
-    ?line {ok, FdReal}   = ?FILE_MODULE:open(Real, []),
-    ?line {ok, Fd}       = ?FILE_MODULE:open([], [ram, read, write]),
-    ?line {ok, FdRealGz} = ?FILE_MODULE:open(RealGz, []),
+    {ok, FdReal}   = ?FILE_MODULE:open(Real, []),
+    {ok, Fd}       = ?FILE_MODULE:open([], [ram, read, write]),
+    {ok, FdRealGz} = ?FILE_MODULE:open(RealGz, []),
     %%
-    ?line {ok, SzGz}     = ?FILE_MODULE:copy(FdRealGz, Fd),
-    ?line {ok, Sz}       = ?RAM_FILE_MODULE:uncompress(Fd),
-    ?line {ok, 0}        = ?FILE_MODULE:position(Fd, bof),
-    ?line true           = compare(FdReal, Fd),
+    {ok, SzGz}     = ?FILE_MODULE:copy(FdRealGz, Fd),
+    {ok, Sz}       = ?RAM_FILE_MODULE:uncompress(Fd),
+    {ok, 0}        = ?FILE_MODULE:position(Fd, bof),
+    true           = compare(FdReal, Fd),
     %%
-    ?line true           = (SzGz =< Sz),
+    true           = (SzGz =< Sz),
     %%
     %% Compress and uncompress test
     %%
-    ?line {ok, 0}        = ?FILE_MODULE:position(FdReal, bof),
-    ?line {ok, 0}        = ?FILE_MODULE:position(Fd, bof),
-    ?line ok             = ?FILE_MODULE:truncate(Fd),
-    ?line {ok, Sz}       = ?FILE_MODULE:copy(FdReal, Fd),
-    ?line {ok, SzGz}     = ?RAM_FILE_MODULE:compress(Fd),
-    ?line {ok, Sz}       = ?RAM_FILE_MODULE:uncompress(Fd),
-    ?line {ok, 0}        = ?FILE_MODULE:position(Fd, bof),
-    ?line {ok, 0}        = ?FILE_MODULE:position(FdReal, bof),
-    ?line true           = compare(FdReal, Fd),
+    {ok, 0}        = ?FILE_MODULE:position(FdReal, bof),
+    {ok, 0}        = ?FILE_MODULE:position(Fd, bof),
+    ok             = ?FILE_MODULE:truncate(Fd),
+    {ok, Sz}       = ?FILE_MODULE:copy(FdReal, Fd),
+    {ok, SzGz}     = ?RAM_FILE_MODULE:compress(Fd),
+    {ok, Sz}       = ?RAM_FILE_MODULE:uncompress(Fd),
+    {ok, 0}        = ?FILE_MODULE:position(Fd, bof),
+    {ok, 0}        = ?FILE_MODULE:position(FdReal, bof),
+    true           = compare(FdReal, Fd),
     %%
-    ?line ok             = ?FILE_MODULE:close(FdReal),
-    ?line ok             = ?FILE_MODULE:close(Fd),
-    ?line ok             = ?FILE_MODULE:close(FdRealGz),
+    ok             = ?FILE_MODULE:close(FdReal),
+    ok             = ?FILE_MODULE:close(Fd),
+    ok             = ?FILE_MODULE:close(FdRealGz),
 
 
     %% Test uncompressing data that will be expanded many times.
-    ?line Huge = iolist_to_binary(mk_42(18)),
-    ?line HugeSize = byte_size(Huge),
-    ?line HugeGz = zlib:gzip(Huge),
+    Huge = iolist_to_binary(mk_42(18)),
+    HugeSize = byte_size(Huge),
+    HugeGz = zlib:gzip(Huge),
 
-    ?line {ok,HugeFd} = ?FILE_MODULE:open([], [ram,read,write,binary]),
-    ?line ok = ?FILE_MODULE:write(HugeFd, HugeGz),
-    ?line {ok,HugeSize} = ?RAM_FILE_MODULE:uncompress(HugeFd),
-    ?line {ok,0} = ?FILE_MODULE:position(HugeFd, bof),
-    ?line {ok,Huge} = ?FILE_MODULE:read(HugeFd, HugeSize),
+    {ok,HugeFd} = ?FILE_MODULE:open([], [ram,read,write,binary]),
+    ok = ?FILE_MODULE:write(HugeFd, HugeGz),
+    {ok,HugeSize} = ?RAM_FILE_MODULE:uncompress(HugeFd),
+    {ok,0} = ?FILE_MODULE:position(HugeFd, bof),
+    {ok,Huge} = ?FILE_MODULE:read(HugeFd, HugeSize),
 
     %% Uncompressing again should do nothing.
-    ?line {ok,HugeSize} = ?RAM_FILE_MODULE:uncompress(HugeFd),
-    ?line {ok,0} = ?FILE_MODULE:position(HugeFd, bof),
-    ?line {ok,Huge} = ?FILE_MODULE:read(HugeFd, HugeSize),
+    {ok,HugeSize} = ?RAM_FILE_MODULE:uncompress(HugeFd),
+    {ok,0} = ?FILE_MODULE:position(HugeFd, bof),
+    {ok,Huge} = ?FILE_MODULE:read(HugeFd, HugeSize),
 
-    ?line ok = ?FILE_MODULE:close(HugeFd),
+    ok = ?FILE_MODULE:close(HugeFd),
 
     ok.
 
@@ -440,68 +440,68 @@ mk_42(N) ->
 %% Test that uuencode/1 and uudecode/1 works.
 uuencode(Config) when is_list(Config) ->
     Data   = proplists:get_value(data_dir, Config),
-    ?line Real   = filename:join(Data, "realmen.html"),
-    ?line RealUu = filename:join(Data, "realmen.html.uu"),
+    Real   = filename:join(Data, "realmen.html"),
+    RealUu = filename:join(Data, "realmen.html.uu"),
     %%
     %% Uudecode test
     %%
-    ?line {ok, FdReal}   = ?FILE_MODULE:open(Real, []),
-    ?line {ok, Fd}       = ?FILE_MODULE:open([], [ram, read, write]),
-    ?line {ok, FdRealUu} = ?FILE_MODULE:open(RealUu, []),
+    {ok, FdReal}   = ?FILE_MODULE:open(Real, []),
+    {ok, Fd}       = ?FILE_MODULE:open([], [ram, read, write]),
+    {ok, FdRealUu} = ?FILE_MODULE:open(RealUu, []),
     %%
-    ?line {ok, SzUu}     = ?FILE_MODULE:copy(FdRealUu, Fd),
-    ?line {ok, Sz}       = ?RAM_FILE_MODULE:uudecode(Fd),
-    ?line true           = (Sz =< SzUu),
-    ?line {ok, 0}        = ?FILE_MODULE:position(Fd, bof),
-    ?line true           = compare(FdReal, Fd),
+    {ok, SzUu}     = ?FILE_MODULE:copy(FdRealUu, Fd),
+    {ok, Sz}       = ?RAM_FILE_MODULE:uudecode(Fd),
+    true           = (Sz =< SzUu),
+    {ok, 0}        = ?FILE_MODULE:position(Fd, bof),
+    true           = compare(FdReal, Fd),
     %%
     %% Uuencode and decode test
     %%
     F = fun(Offs) ->
 		Size = Sz - Offs,
-		?line {ok, Offs}     = ?FILE_MODULE:position(FdReal, {bof,Offs}),
-		?line {ok, 0}        = ?FILE_MODULE:position(Fd, bof),
-		?line ok             = ?FILE_MODULE:truncate(Fd),
-		?line {ok, Size}     = ?FILE_MODULE:copy(FdReal, Fd),
-		?line {ok, SizeUu}   = ?RAM_FILE_MODULE:uuencode(Fd),
-		?line true           = (Size =< SizeUu),
-		?line {ok, Size}     = ?RAM_FILE_MODULE:uudecode(Fd),
-		?line {ok, Offs}     = ?FILE_MODULE:position(FdReal, {bof,Offs}),
-		?line {ok, 0}        = ?FILE_MODULE:position(Fd, bof),
-		?line true           = compare(FdReal, Fd)
+		{ok, Offs}     = ?FILE_MODULE:position(FdReal, {bof,Offs}),
+		{ok, 0}        = ?FILE_MODULE:position(Fd, bof),
+		ok             = ?FILE_MODULE:truncate(Fd),
+		{ok, Size}     = ?FILE_MODULE:copy(FdReal, Fd),
+		{ok, SizeUu}   = ?RAM_FILE_MODULE:uuencode(Fd),
+		true           = (Size =< SizeUu),
+		{ok, Size}     = ?RAM_FILE_MODULE:uudecode(Fd),
+		{ok, Offs}     = ?FILE_MODULE:position(FdReal, {bof,Offs}),
+		{ok, 0}        = ?FILE_MODULE:position(Fd, bof),
+		true           = compare(FdReal, Fd)
 	end,
     lists:foreach(F, lists:seq(0,Sz-1, 43)),
 
-    ?line ok             = ?FILE_MODULE:close(FdReal),
-    ?line ok             = ?FILE_MODULE:close(Fd),
-    ?line ok             = ?FILE_MODULE:close(FdRealUu),
+    ok             = ?FILE_MODULE:close(FdReal),
+    ok             = ?FILE_MODULE:close(Fd),
+    ok             = ?FILE_MODULE:close(FdRealUu),
     %%
     ok.
 
 
 %% Test error checking of large file offsets.
 large_file_errors(Config) when is_list(Config) ->
-    ?line TwoGig = 1 bsl 31,
-    ?line {ok,Fd}         = ?RAM_FILE_MODULE:open("1234567890", [read,write]),
-    ?line {error, einval} = ?FILE_MODULE:read(Fd, TwoGig),
-    ?line {error, badarg} = ?FILE_MODULE:read(Fd, -1),
-    ?line {error, einval} = ?FILE_MODULE:position(Fd, {bof,TwoGig}),
-    ?line {error, einval} = ?FILE_MODULE:position(Fd, {bof,-TwoGig-1}),
-    ?line {error, einval} = ?FILE_MODULE:position(Fd, {bof,-1}),
-    ?line {error, einval} = ?FILE_MODULE:position(Fd, {cur,TwoGig}),
-    ?line {error, einval} = ?FILE_MODULE:position(Fd, {cur,-TwoGig-1}),
-    ?line {error, einval} = ?FILE_MODULE:position(Fd, {eof,TwoGig}),
-    ?line {error, einval} = ?FILE_MODULE:position(Fd, {eof,-TwoGig-1}),
-    ?line {error, einval} = ?FILE_MODULE:pread(Fd, TwoGig, 1),
-    ?line {error, einval} = ?FILE_MODULE:pread(Fd, -TwoGig-1, 1),
-    ?line {error, einval} = ?FILE_MODULE:pread(Fd, -1, 1),
-    ?line {error, einval} = ?FILE_MODULE:pwrite(Fd, TwoGig, "@"),
-    ?line {error, einval} = ?FILE_MODULE:pwrite(Fd, -TwoGig-1, "@"),
-    ?line {error, einval} = ?FILE_MODULE:pwrite(Fd, -1, "@"),
-    ?line {error, einval} = ?FILE_MODULE:pread(Fd, TwoGig, 0),
-    ?line {error, einval} = ?FILE_MODULE:pread(Fd, -TwoGig-1, 0),
-    ?line {error, einval} = ?FILE_MODULE:pread(Fd, -1, 0),
-    ?line ok              = ?FILE_MODULE:close(Fd),
+    TwoGig = 1 bsl 31,
+    {ok,Fd}         = ?RAM_FILE_MODULE:open("1234567890", [read,write]),
+    {error, einval} = ?FILE_MODULE:read(Fd, TwoGig),
+    {error, badarg} = ?FILE_MODULE:read(Fd, -1),
+    {error, einval} = ?FILE_MODULE:position(Fd, {bof,TwoGig}),
+    {error, einval} = ?FILE_MODULE:position(Fd, {bof,-TwoGig-1}),
+    {error, einval} = ?FILE_MODULE:position(Fd, {bof,-1}),
+    {error, einval} = ?FILE_MODULE:position(Fd, {cur,TwoGig}),
+    {error, einval} = ?FILE_MODULE:position(Fd, {cur,-TwoGig-1}),
+    {error, einval} = ?FILE_MODULE:position(Fd, {eof,TwoGig}),
+    {error, einval} = ?FILE_MODULE:position(Fd, {eof,-TwoGig-1}),
+    {error, einval} = ?FILE_MODULE:pread(Fd, TwoGig, 1),
+    {error, einval} = ?FILE_MODULE:pread(Fd, -TwoGig-1, 1),
+    {error, einval} = ?FILE_MODULE:pread(Fd, -1, 1),
+    {error, einval} = ?FILE_MODULE:pwrite(Fd, TwoGig, "@"),
+    {error, einval} = ?FILE_MODULE:pwrite(Fd, -TwoGig-1, "@"),
+    {error, einval} = ?FILE_MODULE:pwrite(Fd, -1, "@"),
+    {error, einval} = ?FILE_MODULE:pread(Fd, TwoGig, 0),
+    {error, einval} = ?FILE_MODULE:pread(Fd, -TwoGig-1, 0),
+    {error, einval} = ?FILE_MODULE:pread(Fd, -1, 0),
+    ok              = ?FILE_MODULE:close(Fd),
     ok.
 
 
@@ -510,25 +510,25 @@ large_file_errors(Config) when is_list(Config) ->
 large_file_light(Config) when is_list(Config) ->
     PrivDir = proplists:get_value(priv_dir, Config),
     %% Marker for next test case that is to heavy to run in a suite.
-    ?line ok = ?FILE_MODULE:write_file(
-		  filename:join(PrivDir, "large_file_light"),
-		  <<"TAG">>),
-    %%
-    ?line Data = "abcdefghijklmnopqrstuvwzyz",
-    ?line Size = sizeof(Data),
-    ?line Max = (1 bsl 31) - 1,
-    ?line Max__1 = Max - 1,
-    ?line {ok, Fd}        = ?RAM_FILE_MODULE:open(Data, [read]),
-    ?line {ok, Data}      = ?FILE_MODULE:read(Fd, Size+1),
-    ?line {ok, Max__1}    = ?FILE_MODULE:position(Fd, {eof, Max-Size-1}),
-    ?line eof             = ?FILE_MODULE:read(Fd, 1),
-    ?line {ok, Max}       = ?FILE_MODULE:position(Fd, {bof, Max}),
-    ?line {ok, Zero}      = ?FILE_MODULE:read(Fd, 0),
-    ?line 0               = sizeof(Zero),
-    ?line eof             = ?FILE_MODULE:read(Fd, 1),
-    ?line eof             = ?FILE_MODULE:pread(Fd, Max__1, 1),
-    ?line {ok, Zero}      = ?FILE_MODULE:pread(Fd, Max, 0),
-    ?line eof             = ?FILE_MODULE:pread(Fd, Max, 1),
+    ok = ?FILE_MODULE:write_file(
+	    filename:join(PrivDir, "large_file_light"),
+	    <<"TAG">>),
+    %%
+    Data = "abcdefghijklmnopqrstuvwzyz",
+    Size = sizeof(Data),
+    Max = (1 bsl 31) - 1,
+    Max__1 = Max - 1,
+    {ok, Fd}        = ?RAM_FILE_MODULE:open(Data, [read]),
+    {ok, Data}      = ?FILE_MODULE:read(Fd, Size+1),
+    {ok, Max__1}    = ?FILE_MODULE:position(Fd, {eof, Max-Size-1}),
+    eof             = ?FILE_MODULE:read(Fd, 1),
+    {ok, Max}       = ?FILE_MODULE:position(Fd, {bof, Max}),
+    {ok, Zero}      = ?FILE_MODULE:read(Fd, 0),
+    0               = sizeof(Zero),
+    eof             = ?FILE_MODULE:read(Fd, 1),
+    eof             = ?FILE_MODULE:pread(Fd, Max__1, 1),
+    {ok, Zero}      = ?FILE_MODULE:pread(Fd, Max, 0),
+    eof             = ?FILE_MODULE:pread(Fd, Max, 1),
     ok.
 
 
@@ -549,33 +549,33 @@ large_file_heavy(Config) when is_list(Config) ->
     end.
 
 do_large_file_heavy(_Config) ->
-    ?line Data = "qwertyuiopasdfghjklzxcvbnm",
-    ?line Size = sizeof(Data),
-    ?line Max = (1 bsl 31) - 1,
-    ?line Max__1 = Max - 1,
-    ?line Max__3 = Max - 3,
-    ?line {ok, Fd}        = ?RAM_FILE_MODULE:open(Data, [read,write]),
-    ?line {ok, Data}      = ?FILE_MODULE:read(Fd, Size+1),
-    ?line {ok, Max}       = ?FILE_MODULE:position(Fd, {eof, Max-Size}),
-    ?line eof             = ?FILE_MODULE:read(Fd, 1),
-    ?line erlang:display({allocating,2,'GByte',please,be,patient,'...'}),
-    ?line ok              = ?FILE_MODULE:write(Fd, ""),
-    ?line erlang:display({allocating,2,'GByte',succeeded}),
-    ?line {ok, Max__1}    = ?FILE_MODULE:position(Fd, {eof, -1}),
-    ?line {ok, [0]}       = ?FILE_MODULE:read(Fd, 1),
-    ?line {ok, []}        = ?FILE_MODULE:read(Fd, 0),
-    ?line eof             = ?FILE_MODULE:read(Fd, 1),
-    ?line ok              = ?FILE_MODULE:pwrite(Fd, Max-3, "TAG"),
-    ?line {ok, Max}       = ?FILE_MODULE:position(Fd, cur),
-    ?line {ok, Max__3}    = ?FILE_MODULE:position(Fd, {eof, -3}),
-    ?line {ok, "TAG"}     = ?FILE_MODULE:read(Fd, 3+1),
-    ?line {ok, Max__3}    = ?FILE_MODULE:position(Fd, {cur, -3}),
-    ?line ok              = ?FILE_MODULE:write(Fd, "tag"),
-    ?line {ok, Max}       = ?FILE_MODULE:position(Fd, cur),
-    ?line {ok, 0}         = ?FILE_MODULE:position(Fd, bof),
-    ?line {ok, "tag"}     = ?FILE_MODULE:pread(Fd, Max__3, 3+1),
-    ?line {ok, 0}         = ?FILE_MODULE:position(Fd, cur),
-    ?line ok              = ?FILE_MODULE:close(Fd),
+    Data = "qwertyuiopasdfghjklzxcvbnm",
+    Size = sizeof(Data),
+    Max = (1 bsl 31) - 1,
+    Max__1 = Max - 1,
+    Max__3 = Max - 3,
+    {ok, Fd}        = ?RAM_FILE_MODULE:open(Data, [read,write]),
+    {ok, Data}      = ?FILE_MODULE:read(Fd, Size+1),
+    {ok, Max}       = ?FILE_MODULE:position(Fd, {eof, Max-Size}),
+    eof             = ?FILE_MODULE:read(Fd, 1),
+    erlang:display({allocating,2,'GByte',please,be,patient,'...'}),
+    ok              = ?FILE_MODULE:write(Fd, ""),
+    erlang:display({allocating,2,'GByte',succeeded}),
+    {ok, Max__1}    = ?FILE_MODULE:position(Fd, {eof, -1}),
+    {ok, [0]}       = ?FILE_MODULE:read(Fd, 1),
+    {ok, []}        = ?FILE_MODULE:read(Fd, 0),
+    eof             = ?FILE_MODULE:read(Fd, 1),
+    ok              = ?FILE_MODULE:pwrite(Fd, Max-3, "TAG"),
+    {ok, Max}       = ?FILE_MODULE:position(Fd, cur),
+    {ok, Max__3}    = ?FILE_MODULE:position(Fd, {eof, -3}),
+    {ok, "TAG"}     = ?FILE_MODULE:read(Fd, 3+1),
+    {ok, Max__3}    = ?FILE_MODULE:position(Fd, {cur, -3}),
+    ok              = ?FILE_MODULE:write(Fd, "tag"),
+    {ok, Max}       = ?FILE_MODULE:position(Fd, cur),
+    {ok, 0}         = ?FILE_MODULE:position(Fd, bof),
+    {ok, "tag"}     = ?FILE_MODULE:pread(Fd, Max__3, 3+1),
+    {ok, 0}         = ?FILE_MODULE:position(Fd, cur),
+    ok              = ?FILE_MODULE:close(Fd),
     ok.
 
 %%--------------------------------------------------------------------------
@@ -609,7 +609,7 @@ compare_data(A, B) when is_binary(A), is_list(B) ->
     A == list_to_binary(B);
 compare_data(A, B) when is_binary(A), is_binary(B) ->
     A == B.
-	    
+
 sizeof(Data) when is_list(Data) ->
     length(Data);
 sizeof(Data) when is_binary(Data) ->