Remove ?line macros

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

1 files changed, 1651 insertions, 1651 deletions

diff --git a/lib/kernel/test/file_SUITE.erl b/lib/kernel/test/file_SUITE.erl
index f5f256a257..74db2970af 100644
--- a/lib/kernel/test/file_SUITE.erl
+++ b/lib/kernel/test/file_SUITE.erl
@@ -51,20 +51,20 @@
 	 pos1/1, pos2/1, pos3/1]).
 -export([close/1, consult1/1, path_consult/1, delete/1]).
 -export([ eval1/1, path_eval/1, script1/1, path_script/1,
-	 open1/1,
-	 old_modes/1, new_modes/1, path_open/1, open_errors/1]).
+	  open1/1,
+	  old_modes/1, new_modes/1, path_open/1, open_errors/1]).
 -export([ file_info_basic_file/1, file_info_basic_directory/1,
-	 file_info_bad/1, file_info_times/1, file_write_file_info/1]).
+	  file_info_bad/1, file_info_times/1, file_write_file_info/1]).
 -export([rename/1, access/1, truncate/1, datasync/1, sync/1,
 	 read_write/1, pread_write/1, append/1, exclusive/1]).
 -export([ e_delete/1, e_rename/1, e_make_dir/1, e_del_dir/1]).
 -export([otp_5814/1, otp_10852/1]).
 
 -export([ read_not_really_compressed/1,
-	 read_compressed_cooked/1, read_compressed_cooked_binary/1,
-	 read_cooked_tar_problem/1,
-	 write_compressed/1, compress_errors/1, catenated_gzips/1,
-	 compress_async_crash/1]).
+	  read_compressed_cooked/1, read_compressed_cooked_binary/1,
+	  read_cooked_tar_problem/1,
+	  write_compressed/1, compress_errors/1, catenated_gzips/1,
+	  compress_async_crash/1]).
 
 -export([ make_link/1, read_link_info_for_non_link/1, symlinks/1]).
 
@@ -266,57 +266,57 @@ mini_server(Parent) ->
 %% Test that standard i/o-servers work with file module.
 standard_io(Config) when is_list(Config) ->
     %% Really just a smoke test
-    ?line Pid = spawn(?MODULE,mini_server,[self()]),
-    ?line register(mini_server,Pid),
-    ?line ok = file:write(mini_server,<<"hej\n">>),
-    ?line receive
-	     {io_request,_,_,{put_chars,<<"hej\n">>}} ->
-		  ok
-	  after 1000 ->
-		  exit(noreply)
-	  end,
-    ?line {ok,"aaaaa"} = file:read(mini_server,5),
-    ?line receive
-	     {io_request,_,_,{get_chars,'',5}} ->
-		  ok
-	  after 1000 ->
-		  exit(noreply)
-	  end,
-    ?line {ok,"hej\n"} = file:read_line(mini_server),
-    ?line receive
-	     {io_request,_,_,{get_line,''}} ->
-		  ok
-	  after 1000 ->
-		  exit(noreply)
-	  end,
-    ?line OldGL = group_leader(),
-    ?line group_leader(Pid,self()),
-    ?line ok = file:write(standard_io,<<"hej\n">>),
-    ?line group_leader(OldGL,self()),
-    ?line receive
-	     {io_request,_,_,{put_chars,<<"hej\n">>}} ->
-		  ok
-	  after 1000 ->
-		  exit(noreply)
-	  end,
-    ?line group_leader(Pid,self()),
-    ?line {ok,"aaaaa"} = file:read(standard_io,5),
-    ?line group_leader(OldGL,self()),
-    ?line receive
-	     {io_request,_,_,{get_chars,'',5}} ->
-		  ok
-	  after 1000 ->
-		  exit(noreply)
-	  end,
-    ?line group_leader(Pid,self()),
-    ?line {ok,"hej\n"} = file:read_line(standard_io),
-    ?line group_leader(OldGL,self()),
-    ?line receive
-	     {io_request,_,_,{get_line,''}} ->
-		  ok
-	  after 1000 ->
-		  exit(noreply)
-	  end,
+    Pid = spawn(?MODULE,mini_server,[self()]),
+    register(mini_server,Pid),
+    ok = file:write(mini_server,<<"hej\n">>),
+    receive
+	{io_request,_,_,{put_chars,<<"hej\n">>}} ->
+	    ok
+    after 1000 ->
+	    exit(noreply)
+    end,
+    {ok,"aaaaa"} = file:read(mini_server,5),
+    receive
+	{io_request,_,_,{get_chars,'',5}} ->
+	    ok
+    after 1000 ->
+	    exit(noreply)
+    end,
+    {ok,"hej\n"} = file:read_line(mini_server),
+    receive
+	{io_request,_,_,{get_line,''}} ->
+	    ok
+    after 1000 ->
+	    exit(noreply)
+    end,
+    OldGL = group_leader(),
+    group_leader(Pid,self()),
+    ok = file:write(standard_io,<<"hej\n">>),
+    group_leader(OldGL,self()),
+    receive
+	{io_request,_,_,{put_chars,<<"hej\n">>}} ->
+	    ok
+    after 1000 ->
+	    exit(noreply)
+    end,
+    group_leader(Pid,self()),
+    {ok,"aaaaa"} = file:read(standard_io,5),
+    group_leader(OldGL,self()),
+    receive
+	{io_request,_,_,{get_chars,'',5}} ->
+	    ok
+    after 1000 ->
+	    exit(noreply)
+    end,
+    group_leader(Pid,self()),
+    {ok,"hej\n"} = file:read_line(standard_io),
+    group_leader(OldGL,self()),
+    receive
+	{io_request,_,_,{get_line,''}} ->
+	    ok
+    after 1000 ->
+	    exit(noreply)
+    end,
     Pid ! die,
     receive after 1000 -> ok end.
 
@@ -487,55 +487,55 @@ um_filename(Str = [_|_], Dir, Options) ->
 
 read_write_file(Config) when is_list(Config) ->
     RootDir = proplists:get_value(priv_dir,Config),
-    ?line Name = filename:join(RootDir, 
-			       atom_to_list(?MODULE)
-			       ++"_read_write_file"),
+    Name = filename:join(RootDir,
+			 atom_to_list(?MODULE)
+			 ++"_read_write_file"),
 
     %% Try writing and reading back some term
-    ?line SomeTerm = {"This term",{will,be},[written,$t,$o],1,file,[]},
-    ?line ok = ?FILE_MODULE:write_file(Name,term_to_binary(SomeTerm)),
-    ?line {ok,Bin1} = ?FILE_MODULE:read_file(Name),
-    ?line SomeTerm = binary_to_term(Bin1),
-  
+    SomeTerm = {"This term",{will,be},[written,$t,$o],1,file,[]},
+    ok = ?FILE_MODULE:write_file(Name,term_to_binary(SomeTerm)),
+    {ok,Bin1} = ?FILE_MODULE:read_file(Name),
+    SomeTerm = binary_to_term(Bin1),
+
     %% Try a "null" term
-    ?line NullTerm = [],
-    ?line ok = ?FILE_MODULE:write_file(Name,term_to_binary(NullTerm)),
-    ?line {ok,Bin2} = ?FILE_MODULE:read_file(Name),
-    ?line NullTerm = binary_to_term(Bin2),
+    NullTerm = [],
+    ok = ?FILE_MODULE:write_file(Name,term_to_binary(NullTerm)),
+    {ok,Bin2} = ?FILE_MODULE:read_file(Name),
+    NullTerm = binary_to_term(Bin2),
 
     %% Try some "complicated" types
-    ?line BigNum = 123456789012345678901234567890,
-    ?line ComplTerm = {self(),make_ref(),BigNum,3.14159},
-    ?line ok = ?FILE_MODULE:write_file(Name,term_to_binary(ComplTerm)),
-    ?line {ok,Bin3} = ?FILE_MODULE:read_file(Name),
-    ?line ComplTerm = binary_to_term(Bin3),
+    BigNum = 123456789012345678901234567890,
+    ComplTerm = {self(),make_ref(),BigNum,3.14159},
+    ok = ?FILE_MODULE:write_file(Name,term_to_binary(ComplTerm)),
+    {ok,Bin3} = ?FILE_MODULE:read_file(Name),
+    ComplTerm = binary_to_term(Bin3),
 
     %% Try reading a nonexistent file
-    ?line Name2 = filename:join(RootDir, 
-				atom_to_list(?MODULE)
-				++"_nonexistent_file"),
-    ?line {error, enoent} = ?FILE_MODULE:read_file(Name2),
-    ?line {error, enoent} = ?FILE_MODULE:read_file(""),
-    ?line {error, enoent} = ?FILE_MODULE:read_file(''),
+    Name2 = filename:join(RootDir,
+			  atom_to_list(?MODULE)
+			  ++"_nonexistent_file"),
+    {error, enoent} = ?FILE_MODULE:read_file(Name2),
+    {error, enoent} = ?FILE_MODULE:read_file(""),
+    {error, enoent} = ?FILE_MODULE:read_file(''),
 
     %% Try writing to a bad filename
-    ?line {error, enoent} = 
+    {error, enoent} =
 	?FILE_MODULE:write_file("",term_to_binary(NullTerm)),
 
     %% Try writing something else than a binary
-    ?line {error, badarg} = ?FILE_MODULE:write_file(Name,{1,2,3}),
-    ?line {error, badarg} = ?FILE_MODULE:write_file(Name,self()),
+    {error, badarg} = ?FILE_MODULE:write_file(Name,{1,2,3}),
+    {error, badarg} = ?FILE_MODULE:write_file(Name,self()),
 
     %% Some non-term binaries
-    ?line ok = ?FILE_MODULE:write_file(Name,[]),
-    ?line {ok,Bin4} = ?FILE_MODULE:read_file(Name),
-    ?line 0 = byte_size(Bin4),
+    ok = ?FILE_MODULE:write_file(Name,[]),
+    {ok,Bin4} = ?FILE_MODULE:read_file(Name),
+    0 = byte_size(Bin4),
 
-    ?line ok = ?FILE_MODULE:write_file(Name,[Bin1,[],[[Bin2]]]),
-    ?line {ok,Bin5} = ?FILE_MODULE:read_file(Name),
-    ?line {Bin1,Bin2} = split_binary(Bin5,byte_size(Bin1)),
+    ok = ?FILE_MODULE:write_file(Name,[Bin1,[],[[Bin2]]]),
+    {ok,Bin5} = ?FILE_MODULE:read_file(Name),
+    {Bin1,Bin2} = split_binary(Bin5,byte_size(Bin1)),
 
-    ?line [] = flush(),
+    [] = flush(),
     ok.
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
@@ -543,40 +543,40 @@ read_write_file(Config) when is_list(Config) ->
 
 make_del_dir(Config) when is_list(Config) ->
     RootDir = proplists:get_value(priv_dir,Config),
-    ?line NewDir = filename:join(RootDir, 
-				 atom_to_list(?MODULE)
-				 ++"_mk-dir"),
-    ?line ok = ?FILE_MODULE:make_dir(NewDir),
-    ?line {error, eexist} = ?FILE_MODULE:make_dir(NewDir),
-    ?line ok = ?FILE_MODULE:del_dir(NewDir),
-    ?line {error, enoent} = ?FILE_MODULE:del_dir(NewDir),
+    NewDir = filename:join(RootDir,
+			   atom_to_list(?MODULE)
+			   ++"_mk-dir"),
+    ok = ?FILE_MODULE:make_dir(NewDir),
+    {error, eexist} = ?FILE_MODULE:make_dir(NewDir),
+    ok = ?FILE_MODULE:del_dir(NewDir),
+    {error, enoent} = ?FILE_MODULE:del_dir(NewDir),
     %% Make sure we are not in a directory directly under test_server
     %% as that would result in eacces errors when trying to delete '..',
     %% because there are processes having that directory as current.
-    ?line ok = ?FILE_MODULE:make_dir(NewDir),
-    ?line {ok,CurrentDir} = file:get_cwd(),
+    ok = ?FILE_MODULE:make_dir(NewDir),
+    {ok,CurrentDir} = file:get_cwd(),
     case {os:type(), length(NewDir) >= 260 } of
 	{{win32,_}, true} ->
 	    io:format("Skip set_cwd for windows path longer than 260 (MAX_PATH)\n", []),
 	    io:format("\nNewDir = ~p\n", [NewDir]);
     	_ ->
-	    ?line ok = ?FILE_MODULE:set_cwd(NewDir)
+	    ok = ?FILE_MODULE:set_cwd(NewDir)
     end,
     try
 	%% Check that we get an error when trying to create...
 	%% a deep directory
-	?line NewDir2 = filename:join(RootDir, 
-				      atom_to_list(?MODULE)
-				      ++"_mk-dir-noexist/foo"),
-	?line {error, enoent} = ?FILE_MODULE:make_dir(NewDir2),
+	NewDir2 = filename:join(RootDir,
+				atom_to_list(?MODULE)
+				++"_mk-dir-noexist/foo"),
+	{error, enoent} = ?FILE_MODULE:make_dir(NewDir2),
 	%% a nameless directory
-	?line {error, enoent} = ?FILE_MODULE:make_dir(""),
+	{error, enoent} = ?FILE_MODULE:make_dir(""),
 	%% a directory with illegal name
-	?line {error, badarg} = ?FILE_MODULE:make_dir({1,2,3}),
-	
+	{error, badarg} = ?FILE_MODULE:make_dir({1,2,3}),
+
 	%% a directory with illegal name, even if it's a (bad) list
-	?line {error, badarg} = ?FILE_MODULE:make_dir([1,2,3,{}]),
-	
+	{error, badarg} = ?FILE_MODULE:make_dir([1,2,3,{}]),
+
 	%% Maybe this isn't an error, exactly, but worth mentioning anyway:
 	%% ok = ?FILE_MODULE:make_dir([$f,$o,$o,0,$b,$a,$r])),
 	%% The above line works, and created a directory "./foo"
@@ -584,36 +584,36 @@ make_del_dir(Config) when is_list(Config) ->
 	%% a directory, but with a name that incorporates the "bar" part of
 	%% the list, so that [$f,$o,$o,0,$f,$o,$o] wouldn't refer to the same
 	%% dir. But this would slow it down.
-	
+
 	%% Try deleting some bad directories
 	%% Deleting the parent directory to the current, sounds dangerous, huh?
 	%% Don't worry ;-) the parent directory should never be empty, right?
-	?line case ?FILE_MODULE:del_dir('..') of
-		  {error, eexist} -> ok;
-		  {error, eacces} -> ok;		%OpenBSD
-		  {error, einval} -> ok			%FreeBSD
-	      end,
-	?line {error, enoent} = ?FILE_MODULE:del_dir(""),
-	?line {error, badarg} = ?FILE_MODULE:del_dir([3,2,1,{}]),
-	
-	?line [] = flush()
+	case ?FILE_MODULE:del_dir('..') of
+	    {error, eexist} -> ok;
+	    {error, eacces} -> ok;		%OpenBSD
+	    {error, einval} -> ok			%FreeBSD
+	end,
+	{error, enoent} = ?FILE_MODULE:del_dir(""),
+	{error, badarg} = ?FILE_MODULE:del_dir([3,2,1,{}]),
+
+	[] = flush()
     after
-	 ?FILE_MODULE:set_cwd(CurrentDir)
+	?FILE_MODULE:set_cwd(CurrentDir)
     end,
     ok.
 
 cur_dir_0(Config) when is_list(Config) ->
     %% Find out the current dir, and cd to it ;-)
-    ?line {ok,BaseDir} = ?FILE_MODULE:get_cwd(),
-    ?line Dir1 = BaseDir ++ "", %% Check that it's a string
-    ?line ok = ?FILE_MODULE:set_cwd(Dir1),
+    {ok,BaseDir} = ?FILE_MODULE:get_cwd(),
+    Dir1 = BaseDir ++ "", %% Check that it's a string
+    ok = ?FILE_MODULE:set_cwd(Dir1),
 
     %% Make a new dir, and cd to that
     RootDir = proplists:get_value(priv_dir,Config),
-    ?line NewDir = filename:join(RootDir, 
-				 atom_to_list(?MODULE)
-				 ++"_curdir"),
-    ?line ok = ?FILE_MODULE:make_dir(NewDir),
+    NewDir = filename:join(RootDir,
+			   atom_to_list(?MODULE)
+			   ++"_curdir"),
+    ok = ?FILE_MODULE:make_dir(NewDir),
     case {os:type(), length(NewDir) >= 260} of
 	{{win32,_}, true} ->
 	    io:format("Skip set_cwd for windows path longer than 260 (MAX_PATH):\n"),
@@ -646,44 +646,44 @@ cur_dir_0(Config) when is_list(Config) ->
 	    {ok,OldDirFiles} = ?FILE_MODULE:list_dir("."),
 	    false = lists:member(UncommonName,OldDirFiles)
     end,
-	
+
     %% Try doing some bad things
-    ?line {error, badarg} = ?FILE_MODULE:set_cwd({foo,bar}),
-    ?line {error, enoent} = ?FILE_MODULE:set_cwd(""),
-    ?line {error, enoent} = ?FILE_MODULE:set_cwd(".......a......"),
-    ?line {ok,BaseDir} = ?FILE_MODULE:get_cwd(), %% Still there?
+    {error, badarg} = ?FILE_MODULE:set_cwd({foo,bar}),
+    {error, enoent} = ?FILE_MODULE:set_cwd(""),
+    {error, enoent} = ?FILE_MODULE:set_cwd(".......a......"),
+    {ok,BaseDir} = ?FILE_MODULE:get_cwd(), %% Still there?
 
     %% On Windows, there should only be slashes, no backslashes,
     %% in the return value of get_cwd().
     %% (The test is harmless on Unix, because filenames usually
     %% don't contain backslashes.)
 
-    ?line {ok, BaseDir} = ?FILE_MODULE:get_cwd(),
-    ?line false = lists:member($\\, BaseDir),
+    {ok, BaseDir} = ?FILE_MODULE:get_cwd(),
+    false = lists:member($\\, BaseDir),
 
-    ?line [] = flush(),
+    [] = flush(),
     ok.
 
 %% Tests ?FILE_MODULE:get_cwd/1.
 
 cur_dir_1(Config) when is_list(Config) ->
-    ?line case os:type() of
-	   {win32, _} ->
-		  win_cur_dir_1(Config);
-	    _ ->
-		  ?line {error, enotsup} = ?FILE_MODULE:get_cwd("d:")
-      end,
-    ?line [] = flush(),
+    case os:type() of
+	{win32, _} ->
+	    win_cur_dir_1(Config);
+	_ ->
+	    {error, enotsup} = ?FILE_MODULE:get_cwd("d:")
+    end,
+    [] = flush(),
     ok.
-	
+
 win_cur_dir_1(_Config) ->
-    ?line {ok,BaseDir} = ?FILE_MODULE:get_cwd(),
+    {ok,BaseDir} = ?FILE_MODULE:get_cwd(),
 
     %% Get the drive letter from the current directory,
     %% and try to get current directory for that drive.
 
-    ?line [Drive,$:|_] = BaseDir,
-    ?line {ok,BaseDir} = ?FILE_MODULE:get_cwd([Drive,$:]),
+    [Drive,$:|_] = BaseDir,
+    {ok,BaseDir} = ?FILE_MODULE:get_cwd([Drive,$:]),
     io:format("BaseDir = ~s\n", [BaseDir]),
 
     %% Unfortunately, there is no way to move away from the
@@ -840,247 +840,247 @@ start_node(Name, Args) ->
 
 open1(Config) when is_list(Config) ->
     RootDir = proplists:get_value(priv_dir,Config),
-    ?line NewDir = filename:join(RootDir, 
-				 atom_to_list(?MODULE)
-				 ++"_files"),
-    ?line ok = ?FILE_MODULE:make_dir(NewDir),
-    ?line Name = filename:join(NewDir, "foo1.fil"),
-    ?line {ok,Fd1} = ?FILE_MODULE:open(Name,read_write),
-    ?line {ok,Fd2} = ?FILE_MODULE:open(Name,read),
-    ?line Str = "{a,tuple}.\n",
-    ?line io:format(Fd1,Str,[]),
-    ?line {ok,0} = ?FILE_MODULE:position(Fd1,bof),
-    ?line Str = io:get_line(Fd1,''),
-    ?line Str = io:get_line(Fd2,''),
-    ?line ok = ?FILE_MODULE:close(Fd2),
-    ?line {ok,0} = ?FILE_MODULE:position(Fd1,bof),
-    ?line ok = ?FILE_MODULE:truncate(Fd1),
-    ?line eof = io:get_line(Fd1,''),
-    ?line ok = ?FILE_MODULE:close(Fd1),
-    ?line {ok,Fd3} = ?FILE_MODULE:open(Name,read),
-    ?line eof = io:get_line(Fd3,''),
-    ?line ok = ?FILE_MODULE:close(Fd3),
-    ?line [] = flush(),
+    NewDir = filename:join(RootDir,
+			   atom_to_list(?MODULE)
+			   ++"_files"),
+    ok = ?FILE_MODULE:make_dir(NewDir),
+    Name = filename:join(NewDir, "foo1.fil"),
+    {ok,Fd1} = ?FILE_MODULE:open(Name,read_write),
+    {ok,Fd2} = ?FILE_MODULE:open(Name,read),
+    Str = "{a,tuple}.\n",
+    io:format(Fd1,Str,[]),
+    {ok,0} = ?FILE_MODULE:position(Fd1,bof),
+    Str = io:get_line(Fd1,''),
+    Str = io:get_line(Fd2,''),
+    ok = ?FILE_MODULE:close(Fd2),
+    {ok,0} = ?FILE_MODULE:position(Fd1,bof),
+    ok = ?FILE_MODULE:truncate(Fd1),
+    eof = io:get_line(Fd1,''),
+    ok = ?FILE_MODULE:close(Fd1),
+    {ok,Fd3} = ?FILE_MODULE:open(Name,read),
+    eof = io:get_line(Fd3,''),
+    ok = ?FILE_MODULE:close(Fd3),
+    [] = flush(),
     ok.
 
 %% Tests all open modes.
 
 old_modes(Config) when is_list(Config) ->
     RootDir = proplists:get_value(priv_dir, Config),
-    ?line NewDir = filename:join(RootDir, 
-				 atom_to_list(?MODULE)
-				 ++"_old_open_modes"),
-    ?line ok = ?FILE_MODULE:make_dir(NewDir),
-    ?line Name1 = filename:join(NewDir, "foo1.fil"),
-    ?line Marker = "hello, world",
+    NewDir = filename:join(RootDir,
+			   atom_to_list(?MODULE)
+			   ++"_old_open_modes"),
+    ok = ?FILE_MODULE:make_dir(NewDir),
+    Name1 = filename:join(NewDir, "foo1.fil"),
+    Marker = "hello, world",
 
     %% write
-    ?line {ok, Fd1} = ?FILE_MODULE:open(Name1, write),
-    ?line ok = io:write(Fd1, Marker),
-    ?line ok = io:put_chars(Fd1, ".\n"),
-    ?line ok = ?FILE_MODULE:close(Fd1),
+    {ok, Fd1} = ?FILE_MODULE:open(Name1, write),
+    ok = io:write(Fd1, Marker),
+    ok = io:put_chars(Fd1, ".\n"),
+    ok = ?FILE_MODULE:close(Fd1),
 
     %% read
-    ?line {ok, Fd2} = ?FILE_MODULE:open(Name1, read),
-    ?line {ok, Marker} = io:read(Fd2, prompt),
-    ?line ok = ?FILE_MODULE:close(Fd2),
+    {ok, Fd2} = ?FILE_MODULE:open(Name1, read),
+    {ok, Marker} = io:read(Fd2, prompt),
+    ok = ?FILE_MODULE:close(Fd2),
 
     %% read_write
-    ?line {ok, Fd3} = ?FILE_MODULE:open(Name1, read_write),
-    ?line {ok, Marker} = io:read(Fd3, prompt),
-    ?line ok = io:write(Fd3, Marker),
-    ?line ok = ?FILE_MODULE:close(Fd3),
+    {ok, Fd3} = ?FILE_MODULE:open(Name1, read_write),
+    {ok, Marker} = io:read(Fd3, prompt),
+    ok = io:write(Fd3, Marker),
+    ok = ?FILE_MODULE:close(Fd3),
 
-    ?line [] = flush(),
+    [] = flush(),
     ok.
 
 
 new_modes(Config) when is_list(Config) ->
     RootDir = proplists:get_value(priv_dir, Config),
-    ?line NewDir = filename:join(RootDir, 
-				 atom_to_list(?MODULE)
-				 ++"_new_open_modes"),
-    ?line ok = ?FILE_MODULE:make_dir(NewDir),
-    ?line Name1 = filename:join(NewDir, "foo1.fil"),
-    ?line Marker = "hello, world",
+    NewDir = filename:join(RootDir,
+			   atom_to_list(?MODULE)
+			   ++"_new_open_modes"),
+    ok = ?FILE_MODULE:make_dir(NewDir),
+    Name1 = filename:join(NewDir, "foo1.fil"),
+    Marker = "hello, world",
 
     %% write
-    ?line {ok, Fd1} = ?FILE_MODULE:open(Name1, [write]),
-    ?line ok = io:write(Fd1, Marker),
-    ?line ok = io:put_chars(Fd1, ".\n"),
-    ?line ok = ?FILE_MODULE:close(Fd1),
+    {ok, Fd1} = ?FILE_MODULE:open(Name1, [write]),
+    ok = io:write(Fd1, Marker),
+    ok = io:put_chars(Fd1, ".\n"),
+    ok = ?FILE_MODULE:close(Fd1),
 
     %% read
-    ?line {ok, Fd2} = ?FILE_MODULE:open(Name1, [read]),
-    ?line {ok, Marker} = io:read(Fd2, prompt),
-    ?line ok = ?FILE_MODULE:close(Fd2),
+    {ok, Fd2} = ?FILE_MODULE:open(Name1, [read]),
+    {ok, Marker} = io:read(Fd2, prompt),
+    ok = ?FILE_MODULE:close(Fd2),
 
     %% read and write
-    ?line {ok, Fd3} = ?FILE_MODULE:open(Name1, [read, write]),
-    ?line {ok, Marker} = io:read(Fd3, prompt),
-    ?line ok = io:write(Fd3, Marker),
-    ?line ok = ?FILE_MODULE:close(Fd3),
+    {ok, Fd3} = ?FILE_MODULE:open(Name1, [read, write]),
+    {ok, Marker} = io:read(Fd3, prompt),
+    ok = io:write(Fd3, Marker),
+    ok = ?FILE_MODULE:close(Fd3),
 
     %% read by default
-    ?line {ok, Fd4} = ?FILE_MODULE:open(Name1, []),
-    ?line {ok, Marker} = io:read(Fd4, prompt),
-    ?line ok = ?FILE_MODULE:close(Fd4),
+    {ok, Fd4} = ?FILE_MODULE:open(Name1, []),
+    {ok, Marker} = io:read(Fd4, prompt),
+    ok = ?FILE_MODULE:close(Fd4),
 
     %% read and binary
-    ?line {ok, Fd5} = ?FILE_MODULE:open(Name1, [read, binary]),
-    ?line {ok, Marker} = io:read(Fd5, prompt),
-    ?line ok = ?FILE_MODULE:close(Fd5),
+    {ok, Fd5} = ?FILE_MODULE:open(Name1, [read, binary]),
+    {ok, Marker} = io:read(Fd5, prompt),
+    ok = ?FILE_MODULE:close(Fd5),
 
     %% read, raw
-    ?line {ok, Fd6} = ?FILE_MODULE:open(Name1, [read, raw]),
-    ?line {ok, [$\[]} = ?FILE_MODULE:read(Fd6, 1),
-    ?line ok = ?FILE_MODULE:close(Fd6),
-
-    %% write and sync
-    case ?FILE_MODULE:open(Name1, [write, sync]) of
-	{ok, Fd7} ->
-	    ok = io:write(Fd7, Marker),
-	    ok = io:put_chars(Fd7, ".\n"),
-	    ok = ?FILE_MODULE:close(Fd7),
-	    {ok, Fd8} = ?FILE_MODULE:open(Name1, [read]),
-	    {ok, Marker} = io:read(Fd8, prompt),
-	    ok = ?FILE_MODULE:close(Fd8);
-	{error, enotsup} ->
-	    %% for platforms that don't support the sync option
-	    ok
-    end,
-
-    ?line [] = flush(),
-    ok.
+    {ok, Fd6} = ?FILE_MODULE:open(Name1, [read, raw]),
+    {ok, [$\[]} = ?FILE_MODULE:read(Fd6, 1),
+     ok = ?FILE_MODULE:close(Fd6),
+
+     %% write and sync
+     case ?FILE_MODULE:open(Name1, [write, sync]) of
+	 {ok, Fd7} ->
+	     ok = io:write(Fd7, Marker),
+	     ok = io:put_chars(Fd7, ".\n"),
+	     ok = ?FILE_MODULE:close(Fd7),
+	     {ok, Fd8} = ?FILE_MODULE:open(Name1, [read]),
+	     {ok, Marker} = io:read(Fd8, prompt),
+	     ok = ?FILE_MODULE:close(Fd8);
+	 {error, enotsup} ->
+	     %% for platforms that don't support the sync option
+	     ok
+     end,
+
+     [] = flush(),
+     ok.
 
 path_open(Config) when is_list(Config) ->
     RootDir = proplists:get_value(priv_dir,Config),
-    ?line NewDir = filename:join(RootDir, 
-				 atom_to_list(?MODULE)
-				 ++"_path_open"),
-    ?line ok = ?FILE_MODULE:make_dir(NewDir),
-    ?line FileName = "path_open.fil",
-    ?line Name = filename:join(RootDir, FileName),
-    ?line {ok,Fd1,_FullName1} =
+    NewDir = filename:join(RootDir,
+			   atom_to_list(?MODULE)
+			   ++"_path_open"),
+    ok = ?FILE_MODULE:make_dir(NewDir),
+    FileName = "path_open.fil",
+    Name = filename:join(RootDir, FileName),
+    {ok,Fd1,_FullName1} =
 	?FILE_MODULE:path_open(
-	  [RootDir,
-	   "nosuch1",
-	   NewDir],FileName,write),
-    ?line io:format(Fd1,"ABCDEFGH",[]),
-    ?line ok = ?FILE_MODULE:close(Fd1),
+	   [RootDir,
+	    "nosuch1",
+	    NewDir],FileName,write),
+    io:format(Fd1,"ABCDEFGH",[]),
+    ok = ?FILE_MODULE:close(Fd1),
 
     %% locate it in the last dir
-    ?line {ok,Fd2,_FullName2} =
+    {ok,Fd2,_FullName2} =
 	?FILE_MODULE:path_open(
-	  ["nosuch1",
-	   NewDir,
-	   RootDir],FileName,read),
-    ?line {ok,2} = 
+	   ["nosuch1",
+	    NewDir,
+	    RootDir],FileName,read),
+    {ok,2} =
 	?FILE_MODULE:position(Fd2,2), "C" = io:get_chars(Fd2,'',1),
-    ?line ok = ?FILE_MODULE:close(Fd2),
+    ok = ?FILE_MODULE:close(Fd2),
     %% Try a failing path
-    ?line {error, enoent} = ?FILE_MODULE:path_open(
-			      ["nosuch1",
-			       NewDir],FileName,read),
+    {error, enoent} = ?FILE_MODULE:path_open(
+			 ["nosuch1",
+			  NewDir],FileName,read),
     %% Check that it's found regardless of path, if an absolute name given
-    ?line {ok,Fd3,_FullPath3} =
+    {ok,Fd3,_FullPath3} =
 	?FILE_MODULE:path_open(
-	  ["nosuch1",
-	   NewDir],Name,read),
-    ?line {ok,2} = 
+	   ["nosuch1",
+	    NewDir],Name,read),
+    {ok,2} =
 	?FILE_MODULE:position(Fd3,2), "C" = io:get_chars(Fd3,'',1),
-    ?line ok = ?FILE_MODULE:close(Fd3),
+    ok = ?FILE_MODULE:close(Fd3),
 
-    ?line [] = flush(),
+    [] = flush(),
     ok.
 
 close(Config) when is_list(Config) ->
     RootDir = proplists:get_value(priv_dir,Config),
-    ?line Name = filename:join(RootDir, 
-			       atom_to_list(?MODULE)
-			       ++"_close.fil"),
-    ?line {ok,Fd1} = ?FILE_MODULE:open(Name,read_write),
+    Name = filename:join(RootDir,
+			 atom_to_list(?MODULE)
+			 ++"_close.fil"),
+    {ok,Fd1} = ?FILE_MODULE:open(Name,read_write),
     %% Just closing it is no fun, we did that a million times already
     %% This is a common error, for code written before Erlang 4.3
     %% bacause then ?FILE_MODULE:open just returned a Pid, and not everyone
     %% really checked what they got.
-    ?line {'EXIT',_Msg} = (catch ok = ?FILE_MODULE:close({ok,Fd1})),
-    ?line ok = ?FILE_MODULE:close(Fd1),
+    {'EXIT',_Msg} = (catch ok = ?FILE_MODULE:close({ok,Fd1})),
+    ok = ?FILE_MODULE:close(Fd1),
 
     %% Try closing one more time
-    ?line Val = ?FILE_MODULE:close(Fd1),
-    ?line io:format("Second close gave: ~p",[Val]),
+    Val = ?FILE_MODULE:close(Fd1),
+    io:format("Second close gave: ~p",[Val]),
 
-    ?line [] = flush(),
+    [] = flush(),
     ok.
 
 access(Config) when is_list(Config) ->
     RootDir = proplists:get_value(priv_dir,Config),
-    ?line Name = filename:join(RootDir, 
-			       atom_to_list(?MODULE)
-			       ++"_access.fil"),
-    ?line Str = "ABCDEFGH",
-    ?line {ok,Fd1} = ?FILE_MODULE:open(Name,write),
-    ?line io:format(Fd1,Str,[]),
-    ?line ok = ?FILE_MODULE:close(Fd1),
+    Name = filename:join(RootDir,
+			 atom_to_list(?MODULE)
+			 ++"_access.fil"),
+    Str = "ABCDEFGH",
+    {ok,Fd1} = ?FILE_MODULE:open(Name,write),
+    io:format(Fd1,Str,[]),
+    ok = ?FILE_MODULE:close(Fd1),
     %% Check that we can't write when in read only mode
-    ?line {ok,Fd2} = ?FILE_MODULE:open(Name,read),
-    ?line case catch io:format(Fd2,"XXXX",[]) of
-	      ok ->
-		  ct:fail({format,write});
-	      _ ->
-		  ok
-	  end,
-    ?line ok = ?FILE_MODULE:close(Fd2),
-    ?line {ok,Fd3} = ?FILE_MODULE:open(Name,read),
-    ?line Str = io:get_line(Fd3,''),
-    ?line ok = ?FILE_MODULE:close(Fd3),
+    {ok,Fd2} = ?FILE_MODULE:open(Name,read),
+    case catch io:format(Fd2,"XXXX",[]) of
+	ok ->
+	    ct:fail({format,write});
+	_ ->
+	    ok
+    end,
+    ok = ?FILE_MODULE:close(Fd2),
+    {ok,Fd3} = ?FILE_MODULE:open(Name,read),
+    Str = io:get_line(Fd3,''),
+    ok = ?FILE_MODULE:close(Fd3),
 
-    ?line [] = flush(),
+    [] = flush(),
     ok.
 
 %% Tests ?FILE_MODULE:read/2 and ?FILE_MODULE:write/2.
 
 read_write(Config) when is_list(Config) ->
     RootDir = proplists:get_value(priv_dir, Config),
-    ?line NewDir = filename:join(RootDir, 
-				 atom_to_list(?MODULE)
-				 ++"_read_write"),
-    ?line ok = ?FILE_MODULE:make_dir(NewDir),
-    ?line Marker = "hello, world",
-    ?line MarkerB = list_to_binary(Marker),
+    NewDir = filename:join(RootDir,
+			   atom_to_list(?MODULE)
+			   ++"_read_write"),
+    ok = ?FILE_MODULE:make_dir(NewDir),
+    Marker = "hello, world",
+    MarkerB = list_to_binary(Marker),
 
     %% Plain file.
-    ?line Name1 = filename:join(NewDir, "plain.fil"),
-    ?line {ok, Fd1} = ?FILE_MODULE:open(Name1, [read, write]),
-    ?line read_write_test(Fd1, Marker, []),
+    Name1 = filename:join(NewDir, "plain.fil"),
+    {ok, Fd1} = ?FILE_MODULE:open(Name1, [read, write]),
+    read_write_test(Fd1, Marker, []),
 
     %% Raw file.
-    ?line Name2 = filename:join(NewDir, "raw.fil"),
-    ?line {ok, Fd2} = ?FILE_MODULE:open(Name2, [read, write, raw]),
-    ?line read_write_test(Fd2, Marker, []),
+    Name2 = filename:join(NewDir, "raw.fil"),
+    {ok, Fd2} = ?FILE_MODULE:open(Name2, [read, write, raw]),
+    read_write_test(Fd2, Marker, []),
 
     %% Plain binary file.
-    ?line Name3 = filename:join(NewDir, "plain-b.fil"),
-    ?line {ok, Fd3} = ?FILE_MODULE:open(Name3, [read, write, binary]),
-    ?line read_write_test(Fd3, MarkerB, <<>>),
+    Name3 = filename:join(NewDir, "plain-b.fil"),
+    {ok, Fd3} = ?FILE_MODULE:open(Name3, [read, write, binary]),
+    read_write_test(Fd3, MarkerB, <<>>),
 
     %% Raw binary file.
-    ?line Name4 = filename:join(NewDir, "raw-b.fil"),
-    ?line {ok, Fd4} = ?FILE_MODULE:open(Name4, [read, write, raw, binary]),
-    ?line read_write_test(Fd4, MarkerB, <<>>),
+    Name4 = filename:join(NewDir, "raw-b.fil"),
+    {ok, Fd4} = ?FILE_MODULE:open(Name4, [read, write, raw, binary]),
+    read_write_test(Fd4, MarkerB, <<>>),
 
     ok.
 
 read_write_test(File, Marker, Empty) ->
-    ?line ok = ?FILE_MODULE:write(File, Marker),
-    ?line {ok, 0} = ?FILE_MODULE:position(File, 0),
-    ?line {ok, Empty} = ?FILE_MODULE:read(File, 0),
-    ?line {ok, Marker} = ?FILE_MODULE:read(File, 100),
-    ?line eof = ?FILE_MODULE:read(File, 100),
-    ?line {ok, Empty} = ?FILE_MODULE:read(File, 0),
-    ?line ok = ?FILE_MODULE:close(File),
-    ?line [] = flush(),
+    ok = ?FILE_MODULE:write(File, Marker),
+    {ok, 0} = ?FILE_MODULE:position(File, 0),
+    {ok, Empty} = ?FILE_MODULE:read(File, 0),
+    {ok, Marker} = ?FILE_MODULE:read(File, 100),
+    eof = ?FILE_MODULE:read(File, 100),
+    {ok, Empty} = ?FILE_MODULE:read(File, 0),
+    ok = ?FILE_MODULE:close(File),
+    [] = flush(),
     ok.
 
 
@@ -1088,114 +1088,114 @@ read_write_test(File, Marker, Empty) ->
 
 pread_write(Config) when is_list(Config) ->
     RootDir = proplists:get_value(priv_dir, Config),
-    ?line NewDir = filename:join(RootDir, 
-				 atom_to_list(?MODULE)
-				 ++"_pread_write"),
-    ?line ok = ?FILE_MODULE:make_dir(NewDir),
-    ?line List = "hello, world",
-    ?line Bin = list_to_binary(List),
+    NewDir = filename:join(RootDir,
+			   atom_to_list(?MODULE)
+			   ++"_pread_write"),
+    ok = ?FILE_MODULE:make_dir(NewDir),
+    List = "hello, world",
+    Bin = list_to_binary(List),
 
     %% Plain file.
-    ?line Name1 = filename:join(NewDir, "plain.fil"),
-    ?line {ok, Fd1} = ?FILE_MODULE:open(Name1, [read, write]),
-    ?line pread_write_test(Fd1, List),
+    Name1 = filename:join(NewDir, "plain.fil"),
+    {ok, Fd1} = ?FILE_MODULE:open(Name1, [read, write]),
+    pread_write_test(Fd1, List),
 
     %% Raw file.
-    ?line Name2 = filename:join(NewDir, "raw.fil"),
-    ?line {ok, Fd2} = ?FILE_MODULE:open(Name2, [read, write, raw]),
-    ?line pread_write_test(Fd2, List),
+    Name2 = filename:join(NewDir, "raw.fil"),
+    {ok, Fd2} = ?FILE_MODULE:open(Name2, [read, write, raw]),
+    pread_write_test(Fd2, List),
 
     %% Plain file. Binary mode.
-    ?line Name3 = filename:join(NewDir, "plain-binary.fil"),
-    ?line {ok, Fd3} = ?FILE_MODULE:open(Name3, [binary, read, write]),
-    ?line pread_write_test(Fd3, Bin),
+    Name3 = filename:join(NewDir, "plain-binary.fil"),
+    {ok, Fd3} = ?FILE_MODULE:open(Name3, [binary, read, write]),
+    pread_write_test(Fd3, Bin),
 
     %% Raw file. Binary mode.
-    ?line Name4 = filename:join(NewDir, "raw-binary.fil"),
-    ?line {ok, Fd4} = ?FILE_MODULE:open(Name4, [binary, read, write, raw]),
-    ?line pread_write_test(Fd4, Bin),
+    Name4 = filename:join(NewDir, "raw-binary.fil"),
+    {ok, Fd4} = ?FILE_MODULE:open(Name4, [binary, read, write, raw]),
+    pread_write_test(Fd4, Bin),
 
     ok.
 
 pread_write_test(File, Data) ->
-    ?line io:format("~p:pread_write_test(~p,~p)~n", [?MODULE, File, Data]),
-    ?line Size = if is_binary(Data) -> byte_size(Data);
-		    is_list(Data) -> length(Data)
-		 end,
-    ?line I = Size + 17,
-    ?line ok = ?FILE_MODULE:pwrite(File, 0, Data),
+    io:format("~p:pread_write_test(~p,~p)~n", [?MODULE, File, Data]),
+    Size = if is_binary(Data) -> byte_size(Data);
+	      is_list(Data) -> length(Data)
+	   end,
+    I = Size + 17,
+    ok = ?FILE_MODULE:pwrite(File, 0, Data),
     Res = ?FILE_MODULE:pread(File, 0, I),
-    ?line {ok, Data} = Res,
-    ?line eof = ?FILE_MODULE:pread(File, I, 1),
-    ?line ok = ?FILE_MODULE:pwrite(File, [{0, Data}, {I, Data}]),
-    ?line {ok, [Data, eof, Data]} = 
+    {ok, Data} = Res,
+    eof = ?FILE_MODULE:pread(File, I, 1),
+    ok = ?FILE_MODULE:pwrite(File, [{0, Data}, {I, Data}]),
+    {ok, [Data, eof, Data]} =
 	?FILE_MODULE:pread(File, [{0, Size}, {2*I, 1}, {I, Size}]),
-    ?line Plist = lists:seq(21*I, 0, -I),
-    ?line Pwrite = lists:map(fun(P)->{P,Data}end, Plist),
-    ?line Pread = [{22*I,Size} | lists:map(fun(P)->{P,Size}end, Plist)],
-    ?line Presult = [eof | lists:map(fun(_)->Data end, Plist)],
-    ?line ok = ?FILE_MODULE:pwrite(File, Pwrite),
-    ?line {ok, Presult} = ?FILE_MODULE:pread(File, Pread),
-    ?line ok = ?FILE_MODULE:close(File),
-    ?line [] = flush(),
+    Plist = lists:seq(21*I, 0, -I),
+    Pwrite = lists:map(fun(P)->{P,Data}end, Plist),
+    Pread = [{22*I,Size} | lists:map(fun(P)->{P,Size}end, Plist)],
+    Presult = [eof | lists:map(fun(_)->Data end, Plist)],
+    ok = ?FILE_MODULE:pwrite(File, Pwrite),
+    {ok, Presult} = ?FILE_MODULE:pread(File, Pread),
+    ok = ?FILE_MODULE:close(File),
+    [] = flush(),
     ok.
 
 %% Test appending to a file.
 append(Config) when is_list(Config) ->
     RootDir = proplists:get_value(priv_dir, Config),
-    ?line NewDir = filename:join(RootDir, 
-				 atom_to_list(?MODULE)
-				 ++"_append"),
-    ?line ok = ?FILE_MODULE:make_dir(NewDir),
+    NewDir = filename:join(RootDir,
+			   atom_to_list(?MODULE)
+			   ++"_append"),
+    ok = ?FILE_MODULE:make_dir(NewDir),
 
-    ?line First = "First line\n",
-    ?line Second = "Seond lines comes here\n",
-    ?line Third = "And here is the third line\n",
+    First = "First line\n",
+    Second = "Seond lines comes here\n",
+    Third = "And here is the third line\n",
 
     %% Write a small text file.
-    ?line Name1 = filename:join(NewDir, "a_file.txt"),
-    ?line {ok, Fd1} = ?FILE_MODULE:open(Name1, [write]),
-    ?line ok = io:format(Fd1, First, []),
-    ?line ok = io:format(Fd1, Second, []),
-    ?line ok = ?FILE_MODULE:close(Fd1),
+    Name1 = filename:join(NewDir, "a_file.txt"),
+    {ok, Fd1} = ?FILE_MODULE:open(Name1, [write]),
+    ok = io:format(Fd1, First, []),
+    ok = io:format(Fd1, Second, []),
+    ok = ?FILE_MODULE:close(Fd1),
 
     %% Open it a again and a append a line to it.
-    ?line {ok, Fd2} = ?FILE_MODULE:open(Name1, [append]),
-    ?line ok = io:format(Fd2, Third, []),
-    ?line ok = ?FILE_MODULE:close(Fd2),
+    {ok, Fd2} = ?FILE_MODULE:open(Name1, [append]),
+    ok = io:format(Fd2, Third, []),
+    ok = ?FILE_MODULE:close(Fd2),
 
     %% Read it back and verify.
-    ?line Expected = list_to_binary([First, Second, Third]),
-    ?line {ok, Expected} = ?FILE_MODULE:read_file(Name1),
+    Expected = list_to_binary([First, Second, Third]),
+    {ok, Expected} = ?FILE_MODULE:read_file(Name1),
 
-    ?line [] = flush(),
+    [] = flush(),
     ok.
 
 open_errors(Config) when is_list(Config) ->
-    ?line DataDir = 
+    DataDir =
 	filename:dirname(
 	  filename:join(proplists:get_value(data_dir, Config), "x")),
-    ?line DataDirSlash = DataDir++"/",
-    ?line {error, E1} = ?FILE_MODULE:open(DataDir, [read]),
-    ?line {error, E2} = ?FILE_MODULE:open(DataDirSlash, [read]),
-    ?line {error, E3} = ?FILE_MODULE:open(DataDir, [write]),
-    ?line {error, E4} = ?FILE_MODULE:open(DataDirSlash, [write]),
-    ?line {eisdir,eisdir,eisdir,eisdir} = {E1,E2,E3,E4},
-
-    ?line [] = flush(),
+    DataDirSlash = DataDir++"/",
+    {error, E1} = ?FILE_MODULE:open(DataDir, [read]),
+    {error, E2} = ?FILE_MODULE:open(DataDirSlash, [read]),
+    {error, E3} = ?FILE_MODULE:open(DataDir, [write]),
+    {error, E4} = ?FILE_MODULE:open(DataDirSlash, [write]),
+    {eisdir,eisdir,eisdir,eisdir} = {E1,E2,E3,E4},
+
+    [] = flush(),
     ok.
 
 %% Test exclusive access to a file.
 exclusive(Config) when is_list(Config) ->
     RootDir = proplists:get_value(priv_dir,Config),
-    ?line NewDir = filename:join(RootDir,
-				 atom_to_list(?MODULE)
-				 ++"_exclusive"),
-    ?line ok = ?FILE_MODULE:make_dir(NewDir),
-    ?line Name = filename:join(NewDir, "ex_file.txt"),
-    ?line {ok, Fd} = ?FILE_MODULE:open(Name, [write, exclusive]),
-    ?line {error, eexist} = ?FILE_MODULE:open(Name, [write, exclusive]),
-    ?line ok = ?FILE_MODULE:close(Fd),
+    NewDir = filename:join(RootDir,
+			   atom_to_list(?MODULE)
+			   ++"_exclusive"),
+    ok = ?FILE_MODULE:make_dir(NewDir),
+    Name = filename:join(NewDir, "ex_file.txt"),
+    {ok, Fd} = ?FILE_MODULE:open(Name, [write, exclusive]),
+    {error, eexist} = ?FILE_MODULE:open(Name, [write, exclusive]),
+    ok = ?FILE_MODULE:close(Fd),
     ok.
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
@@ -1203,97 +1203,97 @@ exclusive(Config) when is_list(Config) ->
 
 pos1(Config) when is_list(Config) ->
     RootDir = proplists:get_value(priv_dir,Config),
-    ?line Name = filename:join(RootDir, 
-			       atom_to_list(?MODULE)
-			       ++"_pos1.fil"),
-    ?line {ok,Fd1} = ?FILE_MODULE:open(Name,write),
-    ?line io:format(Fd1,"ABCDEFGH",[]),
-    ?line ok = ?FILE_MODULE:close(Fd1),
-    ?line {ok,Fd2} = ?FILE_MODULE:open(Name,read),
+    Name = filename:join(RootDir,
+			 atom_to_list(?MODULE)
+			 ++"_pos1.fil"),
+    {ok,Fd1} = ?FILE_MODULE:open(Name,write),
+    io:format(Fd1,"ABCDEFGH",[]),
+    ok = ?FILE_MODULE:close(Fd1),
+    {ok,Fd2} = ?FILE_MODULE:open(Name,read),
 
     %% Start pos is first char
-    ?line io:format("Relative positions"),
-    ?line "A" = io:get_chars(Fd2,'',1),
-    ?line {ok,2} = ?FILE_MODULE:position(Fd2,{cur,1}), 
-    ?line "C" = io:get_chars(Fd2,'',1),
-    ?line {ok,0} = ?FILE_MODULE:position(Fd2,{cur,-3}), 
-    ?line "A" = io:get_chars(Fd2,'',1),
+    io:format("Relative positions"),
+    "A" = io:get_chars(Fd2,'',1),
+    {ok,2} = ?FILE_MODULE:position(Fd2,{cur,1}),
+    "C" = io:get_chars(Fd2,'',1),
+    {ok,0} = ?FILE_MODULE:position(Fd2,{cur,-3}),
+    "A" = io:get_chars(Fd2,'',1),
     %% Backwards from first char should be an error
-    ?line {ok,0} = ?FILE_MODULE:position(Fd2,{cur,-1}),
-    ?line {error, einval} = ?FILE_MODULE:position(Fd2,{cur,-1}),
+    {ok,0} = ?FILE_MODULE:position(Fd2,{cur,-1}),
+    {error, einval} = ?FILE_MODULE:position(Fd2,{cur,-1}),
     %% Reset position and move again
-    ?line {ok,0} = ?FILE_MODULE:position(Fd2,0),
-    ?line {ok,2} = ?FILE_MODULE:position(Fd2,{cur,2}), 
-    ?line "C" = io:get_chars(Fd2,'',1),
+    {ok,0} = ?FILE_MODULE:position(Fd2,0),
+    {ok,2} = ?FILE_MODULE:position(Fd2,{cur,2}),
+    "C" = io:get_chars(Fd2,'',1),
     %% Go a lot forwards
-    ?line {ok,13} = ?FILE_MODULE:position(Fd2,{cur,10}), 
-    ?line eof = io:get_chars(Fd2,'',1),
+    {ok,13} = ?FILE_MODULE:position(Fd2,{cur,10}),
+    eof = io:get_chars(Fd2,'',1),
 
     %% Try some fixed positions
-    ?line io:format("Fixed positions"),
-    ?line {ok,8} = 
+    io:format("Fixed positions"),
+    {ok,8} =
 	?FILE_MODULE:position(Fd2,8), eof = io:get_chars(Fd2,'',1),
-    ?line {ok,8} = 
+    {ok,8} =
 	?FILE_MODULE:position(Fd2,cur), eof = io:get_chars(Fd2,'',1),
-    ?line {ok,7} = 
+    {ok,7} =
 	?FILE_MODULE:position(Fd2,7), "H" = io:get_chars(Fd2,'',1),
-    ?line {ok,0} = 
+    {ok,0} =
 	?FILE_MODULE:position(Fd2,0), "A" = io:get_chars(Fd2,'',1),
-    ?line {ok,3} = 
+    {ok,3} =
 	?FILE_MODULE:position(Fd2,3), "D" = io:get_chars(Fd2,'',1),
-    ?line {ok,12} = 
+    {ok,12} =
 	?FILE_MODULE:position(Fd2,12), eof = io:get_chars(Fd2,'',1),
-    ?line {ok,3} = 
+    {ok,3} =
 	?FILE_MODULE:position(Fd2,3), "D" = io:get_chars(Fd2,'',1),
     %% Try the {bof,X} notation
-    ?line {ok,3} = ?FILE_MODULE:position(Fd2,{bof,3}),
-    ?line "D" = io:get_chars(Fd2,'',1),
+    {ok,3} = ?FILE_MODULE:position(Fd2,{bof,3}),
+    "D" = io:get_chars(Fd2,'',1),
 
     %% Try eof positions
-    ?line io:format("EOF positions"),
-    ?line {ok,8} = 
+    io:format("EOF positions"),
+    {ok,8} =
 	?FILE_MODULE:position(Fd2,{eof,0}), eof=io:get_chars(Fd2,'',1),
-    ?line {ok,7} = 
+    {ok,7} =
 	?FILE_MODULE:position(Fd2,{eof,-1}),
-    ?line "H" = io:get_chars(Fd2,'',1),
-    ?line {ok,0} = 
+    "H" = io:get_chars(Fd2,'',1),
+    {ok,0} =
 	?FILE_MODULE:position(Fd2,{eof,-8}), "A"=io:get_chars(Fd2,'',1),
-    ?line {error, einval} = ?FILE_MODULE:position(Fd2,{eof,-9}),
+    {error, einval} = ?FILE_MODULE:position(Fd2,{eof,-9}),
 
-    ?line [] = flush(),
+    [] = flush(),
     ok.
 
 pos2(Config) when is_list(Config) ->
     RootDir = proplists:get_value(priv_dir,Config),
-    ?line Name = filename:join(RootDir, 
-			       atom_to_list(?MODULE)
-			       ++"_pos2.fil"),
-    ?line {ok,Fd1} = ?FILE_MODULE:open(Name,write),
-    ?line io:format(Fd1,"ABCDEFGH",[]),
-    ?line ok = ?FILE_MODULE:close(Fd1),
-    ?line {ok,Fd2} = ?FILE_MODULE:open(Name,read),
-    ?line {error, einval} = ?FILE_MODULE:position(Fd2,-1),
+    Name = filename:join(RootDir,
+			 atom_to_list(?MODULE)
+			 ++"_pos2.fil"),
+    {ok,Fd1} = ?FILE_MODULE:open(Name,write),
+    io:format(Fd1,"ABCDEFGH",[]),
+    ok = ?FILE_MODULE:close(Fd1),
+    {ok,Fd2} = ?FILE_MODULE:open(Name,read),
+    {error, einval} = ?FILE_MODULE:position(Fd2,-1),
 
     %% Make sure that we still can search after an error.
-    ?line {ok,0} = ?FILE_MODULE:position(Fd2, 0),
-    ?line {ok,3} = ?FILE_MODULE:position(Fd2, {bof,3}),
-    ?line "D" = io:get_chars(Fd2,'',1),
+    {ok,0} = ?FILE_MODULE:position(Fd2, 0),
+    {ok,3} = ?FILE_MODULE:position(Fd2, {bof,3}),
+    "D" = io:get_chars(Fd2,'',1),
 
-    ?line [] = flush(),
-    ?line io:format("DONE"),
+    [] = flush(),
+    io:format("DONE"),
     ok.
 
 %% When it does not use raw mode, file:position had a bug.
 pos3(Config) when is_list(Config) ->
     RootDir = proplists:get_value(data_dir, Config),
-    ?line Name = filename:join(RootDir, "realmen.html.gz"),
+    Name = filename:join(RootDir, "realmen.html.gz"),
 
-    ?line {ok, Fd} = ?FILE_MODULE:open(Name, [read, binary]),
-    ?line {ok, _}  = ?FILE_MODULE:read(Fd, 5),
-    ?line {error, einval} = ?FILE_MODULE:position(Fd, {bof, -1}),
+    {ok, Fd} = ?FILE_MODULE:open(Name, [read, binary]),
+    {ok, _}  = ?FILE_MODULE:read(Fd, 5),
+    {error, einval} = ?FILE_MODULE:position(Fd, {bof, -1}),
 
     %% Here ok had returned =(
-    ?line {error, einval} = ?FILE_MODULE:position(Fd, {cur, -10}),
+    {error, einval} = ?FILE_MODULE:position(Fd, {cur, -10}),
     %% That test is actually questionable since file:position/2
     %% is documented to leave the file position undefined after
     %% it has returned an error.  But on Posix systems the position
@@ -1306,29 +1306,29 @@ file_info_basic_file(Config) when is_list(Config) ->
     RootDir = proplists:get_value(priv_dir, Config),
 
     %% Create a short file.
-    ?line Name = filename:join(RootDir, 
-			       atom_to_list(?MODULE)
-			       ++"_basic_test.fil"),
-    ?line {ok,Fd1} = ?FILE_MODULE:open(Name, write),
-    ?line io:put_chars(Fd1, "foo bar"),
-    ?line ok = ?FILE_MODULE:close(Fd1),
+    Name = filename:join(RootDir,
+			 atom_to_list(?MODULE)
+			 ++"_basic_test.fil"),
+    {ok,Fd1} = ?FILE_MODULE:open(Name, write),
+    io:put_chars(Fd1, "foo bar"),
+    ok = ?FILE_MODULE:close(Fd1),
 
     %% Test that the file has the expected attributes.
     %% The times are tricky, so we will save them to a separate test case.
     {ok,FileInfo} = ?FILE_MODULE:read_file_info(Name),
     {ok,FileInfo} = ?FILE_MODULE:read_file_info(Name, [raw]),
     #file_info{size=Size,type=Type,access=Access,
-                         atime=AccessTime,mtime=ModifyTime} = FileInfo,
-    ?line io:format("Access ~p, Modify ~p", [AccessTime, ModifyTime]),
-    ?line Size = 7,
-    ?line Type = regular,
-    ?line read_write = Access,
-    ?line true = abs(time_dist(filter_atime(AccessTime, Config),
-			       filter_atime(ModifyTime,
-					    Config))) < 2,
-    ?line all_integers(tuple_to_list(AccessTime) ++ tuple_to_list(ModifyTime)),
-
-    ?line [] = flush(),
+	       atime=AccessTime,mtime=ModifyTime} = FileInfo,
+    io:format("Access ~p, Modify ~p", [AccessTime, ModifyTime]),
+    Size = 7,
+    Type = regular,
+    read_write = Access,
+    true = abs(time_dist(filter_atime(AccessTime, Config),
+			 filter_atime(ModifyTime,
+				      Config))) < 2,
+    all_integers(tuple_to_list(AccessTime) ++ tuple_to_list(ModifyTime)),
+
+    [] = flush(),
     ok.
 
 file_info_basic_directory(Config) when is_list(Config) ->
@@ -1346,11 +1346,11 @@ file_info_basic_directory(Config) when is_list(Config) ->
     %% directories.
     case os:type() of
         {win32, _} ->
-            ?line test_directory("/", read_write),
-            ?line test_directory("c:/", read_write),
-            ?line test_directory("c:\\", read_write);
+            test_directory("/", read_write),
+            test_directory("c:/", read_write),
+            test_directory("c:\\", read_write);
         _ ->
-            ?line test_directory("/", read)
+            test_directory("/", read)
     end,
     ok.
 
@@ -1359,21 +1359,21 @@ test_directory(Name, ExpectedAccess) ->
     {ok,FileInfo} = ?FILE_MODULE:read_file_info(Name, [raw]),
     #file_info{size=Size,type=Type,access=Access,
                atime=AccessTime,mtime=ModifyTime} = FileInfo,
-    ?line io:format("Testing directory ~s", [Name]),
-    ?line io:format("Directory size is ~p", [Size]),
-    ?line io:format("Access ~p", [Access]),
-    ?line io:format("Access time ~p; Modify time~p", 
-		    [AccessTime, ModifyTime]),
-    ?line Type = directory,
-    ?line Access = ExpectedAccess,
-    ?line all_integers(tuple_to_list(AccessTime) ++ tuple_to_list(ModifyTime)),
-    ?line [] = flush(),
+    io:format("Testing directory ~s", [Name]),
+    io:format("Directory size is ~p", [Size]),
+    io:format("Access ~p", [Access]),
+    io:format("Access time ~p; Modify time~p",
+	      [AccessTime, ModifyTime]),
+    Type = directory,
+    Access = ExpectedAccess,
+    all_integers(tuple_to_list(AccessTime) ++ tuple_to_list(ModifyTime)),
+    [] = flush(),
     ok.
 
 all_integers([{A,B,C}|T]) ->
     all_integers([A,B,C|T]);
 all_integers([Int|Rest]) when is_integer(Int) ->
-    ?line all_integers(Rest);
+    all_integers(Rest);
 all_integers([]) -> ok.
 
 %% Try something nonexistent.
@@ -1383,9 +1383,9 @@ file_info_bad(Config) when is_list(Config) ->
     FileName = filename:join(RootDir, atom_to_list(?MODULE) ++ "_nonexistent"),
     {error,enoent} = ?FILE_MODULE:read_file_info(FileName),
     {error,enoent} = ?FILE_MODULE:read_file_info(FileName, [raw]),
-    ?line {error, enoent} = ?FILE_MODULE:read_file_info(""),
+    {error, enoent} = ?FILE_MODULE:read_file_info(""),
     {error, enoent} = ?FILE_MODULE:read_file_info("", [raw]),
-    ?line [] = flush(),
+    [] = flush(),
     ok.
 
 %% Test that the file times behave as they should.
@@ -1394,9 +1394,9 @@ file_info_times(Config) when is_list(Config) ->
     %% We have to try this twice, since if the test runs across the change
     %% of a month the time diff calculations will fail. But it won't happen
     %% if you run it twice in succession.
-    ?line test_server:m_out_of_n(
-	    1,2,
-	    fun() -> ?line file_info_int(Config) end),
+    test_server:m_out_of_n(
+      1,2,
+      fun() -> file_info_int(Config) end),
     ok.
 
 file_info_int(Config) ->
@@ -1407,11 +1407,11 @@ file_info_int(Config) ->
     RootDir = filename:join([proplists:get_value(priv_dir, Config)]),
     io:format("RootDir = ~p", [RootDir]),
 
-    ?line Name = filename:join(RootDir, 
-			       atom_to_list(?MODULE)
-			       ++"_file_info.fil"),
-    ?line {ok,Fd1} = ?FILE_MODULE:open(Name,write),
-    ?line io:put_chars(Fd1,"foo"),
+    Name = filename:join(RootDir,
+			 atom_to_list(?MODULE)
+			 ++"_file_info.fil"),
+    {ok,Fd1} = ?FILE_MODULE:open(Name,write),
+    io:put_chars(Fd1,"foo"),
 
     %% check that the file got a modify date max a few seconds away from now
     {ok,FileInfo1} = ?FILE_MODULE:read_file_info(Name),
@@ -1424,13 +1424,13 @@ file_info_int(Config) ->
 
     #file_info{type=regular,atime=AccTime1,mtime=ModTime1} = FileInfo1,
 
-    ?line Now = erlang:localtime(), %???
-    ?line io:format("Now ~p",[Now]),
-    ?line io:format("Open file Acc ~p Mod ~p",[AccTime1,ModTime1]),
-    ?line true = abs(time_dist(filter_atime(Now, Config),
-			       filter_atime(AccTime1,
-					    Config))) < 8,
-    ?line true = abs(time_dist(Now,ModTime1)) < 8,
+    Now = erlang:localtime(), %???
+    io:format("Now ~p",[Now]),
+    io:format("Open file Acc ~p Mod ~p",[AccTime1,ModTime1]),
+    true = abs(time_dist(filter_atime(Now, Config),
+			 filter_atime(AccTime1,
+				      Config))) < 8,
+    true = abs(time_dist(Now,ModTime1)) < 8,
 
     %% Sleep until we can be sure the seconds value has changed.
     %% Note: FAT-based filesystem (like on Windows 95) have
@@ -1438,17 +1438,17 @@ file_info_int(Config) ->
     timer:sleep(2200),
 
     %% close the file, and watch the modify date change
-    ?line ok = ?FILE_MODULE:close(Fd1),
+    ok = ?FILE_MODULE:close(Fd1),
     {ok,FileInfo2} = ?FILE_MODULE:read_file_info(Name),
     {ok,FileInfo2} = ?FILE_MODULE:read_file_info(Name, [raw]),
     #file_info{size=Size,type=regular,access=Access,
                atime=AccTime2,mtime=ModTime2} = FileInfo2,
-    ?line io:format("Closed file Acc ~p Mod ~p",[AccTime2,ModTime2]),
-    ?line true = time_dist(ModTime1,ModTime2) >= 0,
+    io:format("Closed file Acc ~p Mod ~p",[AccTime2,ModTime2]),
+    true = time_dist(ModTime1,ModTime2) >= 0,
 
     %% this file is supposed to be binary, so it'd better keep it's size
-    ?line Size = 3,
-    ?line Access = read_write,
+    Size = 3,
+    Access = read_write,
 
     %% Do some directory checking
     {ok,FileInfo3} = ?FILE_MODULE:read_file_info(RootDir),
@@ -1456,12 +1456,12 @@ file_info_int(Config) ->
     #file_info{size=DSize,type=directory,access=DAccess,
                atime=AccTime3,mtime=ModTime3} = FileInfo3,
     %% this dir was modified only a few secs ago
-    ?line io:format("Dir Acc ~p; Mod ~p; Now ~p", [AccTime3, ModTime3, Now]),
-    ?line true = abs(time_dist(Now,ModTime3)) < 5,
-    ?line DAccess = read_write,
-    ?line io:format("Dir size is ~p",[DSize]),
+    io:format("Dir Acc ~p; Mod ~p; Now ~p", [AccTime3, ModTime3, Now]),
+    true = abs(time_dist(Now,ModTime3)) < 5,
+    DAccess = read_write,
+    io:format("Dir size is ~p",[DSize]),
 
-    ?line [] = flush(),
+    [] = flush(),
     ok.
 
 %% Filter access times, to copy with a deficiency of FAT file systems
@@ -1472,9 +1472,9 @@ filter_atime(Atime, Config) ->
 	true ->
 	    case Atime of
 	    	{Date, _} ->
-	    	   {Date, {0, 0, 0}};
+		    {Date, {0, 0, 0}};
 		{Y, M, D, _, _, _} ->
-		   {Y, M, D, 0, 0, 0}
+		    {Y, M, D, 0, 0, 0}
 	    end;
 	false ->
 	    Atime
@@ -1483,46 +1483,46 @@ filter_atime(Atime, Config) ->
 %% Test the write_file_info/2 function.
 
 file_write_file_info(Config) when is_list(Config) ->
-    ?line RootDir = get_good_directory(Config),
+    RootDir = get_good_directory(Config),
     io:format("RootDir = ~p", [RootDir]),
 
     %% Set the file to read only AND update the file times at the same time.
     %% (This used to fail on Windows NT/95 for a local filesystem.)
     %% Note: Seconds must be even; see note in file_info_times/1.
 
-    ?line Name1 = filename:join(RootDir, 
-			       atom_to_list(?MODULE)
-			       ++"_write_file_info_ro"),
-    ?line ok = ?FILE_MODULE:write_file(Name1, "hello"),
-    ?line Time = {{1997, 01, 02}, {12, 35, 42}},
-    ?line Info = #file_info{mode=8#400, atime=Time, mtime=Time, ctime=Time},
-    ?line ok = ?FILE_MODULE:write_file_info(Name1, Info),
+    Name1 = filename:join(RootDir,
+			  atom_to_list(?MODULE)
+			  ++"_write_file_info_ro"),
+    ok = ?FILE_MODULE:write_file(Name1, "hello"),
+    Time = {{1997, 01, 02}, {12, 35, 42}},
+    Info = #file_info{mode=8#400, atime=Time, mtime=Time, ctime=Time},
+    ok = ?FILE_MODULE:write_file_info(Name1, Info),
 
     %% Read back the times.
 
-    ?line {ok, ActualInfo} = ?FILE_MODULE:read_file_info(Name1),
-    ?line #file_info{mode=_Mode, atime=ActAtime, mtime=Time,
-		     ctime=ActCtime} = ActualInfo,
-    ?line FilteredAtime = filter_atime(Time, Config),
-    ?line FilteredAtime = filter_atime(ActAtime, Config),
-    ?line case os:type() of
-	      {win32, _} ->
-		  %% On Windows, "ctime" means creation time and it can
-		  %% be set.
-		  ActCtime = Time;
-	      _ ->
-		  ok
-	  end,
-    ?line {error, eacces} = ?FILE_MODULE:write_file(Name1, "hello again"),
+    {ok, ActualInfo} = ?FILE_MODULE:read_file_info(Name1),
+    #file_info{mode=_Mode, atime=ActAtime, mtime=Time,
+	       ctime=ActCtime} = ActualInfo,
+    FilteredAtime = filter_atime(Time, Config),
+    FilteredAtime = filter_atime(ActAtime, Config),
+    case os:type() of
+	{win32, _} ->
+	    %% On Windows, "ctime" means creation time and it can
+	    %% be set.
+	    ActCtime = Time;
+	_ ->
+	    ok
+    end,
+    {error, eacces} = ?FILE_MODULE:write_file(Name1, "hello again"),
 
     %% Make the file writable again.
 
-    ?line ?FILE_MODULE:write_file_info(Name1, #file_info{mode=8#600}),
-    ?line ok = ?FILE_MODULE:write_file(Name1, "hello again"),
+    ?FILE_MODULE:write_file_info(Name1, #file_info{mode=8#600}),
+    ok = ?FILE_MODULE:write_file(Name1, "hello again"),
 
     %% And unwritable.
-    ?line ?FILE_MODULE:write_file_info(Name1, #file_info{mode=8#400}),
-    ?line {error, eacces} = ?FILE_MODULE:write_file(Name1, "hello again"),
+    ?FILE_MODULE:write_file_info(Name1, #file_info{mode=8#400}),
+    {error, eacces} = ?FILE_MODULE:write_file(Name1, "hello again"),
 
     %% Same with raw.
     ?FILE_MODULE:write_file_info(Name1, #file_info{mode=8#600}, [raw]),
@@ -1533,27 +1533,27 @@ file_write_file_info(Config) when is_list(Config) ->
     %% Write the times again.
     %% Note: Seconds must be even; see note in file_info_times/1.
 
-    ?line NewTime = {{1997, 02, 15}, {13, 18, 20}},
-    ?line NewInfo = #file_info{atime=NewTime, mtime=NewTime, ctime=NewTime},
-    ?line ok = ?FILE_MODULE:write_file_info(Name1, NewInfo),
-    ?line {ok, ActualInfo2} = ?FILE_MODULE:read_file_info(Name1),
-    ?line #file_info{atime=NewActAtime, mtime=NewTime,
-		     ctime=NewActCtime} = ActualInfo2,
-    ?line NewFilteredAtime = filter_atime(NewTime, Config),
-    ?line NewFilteredAtime = filter_atime(NewActAtime, Config),
-    ?line case os:type() of
-	      {win32, _} -> NewActCtime = NewTime;
-	      _ -> ok
-	  end,
+    NewTime = {{1997, 02, 15}, {13, 18, 20}},
+    NewInfo = #file_info{atime=NewTime, mtime=NewTime, ctime=NewTime},
+    ok = ?FILE_MODULE:write_file_info(Name1, NewInfo),
+    {ok, ActualInfo2} = ?FILE_MODULE:read_file_info(Name1),
+    #file_info{atime=NewActAtime, mtime=NewTime,
+	       ctime=NewActCtime} = ActualInfo2,
+    NewFilteredAtime = filter_atime(NewTime, Config),
+    NewFilteredAtime = filter_atime(NewActAtime, Config),
+    case os:type() of
+	{win32, _} -> NewActCtime = NewTime;
+	_ -> ok
+    end,
 
     %% The file should still be unwritable.
-    ?line {error, eacces} = ?FILE_MODULE:write_file(Name1, "hello again"),
+    {error, eacces} = ?FILE_MODULE:write_file(Name1, "hello again"),
 
     %% Make the file writeable again, so that we can remove the
     %% test suites ... :-)
-    ?line ?FILE_MODULE:write_file_info(Name1, #file_info{mode=8#600}),
+    ?FILE_MODULE:write_file_info(Name1, #file_info{mode=8#600}),
 
-    ?line [] = flush(),
+    [] = flush(),
     ok.
 
 %% Returns a directory on a file system that has correct file times.
@@ -1564,356 +1564,356 @@ get_good_directory(Config) ->
 
 consult1(Config) when is_list(Config) ->
     RootDir = proplists:get_value(priv_dir,Config),
-    ?line Name = filename:join(RootDir, 
-			       atom_to_list(?MODULE)
-			       ++"_consult.fil"),
-    ?line {ok,Fd1} = ?FILE_MODULE:open(Name,write),
+    Name = filename:join(RootDir,
+			 atom_to_list(?MODULE)
+			 ++"_consult.fil"),
+    {ok,Fd1} = ?FILE_MODULE:open(Name,write),
     %% note that there is no final \n (only a space)
-    ?line io:format(Fd1,
-		    "{this,[is,1.0],'journey'}.\n\"into\". (sound). ",
-		    []),
-    ?line ok = ?FILE_MODULE:close(Fd1),
-    ?line {ok,[{this,[is,1.0],journey},"into",sound]} = 
+    io:format(Fd1,
+	      "{this,[is,1.0],'journey'}.\n\"into\". (sound). ",
+	      []),
+    ok = ?FILE_MODULE:close(Fd1),
+    {ok,[{this,[is,1.0],journey},"into",sound]} =
 	?FILE_MODULE:consult(Name),
 
-    ?line {ok,Fd2} = ?FILE_MODULE:open(Name,write),
+    {ok,Fd2} = ?FILE_MODULE:open(Name,write),
     %% note the missing double quote
-    ?line io:format(
-	    Fd2,"{this,[is,1.0],'journey'}.\n \"into. (sound). ",[]),
-    ?line ok = ?FILE_MODULE:close(Fd2),
-    ?line {error, {_, _, _} = Msg} = ?FILE_MODULE:consult(Name),
-    ?line io:format("Errmsg: ~p",[Msg]),
+    io:format(
+      Fd2,"{this,[is,1.0],'journey'}.\n \"into. (sound). ",[]),
+    ok = ?FILE_MODULE:close(Fd2),
+    {error, {_, _, _} = Msg} = ?FILE_MODULE:consult(Name),
+    io:format("Errmsg: ~p",[Msg]),
 
-    ?line {error, enoent} = ?FILE_MODULE:consult(Name ++ ".nonexistent"),
+    {error, enoent} = ?FILE_MODULE:consult(Name ++ ".nonexistent"),
 
-    ?line [] = flush(),
+    [] = flush(),
     ok.
 
 path_consult(Config) when is_list(Config) ->
     RootDir = proplists:get_value(priv_dir,Config),
-    ?line FileName = atom_to_list(?MODULE)++"_path_consult.fil",
-    ?line Name = filename:join(RootDir, FileName),
-    ?line {ok,Fd1} = ?FILE_MODULE:open(Name,write),
-    ?line io:format(Fd1,"{this,is,a,journey,into,sound}.\n",[]),
-    ?line ok = ?FILE_MODULE:close(Fd1),
+    FileName = atom_to_list(?MODULE)++"_path_consult.fil",
+    Name = filename:join(RootDir, FileName),
+    {ok,Fd1} = ?FILE_MODULE:open(Name,write),
+    io:format(Fd1,"{this,is,a,journey,into,sound}.\n",[]),
+    ok = ?FILE_MODULE:close(Fd1),
     %% File last in path
-    ?line {ok,[{this,is,a,journey,into,sound}],Dir} =
+    {ok,[{this,is,a,journey,into,sound}],Dir} =
 	?FILE_MODULE:path_consult(
-	  [filename:join(RootDir, "dir1"),
-	   filename:join(RootDir, ".."),
-	   filename:join(RootDir, "dir2"),
-	   RootDir], FileName),
-    ?line true = lists:prefix(RootDir,Dir),
+	   [filename:join(RootDir, "dir1"),
+	    filename:join(RootDir, ".."),
+	    filename:join(RootDir, "dir2"),
+	    RootDir], FileName),
+    true = lists:prefix(RootDir,Dir),
 
     %% While maybe not an error, it may be worth noting that
     %% when the full path to a file is given, it's always found
     %% regardless of the contents of the path
-    ?line {ok,_,_} = ?FILE_MODULE:path_consult(["nosuch1","nosuch2"],Name),
+    {ok,_,_} = ?FILE_MODULE:path_consult(["nosuch1","nosuch2"],Name),
 
-    ?line [] = flush(),
+    [] = flush(),
     ok.
 
 
 eval1(Config) when is_list(Config) ->
     RootDir = proplists:get_value(priv_dir,Config),
-    ?line Name = filename:join(RootDir, 
-			       atom_to_list(?MODULE)++"_eval.fil"),
-    ?line {ok,Fd1} = ?FILE_MODULE:open(Name,write),
+    Name = filename:join(RootDir,
+			 atom_to_list(?MODULE)++"_eval.fil"),
+    {ok,Fd1} = ?FILE_MODULE:open(Name,write),
     %% note that there is no final \n (only a space)
-    ?line io:format(Fd1,"put(evaluated_ok,\ntrue). ",[]),
-    ?line ok = ?FILE_MODULE:close(Fd1),
-    ?line ok = ?FILE_MODULE:eval(Name),
-    ?line true = get(evaluated_ok),
-    
-    ?line {ok,Fd2} = ?FILE_MODULE:open(Name,write),
+    io:format(Fd1,"put(evaluated_ok,\ntrue). ",[]),
+    ok = ?FILE_MODULE:close(Fd1),
+    ok = ?FILE_MODULE:eval(Name),
+    true = get(evaluated_ok),
+
+    {ok,Fd2} = ?FILE_MODULE:open(Name,write),
     %% note that there is no final \n (only a space)
-    ?line io:format(Fd2,"put(evaluated_ok,\nR). ",[]),
-    ?line ok = ?FILE_MODULE:close(Fd2),
-    ?line ok = ?FILE_MODULE:eval(
-		  Name, 
-		  erl_eval:add_binding('R', true, erl_eval:new_bindings())),
-    ?line true = get(evaluated_ok),
-    
-    ?line {ok,Fd3} = ?FILE_MODULE:open(Name,write),
+    io:format(Fd2,"put(evaluated_ok,\nR). ",[]),
+    ok = ?FILE_MODULE:close(Fd2),
+    ok = ?FILE_MODULE:eval(
+	    Name,
+	    erl_eval:add_binding('R', true, erl_eval:new_bindings())),
+    true = get(evaluated_ok),
+
+    {ok,Fd3} = ?FILE_MODULE:open(Name,write),
     %% garbled
-    ?line io:format(Fd3,"puGARBLED-GARBLED\ntrue). ",[]),
-    ?line ok = ?FILE_MODULE:close(Fd3),
-    ?line {error, {_, _, _} = Msg} = ?FILE_MODULE:eval(Name),
-    ?line io:format("Errmsg1: ~p",[Msg]),
-    
-    ?line {error, enoent} = ?FILE_MODULE:eval(Name ++ ".nonexistent"),
-
-    ?line [] = flush(),
+    io:format(Fd3,"puGARBLED-GARBLED\ntrue). ",[]),
+    ok = ?FILE_MODULE:close(Fd3),
+    {error, {_, _, _} = Msg} = ?FILE_MODULE:eval(Name),
+    io:format("Errmsg1: ~p",[Msg]),
+
+    {error, enoent} = ?FILE_MODULE:eval(Name ++ ".nonexistent"),
+
+    [] = flush(),
     ok.
 
 path_eval(Config) when is_list(Config) ->
     RootDir = proplists:get_value(priv_dir,Config),
-    ?line FileName = atom_to_list(?MODULE)++"_path_eval.fil",
-    ?line Name = filename:join(RootDir, FileName),
-    ?line {ok,Fd1} = ?FILE_MODULE:open(Name,write),
-    ?line io:format(Fd1,"put(evaluated_ok,true).\n",[]),
-    ?line ok = ?FILE_MODULE:close(Fd1),
+    FileName = atom_to_list(?MODULE)++"_path_eval.fil",
+    Name = filename:join(RootDir, FileName),
+    {ok,Fd1} = ?FILE_MODULE:open(Name,write),
+    io:format(Fd1,"put(evaluated_ok,true).\n",[]),
+    ok = ?FILE_MODULE:close(Fd1),
     %% File last in path
-    ?line {ok,Dir} =
+    {ok,Dir} =
 	?FILE_MODULE:path_eval(
-	  [filename:join(RootDir, "dir1"),
-	   filename:join(RootDir, ".."),
-	   filename:join(RootDir, "dir2"),
-	   RootDir],FileName),
-    ?line true = get(evaluated_ok),
-    ?line true = lists:prefix(RootDir,Dir),
-    
+	   [filename:join(RootDir, "dir1"),
+	    filename:join(RootDir, ".."),
+	    filename:join(RootDir, "dir2"),
+	    RootDir],FileName),
+    true = get(evaluated_ok),
+    true = lists:prefix(RootDir,Dir),
+
     %% While maybe not an error, it may be worth noting that
     %% when the full path to a file is given, it's always found
     %% regardless of the contents of the path
-    ?line {ok,Fd2} = ?FILE_MODULE:open(Name,write),
-    ?line io:format(Fd2,"put(evaluated_ok,R).\n",[]),
-    ?line ok = ?FILE_MODULE:close(Fd2),
-    ?line {ok,_} = ?FILE_MODULE:path_eval(
-		      ["nosuch1","nosuch2"],
-		      Name,
-		      erl_eval:add_binding('R', true, erl_eval:new_bindings())),
-    
-    ?line [] = flush(),
+    {ok,Fd2} = ?FILE_MODULE:open(Name,write),
+    io:format(Fd2,"put(evaluated_ok,R).\n",[]),
+    ok = ?FILE_MODULE:close(Fd2),
+    {ok,_} = ?FILE_MODULE:path_eval(
+		["nosuch1","nosuch2"],
+		Name,
+		erl_eval:add_binding('R', true, erl_eval:new_bindings())),
+
+    [] = flush(),
     ok.
 
 
 script1(Config) when is_list(Config) ->
     RootDir = proplists:get_value(priv_dir,Config),
-    ?line Name = filename:join(RootDir, 
-			       atom_to_list(?MODULE)++"_script.fil"),
-    ?line {ok,Fd1} = ?FILE_MODULE:open(Name,write),
+    Name = filename:join(RootDir,
+			 atom_to_list(?MODULE)++"_script.fil"),
+    {ok,Fd1} = ?FILE_MODULE:open(Name,write),
     %% note that there is no final \n (only a space)
-    ?line io:format(Fd1,"A = 11,\nB = 6,\nA+B. ",[]),
-    ?line ok = ?FILE_MODULE:close(Fd1),
-    ?line {ok,17} = ?FILE_MODULE:script(Name),
-    
-    ?line {ok,Fd2} = ?FILE_MODULE:open(Name,write),
+    io:format(Fd1,"A = 11,\nB = 6,\nA+B. ",[]),
+    ok = ?FILE_MODULE:close(Fd1),
+    {ok,17} = ?FILE_MODULE:script(Name),
+
+    {ok,Fd2} = ?FILE_MODULE:open(Name,write),
     %% note that there is no final \n (only a space)
-    ?line io:format(Fd2,"A = 11,\nA+B. ",[]),
-    ?line ok = ?FILE_MODULE:close(Fd2),
-    ?line {ok,17} = ?FILE_MODULE:script(
-		       Name, 
-		       erl_eval:add_binding('B', 6, erl_eval:new_bindings())),
-    
-    ?line {ok,Fd3} = ?FILE_MODULE:open(Name,write),
-    ?line io:format(Fd3,"A = 11,\nB = six,\nA+B. ",[]),
-    ?line ok = ?FILE_MODULE:close(Fd3),
-    ?line {error, {_, _, _} = Msg} = ?FILE_MODULE:script(Name),
-    ?line io:format("Errmsg1: ~p",[Msg]),
-
-    ?line {error, enoent} = ?FILE_MODULE:script(Name ++ ".nonexistent"),
-    
-    ?line [] = flush(),
+    io:format(Fd2,"A = 11,\nA+B. ",[]),
+    ok = ?FILE_MODULE:close(Fd2),
+    {ok,17} = ?FILE_MODULE:script(
+		 Name,
+		 erl_eval:add_binding('B', 6, erl_eval:new_bindings())),
+
+    {ok,Fd3} = ?FILE_MODULE:open(Name,write),
+    io:format(Fd3,"A = 11,\nB = six,\nA+B. ",[]),
+    ok = ?FILE_MODULE:close(Fd3),
+    {error, {_, _, _} = Msg} = ?FILE_MODULE:script(Name),
+    io:format("Errmsg1: ~p",[Msg]),
+
+    {error, enoent} = ?FILE_MODULE:script(Name ++ ".nonexistent"),
+
+    [] = flush(),
     ok.
-    
+
 path_script(Config) when is_list(Config) ->
     RootDir = proplists:get_value(priv_dir,Config),
-    ?line FileName = atom_to_list(?MODULE)++"_path_script.fil",
-    ?line Name = filename:join(RootDir, FileName),
-    ?line {ok,Fd1} = ?FILE_MODULE:open(Name,write),
-    ?line io:format(Fd1,"A = 11,\nB = 6,\nA+B.\n",[]),
-    ?line ok = ?FILE_MODULE:close(Fd1),
+    FileName = atom_to_list(?MODULE)++"_path_script.fil",
+    Name = filename:join(RootDir, FileName),
+    {ok,Fd1} = ?FILE_MODULE:open(Name,write),
+    io:format(Fd1,"A = 11,\nB = 6,\nA+B.\n",[]),
+    ok = ?FILE_MODULE:close(Fd1),
     %% File last in path
-    ?line {ok, 17, Dir} =
+    {ok, 17, Dir} =
 	?FILE_MODULE:path_script(
 	   [filename:join(RootDir, "dir1"),
 	    filename:join(RootDir, ".."),
 	    filename:join(RootDir, "dir2"),
 	    RootDir],FileName),
-    ?line true = lists:prefix(RootDir,Dir),
-    
+    true = lists:prefix(RootDir,Dir),
+
     %% While maybe not an error, it may be worth noting that
     %% when the full path to a file is given, it's always found
     %% regardless of the contents of the path
-    ?line {ok,Fd2} = ?FILE_MODULE:open(Name,write),
-    ?line io:format(Fd2,"A = 11,\nA+B.",[]),
-    ?line ok = ?FILE_MODULE:close(Fd2),
-    ?line {ok, 17, Dir} = 
+    {ok,Fd2} = ?FILE_MODULE:open(Name,write),
+    io:format(Fd2,"A = 11,\nA+B.",[]),
+    ok = ?FILE_MODULE:close(Fd2),
+    {ok, 17, Dir} =
 	?FILE_MODULE:path_script(
 	   ["nosuch1","nosuch2"],
 	   Name,
 	   erl_eval:add_binding('B', 6, erl_eval:new_bindings())),
-    
-    ?line [] = flush(),
+
+    [] = flush(),
     ok.
 
-    
+
 
 truncate(Config) when is_list(Config) ->
     RootDir = proplists:get_value(priv_dir,Config),
-    ?line Name = filename:join(RootDir, 
-			       atom_to_list(?MODULE)
-			       ++"_truncate.fil"),
+    Name = filename:join(RootDir,
+			 atom_to_list(?MODULE)
+			 ++"_truncate.fil"),
 
     %% Create a file with some data.
-    ?line MyData = "0123456789abcdefghijklmnopqrstuvxyz",
-    ?line ok = ?FILE_MODULE:write_file(Name, MyData),
+    MyData = "0123456789abcdefghijklmnopqrstuvxyz",
+    ok = ?FILE_MODULE:write_file(Name, MyData),
 
     %% Truncate the file to 10 characters.
-    ?line {ok, Fd} = ?FILE_MODULE:open(Name, read_write),
-    ?line {ok, 10} = ?FILE_MODULE:position(Fd, 10),
-    ?line ok = ?FILE_MODULE:truncate(Fd),
-    ?line ok = ?FILE_MODULE:close(Fd),
+    {ok, Fd} = ?FILE_MODULE:open(Name, read_write),
+    {ok, 10} = ?FILE_MODULE:position(Fd, 10),
+    ok = ?FILE_MODULE:truncate(Fd),
+    ok = ?FILE_MODULE:close(Fd),
 
     %% Read back the file and check that it has been truncated.
-    ?line Expected = list_to_binary("0123456789"),
-    ?line {ok, Expected} = ?FILE_MODULE:read_file(Name),
+    Expected = list_to_binary("0123456789"),
+    {ok, Expected} = ?FILE_MODULE:read_file(Name),
 
     %% Open the file read only and verify that it is not possible to
     %% truncate it, OTP-1960
-    ?line {ok, Fd2} = ?FILE_MODULE:open(Name, read),
-    ?line {ok, 5} = ?FILE_MODULE:position(Fd2, 5),
-    ?line {error, _} = ?FILE_MODULE:truncate(Fd2),
+    {ok, Fd2} = ?FILE_MODULE:open(Name, read),
+    {ok, 5} = ?FILE_MODULE:position(Fd2, 5),
+    {error, _} = ?FILE_MODULE:truncate(Fd2),
 
-    ?line [] = flush(),
+    [] = flush(),
     ok.
 
 
 %% Tests that ?FILE_MODULE:datasync/1 at least doesn't crash.
 datasync(Config) when is_list(Config) ->
     PrivDir = proplists:get_value(priv_dir, Config),
-    ?line Sync = filename:join(PrivDir,
-			       atom_to_list(?MODULE)
-			       ++"_sync.fil"),
+    Sync = filename:join(PrivDir,
+			 atom_to_list(?MODULE)
+			 ++"_sync.fil"),
 
     %% Raw open.
-    ?line {ok, Fd} = ?FILE_MODULE:open(Sync, [write, raw]),
-    ?line ok = ?FILE_MODULE:datasync(Fd),
-    ?line ok = ?FILE_MODULE:close(Fd),
+    {ok, Fd} = ?FILE_MODULE:open(Sync, [write, raw]),
+    ok = ?FILE_MODULE:datasync(Fd),
+    ok = ?FILE_MODULE:close(Fd),
 
     %% Ordinary open.
-    ?line {ok, Fd2} = ?FILE_MODULE:open(Sync, [write]),
-    ?line ok = ?FILE_MODULE:datasync(Fd2),
-    ?line ok = ?FILE_MODULE:close(Fd2),
+    {ok, Fd2} = ?FILE_MODULE:open(Sync, [write]),
+    ok = ?FILE_MODULE:datasync(Fd2),
+    ok = ?FILE_MODULE:close(Fd2),
 
-    ?line [] = flush(),
+    [] = flush(),
     ok.
 
 
 %% Tests that ?FILE_MODULE:sync/1 at least doesn't crash.
 sync(Config) when is_list(Config) ->
     PrivDir = proplists:get_value(priv_dir, Config),
-    ?line Sync = filename:join(PrivDir, 
-			       atom_to_list(?MODULE)
-			       ++"_sync.fil"),
+    Sync = filename:join(PrivDir,
+			 atom_to_list(?MODULE)
+			 ++"_sync.fil"),
 
     %% Raw open.
-    ?line {ok, Fd} = ?FILE_MODULE:open(Sync, [write, raw]),
-    ?line ok = ?FILE_MODULE:sync(Fd),
-    ?line ok = ?FILE_MODULE:close(Fd),
+    {ok, Fd} = ?FILE_MODULE:open(Sync, [write, raw]),
+    ok = ?FILE_MODULE:sync(Fd),
+    ok = ?FILE_MODULE:close(Fd),
 
     %% Ordinary open.
-    ?line {ok, Fd2} = ?FILE_MODULE:open(Sync, [write]),
-    ?line ok = ?FILE_MODULE:sync(Fd2),
-    ?line ok = ?FILE_MODULE:close(Fd2),
+    {ok, Fd2} = ?FILE_MODULE:open(Sync, [write]),
+    ok = ?FILE_MODULE:sync(Fd2),
+    ok = ?FILE_MODULE:close(Fd2),
 
-    ?line [] = flush(),
+    [] = flush(),
     ok.
 
 %% Tests that ?FILE_MODULE:advise/4 at least doesn't crash.
 advise(Config) when is_list(Config) ->
     PrivDir = proplists:get_value(priv_dir, Config),
-    ?line Advise = filename:join(PrivDir,
-			       atom_to_list(?MODULE)
-			       ++"_advise.fil"),
+    Advise = filename:join(PrivDir,
+			   atom_to_list(?MODULE)
+			   ++"_advise.fil"),
 
     Line1 = "Hello\n",
     Line2 = "World!\n",
 
-    ?line {ok, Fd} = ?FILE_MODULE:open(Advise, [write]),
-    ?line ok = ?FILE_MODULE:advise(Fd, 0, 0, normal),
-    ?line ok = io:format(Fd, "~s", [Line1]),
-    ?line ok = io:format(Fd, "~s", [Line2]),
-    ?line ok = ?FILE_MODULE:close(Fd),
-
-    ?line {ok, Fd2} = ?FILE_MODULE:open(Advise, [write]),
-    ?line ok = ?FILE_MODULE:advise(Fd2, 0, 0, random),
-    ?line ok = io:format(Fd2, "~s", [Line1]),
-    ?line ok = io:format(Fd2, "~s", [Line2]),
-    ?line ok = ?FILE_MODULE:close(Fd2),
-
-    ?line {ok, Fd3} = ?FILE_MODULE:open(Advise, [write]),
-    ?line ok = ?FILE_MODULE:advise(Fd3, 0, 0, sequential),
-    ?line ok = io:format(Fd3, "~s", [Line1]),
-    ?line ok = io:format(Fd3, "~s", [Line2]),
-    ?line ok = ?FILE_MODULE:close(Fd3),
-
-    ?line {ok, Fd4} = ?FILE_MODULE:open(Advise, [write]),
-    ?line ok = ?FILE_MODULE:advise(Fd4, 0, 0, will_need),
-    ?line ok = io:format(Fd4, "~s", [Line1]),
-    ?line ok = io:format(Fd4, "~s", [Line2]),
-    ?line ok = ?FILE_MODULE:close(Fd4),
-
-    ?line {ok, Fd5} = ?FILE_MODULE:open(Advise, [write]),
-    ?line ok = ?FILE_MODULE:advise(Fd5, 0, 0, dont_need),
-    ?line ok = io:format(Fd5, "~s", [Line1]),
-    ?line ok = io:format(Fd5, "~s", [Line2]),
-    ?line ok = ?FILE_MODULE:close(Fd5),
-
-    ?line {ok, Fd6} = ?FILE_MODULE:open(Advise, [write]),
-    ?line ok = ?FILE_MODULE:advise(Fd6, 0, 0, no_reuse),
-    ?line ok = io:format(Fd6, "~s", [Line1]),
-    ?line ok = io:format(Fd6, "~s", [Line2]),
-    ?line ok = ?FILE_MODULE:close(Fd6),
-
-    ?line {ok, Fd7} = ?FILE_MODULE:open(Advise, [write]),
-    ?line {error, einval} = ?FILE_MODULE:advise(Fd7, 0, 0, bad_advise),
-    ?line ok = ?FILE_MODULE:close(Fd7),
+    {ok, Fd} = ?FILE_MODULE:open(Advise, [write]),
+    ok = ?FILE_MODULE:advise(Fd, 0, 0, normal),
+    ok = io:format(Fd, "~s", [Line1]),
+    ok = io:format(Fd, "~s", [Line2]),
+    ok = ?FILE_MODULE:close(Fd),
+
+    {ok, Fd2} = ?FILE_MODULE:open(Advise, [write]),
+    ok = ?FILE_MODULE:advise(Fd2, 0, 0, random),
+    ok = io:format(Fd2, "~s", [Line1]),
+    ok = io:format(Fd2, "~s", [Line2]),
+    ok = ?FILE_MODULE:close(Fd2),
+
+    {ok, Fd3} = ?FILE_MODULE:open(Advise, [write]),
+    ok = ?FILE_MODULE:advise(Fd3, 0, 0, sequential),
+    ok = io:format(Fd3, "~s", [Line1]),
+    ok = io:format(Fd3, "~s", [Line2]),
+    ok = ?FILE_MODULE:close(Fd3),
+
+    {ok, Fd4} = ?FILE_MODULE:open(Advise, [write]),
+    ok = ?FILE_MODULE:advise(Fd4, 0, 0, will_need),
+    ok = io:format(Fd4, "~s", [Line1]),
+    ok = io:format(Fd4, "~s", [Line2]),
+    ok = ?FILE_MODULE:close(Fd4),
+
+    {ok, Fd5} = ?FILE_MODULE:open(Advise, [write]),
+    ok = ?FILE_MODULE:advise(Fd5, 0, 0, dont_need),
+    ok = io:format(Fd5, "~s", [Line1]),
+    ok = io:format(Fd5, "~s", [Line2]),
+    ok = ?FILE_MODULE:close(Fd5),
+
+    {ok, Fd6} = ?FILE_MODULE:open(Advise, [write]),
+    ok = ?FILE_MODULE:advise(Fd6, 0, 0, no_reuse),
+    ok = io:format(Fd6, "~s", [Line1]),
+    ok = io:format(Fd6, "~s", [Line2]),
+    ok = ?FILE_MODULE:close(Fd6),
+
+    {ok, Fd7} = ?FILE_MODULE:open(Advise, [write]),
+    {error, einval} = ?FILE_MODULE:advise(Fd7, 0, 0, bad_advise),
+    ok = ?FILE_MODULE:close(Fd7),
 
     %% test write without advise, then a read after an advise
-    ?line {ok, Fd8} = ?FILE_MODULE:open(Advise, [write]),
-    ?line ok = io:format(Fd8, "~s", [Line1]),
-    ?line ok = io:format(Fd8, "~s", [Line2]),
-    ?line ok = ?FILE_MODULE:close(Fd8),
-    ?line {ok, Fd9} = ?FILE_MODULE:open(Advise, [read]),
+    {ok, Fd8} = ?FILE_MODULE:open(Advise, [write]),
+    ok = io:format(Fd8, "~s", [Line1]),
+    ok = io:format(Fd8, "~s", [Line2]),
+    ok = ?FILE_MODULE:close(Fd8),
+    {ok, Fd9} = ?FILE_MODULE:open(Advise, [read]),
     Offset = 0,
     %% same as a 0 length in some implementations
     Length = length(Line1) + length(Line2),
-    ?line ok = ?FILE_MODULE:advise(Fd9, Offset, Length, sequential),
-    ?line {ok, Line1} = ?FILE_MODULE:read_line(Fd9),
-    ?line {ok, Line2} = ?FILE_MODULE:read_line(Fd9),
-    ?line eof = ?FILE_MODULE:read_line(Fd9),
-    ?line ok = ?FILE_MODULE:close(Fd9),
+    ok = ?FILE_MODULE:advise(Fd9, Offset, Length, sequential),
+    {ok, Line1} = ?FILE_MODULE:read_line(Fd9),
+    {ok, Line2} = ?FILE_MODULE:read_line(Fd9),
+    eof = ?FILE_MODULE:read_line(Fd9),
+    ok = ?FILE_MODULE:close(Fd9),
 
-    ?line [] = flush(),
+    [] = flush(),
     ok.
 
 %% Tests that ?FILE_MODULE:allocate/3 at least doesn't crash.
 allocate(Config) when is_list(Config) ->
     PrivDir = proplists:get_value(priv_dir, Config),
-    ?line Allocate = filename:join(PrivDir,
-			       atom_to_list(?MODULE)
-			       ++"_allocate.fil"),
+    Allocate = filename:join(PrivDir,
+			     atom_to_list(?MODULE)
+			     ++"_allocate.fil"),
 
     Line1 = "Hello\n",
     Line2 = "World!\n",
 
-    ?line {ok, Fd} = ?FILE_MODULE:open(Allocate, [write, binary]),
+    {ok, Fd} = ?FILE_MODULE:open(Allocate, [write, binary]),
     allocate_and_assert(Fd, 1, iolist_size([Line1, Line2])),
-    ?line ok = io:format(Fd, "~s", [Line1]),
-    ?line ok = io:format(Fd, "~s", [Line2]),
-    ?line ok = ?FILE_MODULE:close(Fd),
+    ok = io:format(Fd, "~s", [Line1]),
+    ok = io:format(Fd, "~s", [Line2]),
+    ok = ?FILE_MODULE:close(Fd),
 
-    ?line {ok, Fd2} = ?FILE_MODULE:open(Allocate, [write, binary]),
+    {ok, Fd2} = ?FILE_MODULE:open(Allocate, [write, binary]),
     allocate_and_assert(Fd2, 1, iolist_size(Line1)),
-    ?line ok = io:format(Fd2, "~s", [Line1]),
-    ?line ok = io:format(Fd2, "~s", [Line2]),
-    ?line ok = ?FILE_MODULE:close(Fd2),
+    ok = io:format(Fd2, "~s", [Line1]),
+    ok = io:format(Fd2, "~s", [Line2]),
+    ok = ?FILE_MODULE:close(Fd2),
 
-    ?line {ok, Fd3} = ?FILE_MODULE:open(Allocate, [write, binary]),
+    {ok, Fd3} = ?FILE_MODULE:open(Allocate, [write, binary]),
     allocate_and_assert(Fd3, 1, iolist_size(Line1) + 1),
-    ?line ok = io:format(Fd3, "~s", [Line1]),
-    ?line ok = io:format(Fd3, "~s", [Line2]),
-    ?line ok = ?FILE_MODULE:close(Fd3),
+    ok = io:format(Fd3, "~s", [Line1]),
+    ok = io:format(Fd3, "~s", [Line2]),
+    ok = ?FILE_MODULE:close(Fd3),
 
-    ?line {ok, Fd4} = ?FILE_MODULE:open(Allocate, [write, binary]),
+    {ok, Fd4} = ?FILE_MODULE:open(Allocate, [write, binary]),
     allocate_and_assert(Fd4, 1, 4 * iolist_size([Line1, Line2])),
-    ?line ok = io:format(Fd4, "~s", [Line1]),
-    ?line ok = io:format(Fd4, "~s", [Line2]),
-    ?line ok = ?FILE_MODULE:close(Fd4),
+    ok = io:format(Fd4, "~s", [Line1]),
+    ok = io:format(Fd4, "~s", [Line2]),
+    ok = ?FILE_MODULE:close(Fd4),
 
-    ?line [] = flush(),
+    [] = flush(),
     ok.
 
 allocate_and_assert(Fd, Offset, Length) ->
@@ -1940,130 +1940,130 @@ allocate_and_assert(Fd, Offset, Length) ->
     Result = ?FILE_MODULE:allocate(Fd, Offset, Length),
     case os:type() of
         {win32, _} ->
-            ?line {error, enotsup} = Result;
+            {error, enotsup} = Result;
         _ ->
-            ?line _ = Result
+            _ = Result
     end.
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
 delete(Config) when is_list(Config) ->
     RootDir = proplists:get_value(priv_dir,Config),
-    ?line Name = filename:join(RootDir, 
-			       atom_to_list(?MODULE)
-			       ++"_delete.fil"),
-    ?line {ok, Fd1} = ?FILE_MODULE:open(Name, write),
-    ?line io:format(Fd1,"ok.\n",[]),
-    ?line ok = ?FILE_MODULE:close(Fd1),
+    Name = filename:join(RootDir,
+			 atom_to_list(?MODULE)
+			 ++"_delete.fil"),
+    {ok, Fd1} = ?FILE_MODULE:open(Name, write),
+    io:format(Fd1,"ok.\n",[]),
+    ok = ?FILE_MODULE:close(Fd1),
     %% Check that the file is readable
-    ?line {ok, Fd2} = ?FILE_MODULE:open(Name, read),
-    ?line ok = ?FILE_MODULE:close(Fd2),
-    ?line ok = ?FILE_MODULE:delete(Name),
+    {ok, Fd2} = ?FILE_MODULE:open(Name, read),
+    ok = ?FILE_MODULE:close(Fd2),
+    ok = ?FILE_MODULE:delete(Name),
     %% Check that the file is not readable anymore
-    ?line {error, _} = ?FILE_MODULE:open(Name, read),
+    {error, _} = ?FILE_MODULE:open(Name, read),
     %% Try deleting a nonexistent file
-    ?line {error, enoent} = ?FILE_MODULE:delete(Name),
-    ?line [] = flush(),
+    {error, enoent} = ?FILE_MODULE:delete(Name),
+    [] = flush(),
     ok.
 
 rename(Config) when is_list(Config) ->
     RootDir = proplists:get_value(priv_dir,Config),
-    ?line FileName1 = atom_to_list(?MODULE)++"_rename.fil",
-    ?line FileName2 = atom_to_list(?MODULE)++"_rename.ful",
-    ?line Name1 = filename:join(RootDir, FileName1),
-    ?line Name2 = filename:join(RootDir, FileName2),
-    ?line {ok,Fd1} = ?FILE_MODULE:open(Name1,write),
-    ?line ok = ?FILE_MODULE:close(Fd1),
+    FileName1 = atom_to_list(?MODULE)++"_rename.fil",
+    FileName2 = atom_to_list(?MODULE)++"_rename.ful",
+    Name1 = filename:join(RootDir, FileName1),
+    Name2 = filename:join(RootDir, FileName2),
+    {ok,Fd1} = ?FILE_MODULE:open(Name1,write),
+    ok = ?FILE_MODULE:close(Fd1),
     %% Rename, and check that id really changed name
-    ?line ok = ?FILE_MODULE:rename(Name1,Name2),
-    ?line {error, _} = ?FILE_MODULE:open(Name1,read),
-    ?line {ok,Fd2} = ?FILE_MODULE:open(Name2,read),
-    ?line ok = ?FILE_MODULE:close(Fd2),
+    ok = ?FILE_MODULE:rename(Name1,Name2),
+    {error, _} = ?FILE_MODULE:open(Name1,read),
+    {ok,Fd2} = ?FILE_MODULE:open(Name2,read),
+    ok = ?FILE_MODULE:close(Fd2),
     %% Try renaming something to itself
-    ?line ok = ?FILE_MODULE:rename(Name2,Name2),
+    ok = ?FILE_MODULE:rename(Name2,Name2),
     %% Try renaming something that doesn't exist
-    ?line {error, enoent} = ?FILE_MODULE:rename(Name1,Name2),
+    {error, enoent} = ?FILE_MODULE:rename(Name1,Name2),
     %% Try renaming to something else than a string
-    ?line {error, badarg} = ?FILE_MODULE:rename(Name1,{foo,bar}),
-    
+    {error, badarg} = ?FILE_MODULE:rename(Name1,{foo,bar}),
+
     %% Move between directories
-    ?line DirName1 = filename:join(RootDir,
-				   atom_to_list(?MODULE)
-				   ++"_rename_dir"),
-    ?line DirName2 = filename:join(RootDir,
-				   atom_to_list(?MODULE)
-				   ++"_second_rename_dir"),
-    ?line Name1foo = filename:join(DirName1, "foo.fil"),
-    ?line Name2foo = filename:join(DirName2, "foo.fil"),
-    ?line Name2bar = filename:join(DirName2, "bar.dir"),
-    ?line ok = ?FILE_MODULE:make_dir(DirName1),
+    DirName1 = filename:join(RootDir,
+			     atom_to_list(?MODULE)
+			     ++"_rename_dir"),
+    DirName2 = filename:join(RootDir,
+			     atom_to_list(?MODULE)
+			     ++"_second_rename_dir"),
+    Name1foo = filename:join(DirName1, "foo.fil"),
+    Name2foo = filename:join(DirName2, "foo.fil"),
+    Name2bar = filename:join(DirName2, "bar.dir"),
+    ok = ?FILE_MODULE:make_dir(DirName1),
     %% The name has to include the full file name, path in not enough
-    ?line expect({error, eisdir}, {error, eexist}, 
-		 ?FILE_MODULE:rename(Name2,DirName1)),
-    ?line ok = ?FILE_MODULE:rename(Name2, Name1foo),
+    expect({error, eisdir}, {error, eexist},
+	   ?FILE_MODULE:rename(Name2,DirName1)),
+    ok = ?FILE_MODULE:rename(Name2, Name1foo),
     %% Now rename the directory
-    ?line ok = ?FILE_MODULE:rename(DirName1,DirName2),
+    ok = ?FILE_MODULE:rename(DirName1,DirName2),
     %% And check that the file is there now
-    ?line {ok,Fd3} = ?FILE_MODULE:open(Name2foo, read),
-    ?line ok = ?FILE_MODULE:close(Fd3),
+    {ok,Fd3} = ?FILE_MODULE:open(Name2foo, read),
+    ok = ?FILE_MODULE:close(Fd3),
     %% Try some dirty things now: move the directory into itself
-    ?line {error, Msg1} = ?FILE_MODULE:rename(DirName2, Name2bar),
-    ?line io:format("Errmsg1: ~p",[Msg1]),
+    {error, Msg1} = ?FILE_MODULE:rename(DirName2, Name2bar),
+    io:format("Errmsg1: ~p",[Msg1]),
     %% move dir into a file in itself
-    ?line {error, Msg2} = ?FILE_MODULE:rename(DirName2, Name2foo),
-    ?line io:format("Errmsg2: ~p",[Msg2]),
+    {error, Msg2} = ?FILE_MODULE:rename(DirName2, Name2foo),
+    io:format("Errmsg2: ~p",[Msg2]),
 
-    ?line [] = flush(),
+    [] = flush(),
     ok.
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
 names(Config) when is_list(Config) ->
     RootDir = proplists:get_value(priv_dir,Config),
-    ?line FileName = "foo1.fil",
-    ?line Name1 = filename:join(RootDir, FileName),
-    ?line Name2 = [RootDir,"/","foo1",".","fil"],
-    ?line Name3 = [RootDir,"/",foo,$1,[[[],[],'.']],"f",il],
-    ?line {ok,Fd0} = ?FILE_MODULE:open(Name1,write),
-    ?line ok = ?FILE_MODULE:close(Fd0),
+    FileName = "foo1.fil",
+    Name1 = filename:join(RootDir, FileName),
+    Name2 = [RootDir,"/","foo1",".","fil"],
+    Name3 = [RootDir,"/",foo,$1,[[[],[],'.']],"f",il],
+    {ok,Fd0} = ?FILE_MODULE:open(Name1,write),
+    ok = ?FILE_MODULE:close(Fd0),
 
     %% Try some file names
-    ?line {ok,Fd1} = ?FILE_MODULE:open(Name1,read),
-    ?line ok = ?FILE_MODULE:close(Fd1),
-    ?line {ok,Fd2f} = ?FILE_MODULE:open(lists:flatten(Name2),read),
-    ?line ok = ?FILE_MODULE:close(Fd2f),
-    ?line {ok,Fd2} = ?FILE_MODULE:open(Name2,read),
-    ?line ok = ?FILE_MODULE:close(Fd2),
-    ?line {ok,Fd3} = ?FILE_MODULE:open(Name3,read),
-    ?line ok = ?FILE_MODULE:close(Fd3),
-	case length(Name1) > 255 of
-		true ->
-			io:format("Path too long for an atom:\n\n~p\n", [Name1]);
-		false ->
-			Name4 = list_to_atom(Name1),
-			{ok,Fd4} = ?FILE_MODULE:open(Name4,read),
-			ok = ?FILE_MODULE:close(Fd4)
-	end,
+    {ok,Fd1} = ?FILE_MODULE:open(Name1,read),
+    ok = ?FILE_MODULE:close(Fd1),
+    {ok,Fd2f} = ?FILE_MODULE:open(lists:flatten(Name2),read),
+    ok = ?FILE_MODULE:close(Fd2f),
+    {ok,Fd2} = ?FILE_MODULE:open(Name2,read),
+    ok = ?FILE_MODULE:close(Fd2),
+    {ok,Fd3} = ?FILE_MODULE:open(Name3,read),
+    ok = ?FILE_MODULE:close(Fd3),
+    case length(Name1) > 255 of
+	true ->
+	    io:format("Path too long for an atom:\n\n~p\n", [Name1]);
+	false ->
+	    Name4 = list_to_atom(Name1),
+	    {ok,Fd4} = ?FILE_MODULE:open(Name4,read),
+	    ok = ?FILE_MODULE:close(Fd4)
+    end,
 
     %% Try some path names
-    ?line Path1 = RootDir,
-    ?line Path2 = [RootDir],
-    ?line Path3 = ['',[],[RootDir,[[]]]],
-    ?line {ok,Fd11,_} = ?FILE_MODULE:path_open([Path1],FileName,read),
-    ?line ok = ?FILE_MODULE:close(Fd11),
-    ?line {ok,Fd12,_} = ?FILE_MODULE:path_open([Path2],FileName,read),
-    ?line ok = ?FILE_MODULE:close(Fd12),
-    ?line {ok,Fd13,_} = ?FILE_MODULE:path_open([Path3],FileName,read),
-    ?line ok = ?FILE_MODULE:close(Fd13),
-	case length(Path1) > 255 of
-		true->
-			io:format("Path too long for an atom:\n\n~p\n", [Path1]);
-		false ->
-			Path4 = list_to_atom(Path1),
-			{ok,Fd14,_} = ?FILE_MODULE:path_open([Path4],FileName,read),
-			ok = ?FILE_MODULE:close(Fd14)
-	end,
-    ?line [] = flush(),
+    Path1 = RootDir,
+    Path2 = [RootDir],
+    Path3 = ['',[],[RootDir,[[]]]],
+    {ok,Fd11,_} = ?FILE_MODULE:path_open([Path1],FileName,read),
+    ok = ?FILE_MODULE:close(Fd11),
+    {ok,Fd12,_} = ?FILE_MODULE:path_open([Path2],FileName,read),
+    ok = ?FILE_MODULE:close(Fd12),
+    {ok,Fd13,_} = ?FILE_MODULE:path_open([Path3],FileName,read),
+    ok = ?FILE_MODULE:close(Fd13),
+    case length(Path1) > 255 of
+	true->
+	    io:format("Path too long for an atom:\n\n~p\n", [Path1]);
+	false ->
+	    Path4 = list_to_atom(Path1),
+	    {ok,Fd14,_} = ?FILE_MODULE:path_open([Path4],FileName,read),
+	    ok = ?FILE_MODULE:close(Fd14)
+    end,
+    [] = flush(),
     ok.
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
@@ -2071,39 +2071,39 @@ names(Config) when is_list(Config) ->
 
 e_delete(Config) when is_list(Config) ->
     RootDir = proplists:get_value(priv_dir, Config),
-    ?line Base = filename:join(RootDir, 
-			       atom_to_list(?MODULE)++"_e_delete"),
-    ?line ok = ?FILE_MODULE:make_dir(Base),
+    Base = filename:join(RootDir,
+			 atom_to_list(?MODULE)++"_e_delete"),
+    ok = ?FILE_MODULE:make_dir(Base),
 
     %% Delete a non-existing file.
-    ?line {error, enoent} = 
+    {error, enoent} =
 	?FILE_MODULE:delete(filename:join(Base, "non_existing")),
 
     %% Delete a directory.
-    ?line {error, eperm} = ?FILE_MODULE:delete(Base),
+    {error, eperm} = ?FILE_MODULE:delete(Base),
 
     %% Use a path-name with a non-directory component.
-    ?line Afile = filename:join(Base, "a_file"),
-    ?line ok = ?FILE_MODULE:write_file(Afile, "hello\n"),
-    ?line {error, E} = 
+    Afile = filename:join(Base, "a_file"),
+    ok = ?FILE_MODULE:write_file(Afile, "hello\n"),
+    {error, E} =
 	expect({error, enotdir}, {error, enoent}, 
 	       ?FILE_MODULE:delete(filename:join(Afile, "another_file"))),
-    ?line io:format("Result: ~p~n", [E]),
+    io:format("Result: ~p~n", [E]),
 
     %% No permission.
-    ?line case os:type() of
-		{win32, _} ->
-		  %% Remove a character device.
-		  ?line {error, eacces} = ?FILE_MODULE:delete("nul");
-		_ ->
-		  ?line ?FILE_MODULE:write_file_info(
-			   Base, #file_info {mode=0}),
-		  ?line {error, eacces} = ?FILE_MODULE:delete(Afile),
-		  ?line ?FILE_MODULE:write_file_info(
-			   Base, #file_info {mode=8#600})
-	  end,
+    case os:type() of
+	{win32, _} ->
+	    %% Remove a character device.
+	    {error, eacces} = ?FILE_MODULE:delete("nul");
+	_ ->
+	    ?FILE_MODULE:write_file_info(
+	       Base, #file_info {mode=0}),
+	    {error, eacces} = ?FILE_MODULE:delete(Afile),
+	    ?FILE_MODULE:write_file_info(
+	       Base, #file_info {mode=8#600})
+    end,
 
-    ?line [] = flush(),
+    [] = flush(),
     ok.
 
 %%% FreeBSD gives EEXIST when renaming a file to an empty dir, although the
@@ -2114,7 +2114,7 @@ e_delete(Config) when is_list(Config) ->
 e_rename(Config) when is_list(Config) ->
     RootDir = proplists:get_value(priv_dir, Config),
     Base = filename:join(RootDir,
-	atom_to_list(?MODULE)++"_e_rename"),
+			 atom_to_list(?MODULE)++"_e_rename"),
     ok = ?FILE_MODULE:make_dir(Base),
 
     %% Create an empty directory.
@@ -2125,15 +2125,15 @@ e_rename(Config) when is_list(Config) ->
     NonEmptyDir = filename:join(Base, "non_empty_dir"),
     ok = ?FILE_MODULE:make_dir(NonEmptyDir),
     ok = ?FILE_MODULE:write_file(
-	filename:join(NonEmptyDir, "a_file"),
-	"hello\n"),
+	    filename:join(NonEmptyDir, "a_file"),
+	    "hello\n"),
 
     %% Create another non-empty directory.
     ADirectory = filename:join(Base, "a_directory"),
     ok = ?FILE_MODULE:make_dir(ADirectory),
     ok = ?FILE_MODULE:write_file(
-	filename:join(ADirectory, "a_file"),
-	"howdy\n\n"),
+	    filename:join(ADirectory, "a_file"),
+	    "howdy\n\n"),
 
     %% Create a data file.
     File = filename:join(Base, "just_a_file"),
@@ -2147,15 +2147,15 @@ e_rename(Config) when is_list(Config) ->
 
     %% Move Base into Base/new_name.
     {error, einval} = 
-    ?FILE_MODULE:rename(Base, filename:join(Base, "new_name")),
+	?FILE_MODULE:rename(Base, filename:join(Base, "new_name")),
 
     %% Overwrite a directory with a file.
     expect({error, eexist}, %FreeBSD (?)
-	{error, eisdir},
-	?FILE_MODULE:rename(File, EmptyDir)),
+	   {error, eisdir},
+	   ?FILE_MODULE:rename(File, EmptyDir)),
     expect({error, eexist}, %FreeBSD (?)
-	{error, eisdir},
-	?FILE_MODULE:rename(File, NonEmptyDir)),
+	   {error, eisdir},
+	   ?FILE_MODULE:rename(File, NonEmptyDir)),
 
     %% Move a non-existing file.
     NonExistingFile = filename:join(Base, "non_existing_file"),
@@ -2163,8 +2163,8 @@ e_rename(Config) when is_list(Config) ->
 
     %% Overwrite a file with a directory.
     expect({error, eexist}, %FreeBSD (?)
-	{error, enotdir},
-	?FILE_MODULE:rename(ADirectory, File)),
+	   {error, enotdir},
+	   ?FILE_MODULE:rename(ADirectory, File)),
 
     %% Move a file to another filesystem.
     %% XXX - This test case is bogus. We cannot be guaranteed that
@@ -2173,33 +2173,33 @@ e_rename(Config) when is_list(Config) ->
     %%
     %% XXX - Gross hack!
     Comment = case os:type() of
-	{unix, _} ->
-	    OtherFs = "/tmp",
-	    NameOnOtherFs = filename:join(OtherFs, filename:basename(File)),
-	    {ok, Com} = case ?FILE_MODULE:rename(File, NameOnOtherFs) of
-		{error, exdev} ->
-		    %% The file could be in 
-		    %% the same filesystem!
-		    {ok, ok};
-		ok ->
-		    {ok, {comment, 
-			    "Moving between filesystems "
-			    "suceeded, files are probably "
-			    "in the same filesystem!"}};
-		{error, eperm} ->
-		    {ok, {comment, "SBS! You don't "
-			    "have the permission to do "
-			    "this test!"}};
-		Else ->
-		    Else
-	    end,
-	    Com;
-	{win32, _} ->
-	    %% At least Windows NT can 
-	    %% successfully move a file to
-	    %% another drive.
-	    ok
-    end,
+		  {unix, _} ->
+		      OtherFs = "/tmp",
+		      NameOnOtherFs = filename:join(OtherFs, filename:basename(File)),
+		      {ok, Com} = case ?FILE_MODULE:rename(File, NameOnOtherFs) of
+				      {error, exdev} ->
+					  %% The file could be in
+					  %% the same filesystem!
+					  {ok, ok};
+				      ok ->
+					  {ok, {comment,
+						"Moving between filesystems "
+						"suceeded, files are probably "
+						"in the same filesystem!"}};
+				      {error, eperm} ->
+					  {ok, {comment, "SBS! You don't "
+						"have the permission to do "
+						"this test!"}};
+				      Else ->
+					  Else
+				  end,
+		      Com;
+		  {win32, _} ->
+		      %% At least Windows NT can
+		      %% successfully move a file to
+		      %% another drive.
+		      ok
+	      end,
     [] = flush(),
     Comment.
 
@@ -2208,7 +2208,7 @@ e_rename(Config) when is_list(Config) ->
 e_make_dir(Config) when is_list(Config) ->
     RootDir = proplists:get_value(priv_dir, Config),
     Base = filename:join(RootDir, 
-          	       atom_to_list(?MODULE)++"_e_make_dir"),
+			 atom_to_list(?MODULE)++"_e_make_dir"),
     ok = ?FILE_MODULE:make_dir(Base),
 
     %% A component of the path does not exist.
@@ -2231,7 +2231,7 @@ e_make_dir(Config) when is_list(Config) ->
 	    ?FILE_MODULE:write_file_info(Base, #file_info {mode=0}),
 	    {error, eacces} = ?FILE_MODULE:make_dir(filename:join(Base, "xxxx")),
 	    ?FILE_MODULE:write_file_info(
-		     Base, #file_info {mode=8#600})
+	       Base, #file_info {mode=8#600})
     end,
     ok.
 
@@ -2251,21 +2251,21 @@ e_del_dir(Config) when is_list(Config) ->
     Afile = filename:join(Base, "a_directory"),
     ok = ?FILE_MODULE:write_file(Afile, "hello\n"),
     {error, E1} = expect({error, enotdir}, {error, enoent},
-	?FILE_MODULE:del_dir(
-	    filename:join(Afile, "another_directory"))),
+			 ?FILE_MODULE:del_dir(
+			    filename:join(Afile, "another_directory"))),
     io:format("Result: ~p", [E1]),
 
     %% Delete a non-empty directory.
     {error, E2} = expect({error, enotempty}, {error, eexist}, {error, eacces},
-	       ?FILE_MODULE:del_dir(Base)),
+			 ?FILE_MODULE:del_dir(Base)),
     io:format("Result: ~p", [E2]),
 
     %% Remove the current directory.
     {error, E3} = expect({error, einval}, 
-	       {error, eperm}, % Linux and DUX
-	       {error, eacces},
-	       {error, ebusy},
-	       ?FILE_MODULE:del_dir(".")),
+			 {error, eperm}, % Linux and DUX
+			 {error, eacces},
+			 {error, ebusy},
+			 ?FILE_MODULE:del_dir(".")),
     io:format("Result: ~p", [E3]),
 
     %% No permission.
@@ -2289,15 +2289,15 @@ e_del_dir(Config) when is_list(Config) ->
 
 read_compressed_cooked(Config) when is_list(Config) ->
     Data = proplists:get_value(data_dir, Config),
-    ?line Real = filename:join(Data, "realmen.html.gz"),
-    ?line {ok, Fd} = ?FILE_MODULE:open(Real, [read,compressed]),
-    ?line try_read_file_list(Fd).
+    Real = filename:join(Data, "realmen.html.gz"),
+    {ok, Fd} = ?FILE_MODULE:open(Real, [read,compressed]),
+    try_read_file_list(Fd).
 
 read_compressed_cooked_binary(Config) when is_list(Config) ->
     Data = proplists:get_value(data_dir, Config),
-    ?line Real = filename:join(Data, "realmen.html.gz"),
-    ?line {ok, Fd} = ?FILE_MODULE:open(Real, [read,compressed,binary]),
-    ?line try_read_file_binary(Fd).
+    Real = filename:join(Data, "realmen.html.gz"),
+    {ok, Fd} = ?FILE_MODULE:open(Real, [read,compressed,binary]),
+    try_read_file_binary(Fd).
 
 %% Trying reading and positioning from an uncompressed file,
 %% but with the compressed flag given.
@@ -2309,14 +2309,14 @@ read_not_really_compressed(Config) when is_list(Config) ->
     %% The file realmen.html might have got CRs added (by WinZip).
     %% Remove them, or the file positions will not be correct.
 
-    ?line Real = filename:join(Data, "realmen.html"),
-    ?line RealPriv = filename:join(Priv, 
-				   atom_to_list(?MODULE)++"_realmen.html"),
-    ?line {ok, RealDataBin} = ?FILE_MODULE:read_file(Real),
-    ?line RealData = remove_crs(binary_to_list(RealDataBin), []),
-    ?line ok = ?FILE_MODULE:write_file(RealPriv, RealData),
-    ?line {ok, Fd} = ?FILE_MODULE:open(RealPriv, [read, compressed]),
-    ?line try_read_file_list(Fd).
+    Real = filename:join(Data, "realmen.html"),
+    RealPriv = filename:join(Priv,
+			     atom_to_list(?MODULE)++"_realmen.html"),
+    {ok, RealDataBin} = ?FILE_MODULE:read_file(Real),
+    RealData = remove_crs(binary_to_list(RealDataBin), []),
+    ok = ?FILE_MODULE:write_file(RealPriv, RealData),
+    {ok, Fd} = ?FILE_MODULE:open(RealPriv, [read, compressed]),
+    try_read_file_list(Fd).
 
 remove_crs([$\r|Rest], Result) ->
     remove_crs(Rest, Result);
@@ -2328,97 +2328,97 @@ remove_crs([], Result) ->
 try_read_file_list(Fd) ->
     %% Seek to the current position (nothing should happen).
 
-    ?line {ok, 0} = ?FILE_MODULE:position(Fd, 0),
-    ?line {ok, 0} = ?FILE_MODULE:position(Fd, {cur, 0}),
+    {ok, 0} = ?FILE_MODULE:position(Fd, 0),
+    {ok, 0} = ?FILE_MODULE:position(Fd, {cur, 0}),
 
     %% Read a few lines from a compressed file.
 
-    ?line ShouldBe = "<TITLE>Real Programmers Don't Use PASCAL</TITLE>\n",
-    ?line ShouldBe = io:get_line(Fd, ''),
+    ShouldBe = "<TITLE>Real Programmers Don't Use PASCAL</TITLE>\n",
+    ShouldBe = io:get_line(Fd, ''),
 
     %% Now seek forward.
 
-    ?line {ok, 381} = ?FILE_MODULE:position(Fd, 381),
-    ?line Back = "Back in the good old days -- the \"Golden Era\" " ++
+    {ok, 381} = ?FILE_MODULE:position(Fd, 381),
+    Back = "Back in the good old days -- the \"Golden Era\" " ++
 	"of computers, it was\n",
-    ?line Back = io:get_line(Fd, ''),
+    Back = io:get_line(Fd, ''),
 
     %% Try to search forward relative to the current position.
 
-    ?line {ok, CurPos} = ?FILE_MODULE:position(Fd, {cur, 0}),
-    ?line RealPos = 4273,
-    ?line {ok, RealPos} = ?FILE_MODULE:position(Fd, {cur, RealPos-CurPos}),
-    ?line RealProg = "<LI> Real Programmers aren't afraid to use GOTOs.\n",
-    ?line RealProg = io:get_line(Fd, ''),
+    {ok, CurPos} = ?FILE_MODULE:position(Fd, {cur, 0}),
+    RealPos = 4273,
+    {ok, RealPos} = ?FILE_MODULE:position(Fd, {cur, RealPos-CurPos}),
+    RealProg = "<LI> Real Programmers aren't afraid to use GOTOs.\n",
+    RealProg = io:get_line(Fd, ''),
 
     %% Seek backward.
 
-    ?line AfterTitle = length("<TITLE>"),
-    ?line {ok, AfterTitle} = ?FILE_MODULE:position(Fd, AfterTitle),
-    ?line Title = "Real Programmers Don't Use PASCAL</TITLE>\n",
-    ?line Title = io:get_line(Fd, ''),
+    AfterTitle = length("<TITLE>"),
+    {ok, AfterTitle} = ?FILE_MODULE:position(Fd, AfterTitle),
+    Title = "Real Programmers Don't Use PASCAL</TITLE>\n",
+    Title = io:get_line(Fd, ''),
 
     %% Seek past the end of the file.
 
-    ?line {ok, _} = ?FILE_MODULE:position(Fd, 25000),
+    {ok, _} = ?FILE_MODULE:position(Fd, 25000),
 
     %% Done.
 
-    ?line ?FILE_MODULE:close(Fd),
-    ?line [] = flush(),
+    ?FILE_MODULE:close(Fd),
+    [] = flush(),
     ok.
 
 try_read_file_binary(Fd) ->
     %% Seek to the current position (nothing should happen).
 
-    ?line {ok, 0} = ?FILE_MODULE:position(Fd, 0),
-    ?line {ok, 0} = ?FILE_MODULE:position(Fd, {cur, 0}),
+    {ok, 0} = ?FILE_MODULE:position(Fd, 0),
+    {ok, 0} = ?FILE_MODULE:position(Fd, {cur, 0}),
 
     %% Read a few lines from a compressed file.
 
-    ?line ShouldBe = <<"<TITLE>Real Programmers Don't Use PASCAL</TITLE>\n">>,
-    ?line ShouldBe = io:get_line(Fd, ''),
+    ShouldBe = <<"<TITLE>Real Programmers Don't Use PASCAL</TITLE>\n">>,
+    ShouldBe = io:get_line(Fd, ''),
 
     %% Now seek forward.
 
-    ?line {ok, 381} = ?FILE_MODULE:position(Fd, 381),
-    ?line Back = <<"Back in the good old days -- the \"Golden Era\" "
-		  "of computers, it was\n">>,
-    ?line Back = io:get_line(Fd, ''),
+    {ok, 381} = ?FILE_MODULE:position(Fd, 381),
+    Back = <<"Back in the good old days -- the \"Golden Era\" "
+	     "of computers, it was\n">>,
+    Back = io:get_line(Fd, ''),
 
     %% Try to search forward relative to the current position.
 
-    ?line {ok, CurPos} = ?FILE_MODULE:position(Fd, {cur, 0}),
-    ?line RealPos = 4273,
-    ?line {ok, RealPos} = ?FILE_MODULE:position(Fd, {cur, RealPos-CurPos}),
-    ?line RealProg = <<"<LI> Real Programmers aren't afraid to use GOTOs.\n">>,
-    ?line RealProg = io:get_line(Fd, ''),
+    {ok, CurPos} = ?FILE_MODULE:position(Fd, {cur, 0}),
+    RealPos = 4273,
+    {ok, RealPos} = ?FILE_MODULE:position(Fd, {cur, RealPos-CurPos}),
+    RealProg = <<"<LI> Real Programmers aren't afraid to use GOTOs.\n">>,
+    RealProg = io:get_line(Fd, ''),
 
     %% Seek backward.
 
-    ?line AfterTitle = length("<TITLE>"),
-    ?line {ok, AfterTitle} = ?FILE_MODULE:position(Fd, AfterTitle),
-    ?line Title = <<"Real Programmers Don't Use PASCAL</TITLE>\n">>,
-    ?line Title = io:get_line(Fd, ''),
+    AfterTitle = length("<TITLE>"),
+    {ok, AfterTitle} = ?FILE_MODULE:position(Fd, AfterTitle),
+    Title = <<"Real Programmers Don't Use PASCAL</TITLE>\n">>,
+    Title = io:get_line(Fd, ''),
 
     %% Done.
 
-    ?line ?FILE_MODULE:close(Fd),
-    ?line [] = flush(),
+    ?FILE_MODULE:close(Fd),
+    [] = flush(),
     ok.
 
 read_cooked_tar_problem(Config) when is_list(Config) ->
     Data = proplists:get_value(data_dir, Config),
-    ?line ProblemFile = filename:join(Data, "cooked_tar_problem.tar.gz"),
-    ?line {ok,Fd} = ?FILE_MODULE:open(ProblemFile, [read,compressed,binary]),
+    ProblemFile = filename:join(Data, "cooked_tar_problem.tar.gz"),
+    {ok,Fd} = ?FILE_MODULE:open(ProblemFile, [read,compressed,binary]),
+
+    {ok,34304} = file:position(Fd, 34304),
+    {ok,Bin} = file:read(Fd, 512),
+    512 = byte_size(Bin),
+
+    {ok,34304+512+1024} = file:position(Fd, {cur,1024}),
 
-    ?line {ok,34304} = file:position(Fd, 34304),
-    ?line {ok,Bin} = file:read(Fd, 512),
-    ?line 512 = byte_size(Bin),
-    
-    ?line {ok,34304+512+1024} = file:position(Fd, {cur,1024}),
-    
-    ?line ok = file:close(Fd),
+    ok = file:close(Fd),
 
     ok.
 
@@ -2427,33 +2427,33 @@ read_cooked_tar_problem(Config) when is_list(Config) ->
 
 write_compressed(Config) when is_list(Config) ->
     Priv = proplists:get_value(priv_dir, Config),
-    ?line MyFile = filename:join(Priv, 
-				 atom_to_list(?MODULE)++"_test.gz"),
+    MyFile = filename:join(Priv,
+			   atom_to_list(?MODULE)++"_test.gz"),
 
     %% Write a file.
 
-    ?line {ok, Fd} = ?FILE_MODULE:open(MyFile, [write, compressed]),
-    ?line {ok, 0} = ?FILE_MODULE:position(Fd, 0),
-    ?line Prefix = "hello\n",
-    ?line End = "end\n",
-    ?line ok = io:put_chars(Fd, Prefix),
-    ?line {ok, 143} = ?FILE_MODULE:position(Fd, 143),
-    ?line ok = io:put_chars(Fd, End),
-    ?line ok = ?FILE_MODULE:close(Fd),
+    {ok, Fd} = ?FILE_MODULE:open(MyFile, [write, compressed]),
+    {ok, 0} = ?FILE_MODULE:position(Fd, 0),
+    Prefix = "hello\n",
+    End = "end\n",
+    ok = io:put_chars(Fd, Prefix),
+    {ok, 143} = ?FILE_MODULE:position(Fd, 143),
+    ok = io:put_chars(Fd, End),
+    ok = ?FILE_MODULE:close(Fd),
 
     %% Read the file and verify the contents.
 
-    ?line {ok, Fd1} = ?FILE_MODULE:open(MyFile, [read, compressed]),
-    ?line Prefix = io:get_line(Fd1, ''),
-    ?line Second = lists:duplicate(143-length(Prefix), 0) ++ End,
-    ?line Second = io:get_line(Fd1, ''),
-    ?line ok = ?FILE_MODULE:close(Fd1),
+    {ok, Fd1} = ?FILE_MODULE:open(MyFile, [read, compressed]),
+    Prefix = io:get_line(Fd1, ''),
+    Second = lists:duplicate(143-length(Prefix), 0) ++ End,
+    Second = io:get_line(Fd1, ''),
+    ok = ?FILE_MODULE:close(Fd1),
 
     %% Verify successful compression by uncompressing the file
     %% using zlib:gunzip/1.
 
-    ?line {ok,Contents} = file:read_file(MyFile),
-    ?line <<"hello\n",0:137/unit:8,"end\n">> = zlib:gunzip(Contents),
+    {ok,Contents} = file:read_file(MyFile),
+    <<"hello\n",0:137/unit:8,"end\n">> = zlib:gunzip(Contents),
 
     %% Ensure that the file is compressed.
 
@@ -2467,35 +2467,35 @@ write_compressed(Config) when is_list(Config) ->
 
     %% Write again to ensure that the file is truncated.
 
-    ?line {ok, Fd2} = ?FILE_MODULE:open(MyFile, [write, compressed]),
-    ?line NewString = "aaaaaaaaaaa",
-    ?line ok = io:put_chars(Fd2, NewString),
-    ?line ok = ?FILE_MODULE:close(Fd2),
-    ?line {ok, Fd3} = ?FILE_MODULE:open(MyFile, [read, compressed]),
-    ?line {ok, NewString} = ?FILE_MODULE:read(Fd3, 1024),
-    ?line ok = ?FILE_MODULE:close(Fd3),
+    {ok, Fd2} = ?FILE_MODULE:open(MyFile, [write, compressed]),
+    NewString = "aaaaaaaaaaa",
+    ok = io:put_chars(Fd2, NewString),
+    ok = ?FILE_MODULE:close(Fd2),
+    {ok, Fd3} = ?FILE_MODULE:open(MyFile, [read, compressed]),
+    {ok, NewString} = ?FILE_MODULE:read(Fd3, 1024),
+    ok = ?FILE_MODULE:close(Fd3),
 
     %% Done.
 
-    ?line [] = flush(),
+    [] = flush(),
     ok.
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
 catenated_gzips(Config) when is_list(Config) ->
     Priv = proplists:get_value(priv_dir, Config),
-    ?line MyFile = filename:join(Priv, ?MODULE_STRING++"_test.gz"),
+    MyFile = filename:join(Priv, ?MODULE_STRING++"_test.gz"),
 
     First = "Hello, all good men going to search parties. ",
     Second = "Now I really need your help.",
     All = iolist_to_binary([First|Second]),
-    ?line Cat = [zlib:gzip(First),zlib:gzip(Second)],
-    
-    ?line ok = file:write_file(MyFile, Cat),
+    Cat = [zlib:gzip(First),zlib:gzip(Second)],
 
-    ?line {ok,Fd} = file:open(MyFile, [read,compressed,binary]),
-    ?line {ok,All} = file:read(Fd, 100000),
-    ?line ok = file:close(Fd),
+    ok = file:write_file(MyFile, Cat),
+
+    {ok,Fd} = file:open(MyFile, [read,compressed,binary]),
+    {ok,All} = file:read(Fd, 100000),
+    ok = file:close(Fd),
 
     ok.
 
@@ -2503,51 +2503,51 @@ catenated_gzips(Config) when is_list(Config) ->
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
 compress_errors(Config) when is_list(Config) ->
-    ?line DataDir = 
+    DataDir =
 	filename:dirname(
 	  filename:join(proplists:get_value(data_dir, Config), "x")),
-    ?line DataDirSlash = DataDir++"/",
-    ?line {error, enoent} = ?FILE_MODULE:open("non_existing__",
-					      [compressed, read]),
-    ?line {error, einval} = ?FILE_MODULE:open("non_existing__",
-					      [compressed, read, write]),
-    ?line {error, einval} = ?FILE_MODULE:open("non_existing__",
-					      [compressed, read, append]),
-    ?line {error, einval} = ?FILE_MODULE:open("non_existing__",
-					      [compressed, write, append]),
-    ?line {error, E1} = ?FILE_MODULE:open(DataDir, [compressed, read]),
-    ?line {error, E2} = ?FILE_MODULE:open(DataDirSlash, [compressed, read]),
-    ?line {error, E3} = ?FILE_MODULE:open(DataDir, [compressed, write]),
-    ?line {error, E4} = ?FILE_MODULE:open(DataDirSlash, [compressed, write]),
-    ?line {eisdir,eisdir,eisdir,eisdir} = {E1,E2,E3,E4},
+    DataDirSlash = DataDir++"/",
+    {error, enoent} = ?FILE_MODULE:open("non_existing__",
+					[compressed, read]),
+    {error, einval} = ?FILE_MODULE:open("non_existing__",
+					[compressed, read, write]),
+    {error, einval} = ?FILE_MODULE:open("non_existing__",
+					[compressed, read, append]),
+    {error, einval} = ?FILE_MODULE:open("non_existing__",
+					[compressed, write, append]),
+    {error, E1} = ?FILE_MODULE:open(DataDir, [compressed, read]),
+    {error, E2} = ?FILE_MODULE:open(DataDirSlash, [compressed, read]),
+    {error, E3} = ?FILE_MODULE:open(DataDir, [compressed, write]),
+    {error, E4} = ?FILE_MODULE:open(DataDirSlash, [compressed, write]),
+    {eisdir,eisdir,eisdir,eisdir} = {E1,E2,E3,E4},
 
     %% Read a corrupted .gz file.
 
-    ?line Corrupted = filename:join(DataDir, "corrupted.gz"),
-    ?line {ok, Fd} = ?FILE_MODULE:open(Corrupted, [read, compressed]),
-    ?line {error, eio} = ?FILE_MODULE:read(Fd, 100),
-    ?line ?FILE_MODULE:close(Fd),
+    Corrupted = filename:join(DataDir, "corrupted.gz"),
+    {ok, Fd} = ?FILE_MODULE:open(Corrupted, [read, compressed]),
+    {error, eio} = ?FILE_MODULE:read(Fd, 100),
+    ?FILE_MODULE:close(Fd),
 
-    ?line [] = flush(),
+    [] = flush(),
     ok.
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
 compress_async_crash(Config) when is_list(Config) ->
     DataDir = proplists:get_value(data_dir, Config),
-    ?line Path = filename:join(DataDir, "test.gz"),
+    Path = filename:join(DataDir, "test.gz"),
     ExpectedData = <<"qwerty">>,
 
-    ?line _ = ?FILE_MODULE:delete(Path),
-    ?line {ok, Fd} = ?FILE_MODULE:open(Path, [write, binary, compressed]),
-    ?line ok = ?FILE_MODULE:write(Fd, ExpectedData),
-    ?line ok = ?FILE_MODULE:close(Fd),
+    _ = ?FILE_MODULE:delete(Path),
+    {ok, Fd} = ?FILE_MODULE:open(Path, [write, binary, compressed]),
+    ok = ?FILE_MODULE:write(Fd, ExpectedData),
+    ok = ?FILE_MODULE:close(Fd),
 
     %% Test that when using async thread pool, the emulator doesn't crash
     %% when the efile port driver is stopped while a compressed file operation
     %% is in progress (being carried by an async thread).
-    ?line ok = compress_async_crash_loop(10000, Path, ExpectedData),
-    ?line ok = ?FILE_MODULE:delete(Path),
+    ok = compress_async_crash_loop(10000, Path, ExpectedData),
+    ok = ?FILE_MODULE:delete(Path),
     ok.
 
 compress_async_crash_loop(0, _Path, _ExpectedData) ->
@@ -2555,21 +2555,21 @@ compress_async_crash_loop(0, _Path, _ExpectedData) ->
 compress_async_crash_loop(N, Path, ExpectedData) ->
     Parent = self(),
     {Pid, Ref} = spawn_monitor(
-            fun() ->
-                    ?line {ok, Fd} = ?FILE_MODULE:open(
-                                        Path, [read, compressed, raw, binary]),
-                    Len = byte_size(ExpectedData),
-                    Parent ! {self(), continue},
-                    ?line {ok, ExpectedData} = ?FILE_MODULE:read(Fd, Len),
-                    ?line ok = ?FILE_MODULE:close(Fd),
-                    receive foobar -> ok end
-            end),
+		   fun() ->
+			   {ok, Fd} = ?FILE_MODULE:open(
+					 Path, [read, compressed, raw, binary]),
+			   Len = byte_size(ExpectedData),
+			   Parent ! {self(), continue},
+			   {ok, ExpectedData} = ?FILE_MODULE:read(Fd, Len),
+			   ok = ?FILE_MODULE:close(Fd),
+			   receive foobar -> ok end
+		   end),
     receive
         {Pid, continue} ->
             exit(Pid, shutdown),
             receive
                 {'DOWN', Ref, _, _, Reason} ->
-                    ?line shutdown = Reason
+                    shutdown = Reason
             end;
         {'DOWN', Ref, _, _, Reason2} ->
             ct:fail({worker_exited, Reason2})
@@ -2619,43 +2619,43 @@ unicode(Config) when is_list(Config) ->
 %% Test the file:altname/1 function.
 altname(Config) when is_list(Config) ->
     RootDir = proplists:get_value(priv_dir, Config),
-    ?line NewDir = filename:join(RootDir, 
-				 "long alternative path name with spaces"),
-    ?line ok = ?FILE_MODULE:make_dir(NewDir),
-    ?line Name = filename:join(NewDir, "a_file_with_long_name"),
-    ?line ShortName = filename:join(NewDir, "short"),
-    ?line NonexName = filename:join(NewDir, "nonexistent"),
-    ?line ok = ?FILE_MODULE:write_file(Name, "some contents\n"),
-    ?line ok = ?FILE_MODULE:write_file(ShortName, "some contents\n"),
-    ?line Result = 
+    NewDir = filename:join(RootDir,
+			   "long alternative path name with spaces"),
+    ok = ?FILE_MODULE:make_dir(NewDir),
+    Name = filename:join(NewDir, "a_file_with_long_name"),
+    ShortName = filename:join(NewDir, "short"),
+    NonexName = filename:join(NewDir, "nonexistent"),
+    ok = ?FILE_MODULE:write_file(Name, "some contents\n"),
+    ok = ?FILE_MODULE:write_file(ShortName, "some contents\n"),
+    Result =
 	case ?FILE_MODULE:altname(NewDir) of
 	    {error, enotsup} ->
 		{skipped, "Altname not supported on this platform"};
 	    {ok, "LONGAL~1"} -> 
-		?line {ok, "A_FILE~1"} = ?FILE_MODULE:altname(Name),
-		?line {ok, "C:/"} = ?FILE_MODULE:altname("C:/"),
-		?line {ok, "C:\\"} = ?FILE_MODULE:altname("C:\\"),
-		?line {error,enoent} = ?FILE_MODULE:altname(NonexName),
-		?line {ok, "short"} = ?FILE_MODULE:altname(ShortName),
+		{ok, "A_FILE~1"} = ?FILE_MODULE:altname(Name),
+		{ok, "C:/"} = ?FILE_MODULE:altname("C:/"),
+		{ok, "C:\\"} = ?FILE_MODULE:altname("C:\\"),
+		{error,enoent} = ?FILE_MODULE:altname(NonexName),
+		{ok, "short"} = ?FILE_MODULE:altname(ShortName),
 		ok
 	end,
-    ?line [] = flush(),
+    [] = flush(),
     Result.
 
 
 %% Test creating a hard link.
 make_link(Config) when is_list(Config) ->
     RootDir = proplists:get_value(priv_dir, Config),
-    ?line NewDir = filename:join(RootDir, 
-				 atom_to_list(?MODULE)
-				 ++"_make_link"),
-    ?line ok = ?FILE_MODULE:make_dir(NewDir),
-    
-    ?line Name = filename:join(NewDir, "a_file"),
-    ?line ok = ?FILE_MODULE:write_file(Name, "some contents\n"),
-    
-    ?line Alias = filename:join(NewDir, "an_alias"),
-    ?line Result = 
+    NewDir = filename:join(RootDir,
+			   atom_to_list(?MODULE)
+			   ++"_make_link"),
+    ok = ?FILE_MODULE:make_dir(NewDir),
+
+    Name = filename:join(NewDir, "a_file"),
+    ok = ?FILE_MODULE:write_file(Name, "some contents\n"),
+
+    Alias = filename:join(NewDir, "an_alias"),
+    Result =
 	case ?FILE_MODULE:make_link(Name, Alias) of
 	    {error, enotsup} ->
 		{skipped, "Links not supported on this platform"};
@@ -2665,45 +2665,45 @@ make_link(Config) when is_list(Config) ->
 		%% which should in behave exactly as 
 		%% ?FILE_MODULE:read_file_info/1
 		%% since they are not used on symbolic links.
-		
-		?line {ok, Info} = ?FILE_MODULE:read_link_info(Name),
+
+		{ok, Info} = ?FILE_MODULE:read_link_info(Name),
                 {ok,Info} = ?FILE_MODULE:read_link_info(Name, [raw]),
-		?line {ok, Info} = ?FILE_MODULE:read_link_info(Alias),
+		{ok, Info} = ?FILE_MODULE:read_link_info(Alias),
                 {ok,Info} = ?FILE_MODULE:read_link_info(Alias, [raw]),
-		?line #file_info{links = 2, type = regular} = Info,
-		?line {error, eexist} = 
+		#file_info{links = 2, type = regular} = Info,
+		{error, eexist} =
 		    ?FILE_MODULE:make_link(Name, Alias),
 		ok
 	end,
-    
-    ?line [] = flush(),
+
+    [] = flush(),
     Result.
 
 %% Test that reading link info for an ordinary file or directory works
 %% (on all platforms).
 read_link_info_for_non_link(Config) when is_list(Config) ->
-    ?line {ok, #file_info{type=directory}} = 
+    {ok, #file_info{type=directory}} =
 	?FILE_MODULE:read_link_info("."),
     {ok, #file_info{type=directory}} = ?FILE_MODULE:read_link_info(".", [raw]),
-		  
-    ?line [] = flush(),
+
+    [] = flush(),
     ok.
 
 %% Test operations on symbolic links (for Unix).
 symlinks(Config) when is_list(Config) ->
-    ?line {error, _} = ?FILE_MODULE:read_link(lists:duplicate(10000,$a)),
+    {error, _} = ?FILE_MODULE:read_link(lists:duplicate(10000,$a)),
     {error, _} = ?FILE_MODULE:read_link_all(lists:duplicate(10000,$a)),
     RootDir = proplists:get_value(priv_dir, Config),
-    ?line NewDir = filename:join(RootDir, 
-				 atom_to_list(?MODULE)
-				 ++"_symlinks"),
-    ?line ok = ?FILE_MODULE:make_dir(NewDir),
-    
-    ?line Name = filename:join(NewDir, "a_plain_file"),
-    ?line ok = ?FILE_MODULE:write_file(Name, "some stupid content\n"),
-    
-    ?line Alias = filename:join(NewDir, "a_symlink_alias"),
-    ?line Result = 
+    NewDir = filename:join(RootDir,
+			   atom_to_list(?MODULE)
+			   ++"_symlinks"),
+    ok = ?FILE_MODULE:make_dir(NewDir),
+
+    Name = filename:join(NewDir, "a_plain_file"),
+    ok = ?FILE_MODULE:write_file(Name, "some stupid content\n"),
+
+    Alias = filename:join(NewDir, "a_symlink_alias"),
+    Result =
 	case ?FILE_MODULE:make_symlink(Name, Alias) of
 	    {error, enotsup} ->
 		{skipped, "Links not supported on this platform"};
@@ -2711,25 +2711,25 @@ symlinks(Config) when is_list(Config) ->
 		{win32,_} = os:type(),
 		{skipped, "Windows user not privileged to create symlinks"};
 	    ok ->
-		?line {ok, Info1} = ?FILE_MODULE:read_file_info(Name),
+		{ok, Info1} = ?FILE_MODULE:read_file_info(Name),
                 {ok,Info1} = ?FILE_MODULE:read_file_info(Name, [raw]),
-		?line {ok, Info1} = ?FILE_MODULE:read_file_info(Alias),
+		{ok, Info1} = ?FILE_MODULE:read_file_info(Alias),
                 {ok,Info1} = ?FILE_MODULE:read_file_info(Alias, [raw]),
-		?line {ok, Info1} = ?FILE_MODULE:read_link_info(Name),
+		{ok, Info1} = ?FILE_MODULE:read_link_info(Name),
                 {ok,Info1} = ?FILE_MODULE:read_link_info(Name, [raw]),
-		?line #file_info{links = 1, type = regular} = Info1,
-		
-		?line {ok, Info2} = ?FILE_MODULE:read_link_info(Alias),
+		#file_info{links = 1, type = regular} = Info1,
+
+		{ok, Info2} = ?FILE_MODULE:read_link_info(Alias),
                 {ok,Info2} = ?FILE_MODULE:read_link_info(Alias, [raw]),
-		?line #file_info{links=1, type=symlink} = Info2,
-		?line {ok, Name} = ?FILE_MODULE:read_link(Alias),
+		#file_info{links=1, type=symlink} = Info2,
+		{ok, Name} = ?FILE_MODULE:read_link(Alias),
 		{ok, Name} = ?FILE_MODULE:read_link_all(Alias),
 		%% If all is good, delete dir again (avoid hanging dir on windows)
 		rm_rf(?FILE_MODULE,NewDir),
 		ok
-	  end,
-    
-    ?line [] = flush(),
+	end,
+
+    [] = flush(),
     Result.
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
@@ -2737,11 +2737,11 @@ symlinks(Config) when is_list(Config) ->
 copy(Config) when is_list(Config) ->
     RootDir = proplists:get_value(priv_dir, Config),
     %% Create a text file.
-    ?line Name1 = filename:join(RootDir, atom_to_list(?MODULE)++"_copy_1.txt"),
-    ?line Line = "The quick brown fox jumps over a lazy dog. 0123456789\n",
-    ?line Len = length(Line),
-    ?line {ok, Handle1} = ?FILE_MODULE:open(Name1, [write]),
-    ?line {_, Size1} = 
+    Name1 = filename:join(RootDir, atom_to_list(?MODULE)++"_copy_1.txt"),
+    Line = "The quick brown fox jumps over a lazy dog. 0123456789\n",
+    Len = length(Line),
+    {ok, Handle1} = ?FILE_MODULE:open(Name1, [write]),
+    {_, Size1} =
 	iterate({0, 0},
 		done,
 		fun({_, S}) when S >= 128*1024 ->
@@ -2751,44 +2751,44 @@ copy(Config) when is_list(Config) ->
 			ok = ?FILE_MODULE:write(Handle1, [H, " ", Line]),
 			{N + 1, S + length(H) + 1 + Len}
 		end),
-    ?line ?FILE_MODULE:close(Handle1),
+    ?FILE_MODULE:close(Handle1),
     %% Make a copy
-    ?line Name2 = filename:join(RootDir, atom_to_list(?MODULE)++"_copy_2.txt"),
-    ?line {ok, Size1} = ?FILE_MODULE:copy(Name1, Name2),
+    Name2 = filename:join(RootDir, atom_to_list(?MODULE)++"_copy_2.txt"),
+    {ok, Size1} = ?FILE_MODULE:copy(Name1, Name2),
     %% Concatenate 1
-    ?line Name3 = filename:join(RootDir, atom_to_list(?MODULE)++"_copy_3.txt"),
-    ?line {ok, Handle3} = ?FILE_MODULE:open(Name3, [raw, write, binary]),
-    ?line {ok, Size1} = ?FILE_MODULE:copy(Name1, Handle3),
-    ?line {ok, Handle2} = ?FILE_MODULE:open(Name2, [read, binary]),
-    ?line {ok, Size1} = ?FILE_MODULE:copy(Handle2, Handle3),
-    ?line ok = ?FILE_MODULE:close(Handle3),
-    ?line ok = ?FILE_MODULE:close(Handle2),
+    Name3 = filename:join(RootDir, atom_to_list(?MODULE)++"_copy_3.txt"),
+    {ok, Handle3} = ?FILE_MODULE:open(Name3, [raw, write, binary]),
+    {ok, Size1} = ?FILE_MODULE:copy(Name1, Handle3),
+    {ok, Handle2} = ?FILE_MODULE:open(Name2, [read, binary]),
+    {ok, Size1} = ?FILE_MODULE:copy(Handle2, Handle3),
+    ok = ?FILE_MODULE:close(Handle3),
+    ok = ?FILE_MODULE:close(Handle2),
     %% Concatenate 2
-    ?line Name4 = filename:join(RootDir, atom_to_list(?MODULE)++"_copy_4.txt"),
-    ?line {ok, Handle4} = ?FILE_MODULE:open(Name4, [write, binary]),
-    ?line {ok, Size1} = ?FILE_MODULE:copy(Name1, Handle4),
-    ?line {ok, Handle5} = ?FILE_MODULE:open(Name2, [raw, read, binary]),
-    ?line {ok, Size1} = ?FILE_MODULE:copy(Handle5, Handle4),
-    ?line ok = ?FILE_MODULE:close(Handle5),
-    ?line ok = ?FILE_MODULE:close(Handle4),
+    Name4 = filename:join(RootDir, atom_to_list(?MODULE)++"_copy_4.txt"),
+    {ok, Handle4} = ?FILE_MODULE:open(Name4, [write, binary]),
+    {ok, Size1} = ?FILE_MODULE:copy(Name1, Handle4),
+    {ok, Handle5} = ?FILE_MODULE:open(Name2, [raw, read, binary]),
+    {ok, Size1} = ?FILE_MODULE:copy(Handle5, Handle4),
+    ok = ?FILE_MODULE:close(Handle5),
+    ok = ?FILE_MODULE:close(Handle4),
     %% %% Just for test of the test
-    %% ?line {ok, Handle2q} = ?FILE_MODULE:open(Name2, [write, append]),
-    %% ?line ok = ?FILE_MODULE:write(Handle2q, "q"),
-    %% ?line ok = ?FILE_MODULE:close(Handle2q),
+    %% {ok, Handle2q} = ?FILE_MODULE:open(Name2, [write, append]),
+    %% ok = ?FILE_MODULE:write(Handle2q, "q"),
+    %% ok = ?FILE_MODULE:close(Handle2q),
     %% Compare the files
-    ?line {ok, Handle1a} = ?FILE_MODULE:open(Name1, [raw, read]),
-    ?line {ok, Handle2a} = ?FILE_MODULE:open(Name2, [raw, read]),
-    ?line true = stream_cmp(fd_stream_factory([Handle1a]), 
-			    fd_stream_factory([Handle2a])),
-    ?line {ok, 0} = ?FILE_MODULE:position(Handle1a, 0),
-    ?line {ok, 0} = ?FILE_MODULE:position(Handle2a, 0),
-    ?line {ok, Handle3a} = ?FILE_MODULE:open(Name3, [raw, read]),
-    ?line true = stream_cmp(fd_stream_factory([Handle1a, Handle2a]), 
-			    fd_stream_factory([Handle2a])),
-    ?line ok = ?FILE_MODULE:close(Handle1a),
-    ?line ok = ?FILE_MODULE:close(Handle2a),
-    ?line ok = ?FILE_MODULE:close(Handle3a),
-    ?line [] = flush(),
+    {ok, Handle1a} = ?FILE_MODULE:open(Name1, [raw, read]),
+    {ok, Handle2a} = ?FILE_MODULE:open(Name2, [raw, read]),
+    true = stream_cmp(fd_stream_factory([Handle1a]),
+		      fd_stream_factory([Handle2a])),
+    {ok, 0} = ?FILE_MODULE:position(Handle1a, 0),
+    {ok, 0} = ?FILE_MODULE:position(Handle2a, 0),
+    {ok, Handle3a} = ?FILE_MODULE:open(Name3, [raw, read]),
+    true = stream_cmp(fd_stream_factory([Handle1a, Handle2a]),
+		      fd_stream_factory([Handle2a])),
+    ok = ?FILE_MODULE:close(Handle1a),
+    ok = ?FILE_MODULE:close(Handle2a),
+    ok = ?FILE_MODULE:close(Handle3a),
+    [] = flush(),
     ok.
 
 
@@ -2809,7 +2809,7 @@ fd_stream_factory([Fd | T] = L) ->
 	    end
     end.
 
-		    
+
 
 stream_cmp(F1, F2) when is_function(F1), is_function(F2) ->
     stream_cmp(F1(), F2());
@@ -2834,66 +2834,66 @@ stream_cmp([H | T1], [H | T2]) ->
 
 %% Test the get_cwd(), open(), and copy() file server calls.
 new_slave(_RootDir, Cwd) ->
-    ?line L = "qwertyuiopasdfghjklzxcvbnm",
-    ?line N = length(L),
-    ?line {ok, Cwd}         = ?FILE_MODULE:get_cwd(),
-    ?line {error, enotsup}  = ?FILE_MODULE:get_cwd("C:"), % Unix only testcase
-    ?line {ok, FD1}         = ?FILE_MODULE:open("file1.txt", write),
-    ?line ok                = ?FILE_MODULE:close(FD1),
-    ?line {ok, FD2}         = ?FILE_MODULE:open("file1.txt", 
-						[write, append, 
-						 binary, compressed,
-						 delayed_write,
-						 {delayed_write, 0, 0},
-						 read_ahead,
-						 {read_ahead, 0}]),
-    ?line ok                = ?FILE_MODULE:write(FD2, L),
-    ?line ok                = ?FILE_MODULE:close(FD2),
-    ?line {ok, N2}          = ?FILE_MODULE:copy("file1.txt", "file2.txt"),
-    ?line io:format("Size ~p, compressed ~p.~n", [N, N2]),
-    ?line {ok, FD3}         = ?FILE_MODULE:open("file2.txt", 
-						[binary, compressed]),
+    L = "qwertyuiopasdfghjklzxcvbnm",
+    N = length(L),
+    {ok, Cwd}         = ?FILE_MODULE:get_cwd(),
+    {error, enotsup}  = ?FILE_MODULE:get_cwd("C:"), % Unix only testcase
+    {ok, FD1}         = ?FILE_MODULE:open("file1.txt", write),
+    ok                = ?FILE_MODULE:close(FD1),
+    {ok, FD2}         = ?FILE_MODULE:open("file1.txt",
+					  [write, append,
+					   binary, compressed,
+					   delayed_write,
+					   {delayed_write, 0, 0},
+					   read_ahead,
+					   {read_ahead, 0}]),
+    ok                = ?FILE_MODULE:write(FD2, L),
+    ok                = ?FILE_MODULE:close(FD2),
+    {ok, N2}          = ?FILE_MODULE:copy("file1.txt", "file2.txt"),
+    io:format("Size ~p, compressed ~p.~n", [N, N2]),
+    {ok, FD3}         = ?FILE_MODULE:open("file2.txt",
+					  [binary, compressed]),
     %% The file_io_server will translate the binary into a list
-    ?line {ok, L}           = ?FILE_MODULE:read(FD3, N+1),
-    ?line ok                = ?FILE_MODULE:close(FD3),
+    {ok, L}           = ?FILE_MODULE:read(FD3, N+1),
+    ok                = ?FILE_MODULE:close(FD3),
     %%
-    ?line ok                = ?FILE_MODULE:delete("file1.txt"),
-    ?line ok                = ?FILE_MODULE:delete("file2.txt"),
-    ?line []                = flush(),
+    ok                = ?FILE_MODULE:delete("file1.txt"),
+    ok                = ?FILE_MODULE:delete("file2.txt"),
+    []                = flush(),
     ok.
 
 
 %% Test the get_cwd() and open() file server calls.
 old_slave(_RootDir, Cwd) ->
-    ?line L = "qwertyuiopasdfghjklzxcvbnm",
-    ?line N = length(L),
-    ?line {ok, Cwd}         = ?FILE_MODULE:get_cwd(),
-    ?line {error, enotsup}  = ?FILE_MODULE:get_cwd("C:"), % Unix only testcase
-    ?line {ok, FD1}         = ?FILE_MODULE:open("file1.txt", write),
-    ?line ok                = ?FILE_MODULE:close(FD1),
-    ?line {ok, FD2}         = ?FILE_MODULE:open("file1.txt", 
-						[write, binary, compressed]),
-    ?line ok                = ?FILE_MODULE:write(FD2, L),
-    ?line ok                = ?FILE_MODULE:close(FD2),
-    ?line {ok, FD3}         = ?FILE_MODULE:open("file1.txt", [write, append]),
-    ?line ok                = ?FILE_MODULE:close(FD3),
-    ?line {ok, FD4}         = ?FILE_MODULE:open("file1.txt", 
-						[binary, compressed]),
+    L = "qwertyuiopasdfghjklzxcvbnm",
+    N = length(L),
+    {ok, Cwd}         = ?FILE_MODULE:get_cwd(),
+    {error, enotsup}  = ?FILE_MODULE:get_cwd("C:"), % Unix only testcase
+    {ok, FD1}         = ?FILE_MODULE:open("file1.txt", write),
+    ok                = ?FILE_MODULE:close(FD1),
+    {ok, FD2}         = ?FILE_MODULE:open("file1.txt",
+					  [write, binary, compressed]),
+    ok                = ?FILE_MODULE:write(FD2, L),
+    ok                = ?FILE_MODULE:close(FD2),
+    {ok, FD3}         = ?FILE_MODULE:open("file1.txt", [write, append]),
+    ok                = ?FILE_MODULE:close(FD3),
+    {ok, FD4}         = ?FILE_MODULE:open("file1.txt",
+					  [binary, compressed]),
     %% The file_io_server will translate the binary into a list
-    ?line {ok, L}           = ?FILE_MODULE:read(FD4, N+1),
-    ?line ok                = ?FILE_MODULE:close(FD4),
+    {ok, L}           = ?FILE_MODULE:read(FD4, N+1),
+    ok                = ?FILE_MODULE:close(FD4),
     %%
-    ?line ok                = ?FILE_MODULE:delete("file1.txt"),
-    ?line []                = flush(),
+    ok                = ?FILE_MODULE:delete("file1.txt"),
+    []                = flush(),
     ok.
 
 run_test(Test, Args) ->
-    ?line case (catch apply(?MODULE, Test, Args)) of
-	      {'EXIT', _} = Exit ->
-		  {done, Exit, get(test_server_loc)};
-	      Result ->
-		  {done, Result}
-	  end.
+    case (catch apply(?MODULE, Test, Args)) of
+	{'EXIT', _} = Exit ->
+	    {done, Exit, get(test_server_loc)};
+	Result ->
+	    {done, Result}
+    end.
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
@@ -2902,7 +2902,7 @@ run_test(Test, Args) ->
 delayed_write(Config) when is_list(Config) ->
     RootDir = proplists:get_value(priv_dir, Config),
     File = filename:join(RootDir, 
-          	       atom_to_list(?MODULE)++"_delayed_write.txt"),
+			 atom_to_list(?MODULE)++"_delayed_write.txt"),
     Data1 = "asdfghjkl",
     Data2 = "qwertyuio",
     Data3 = "zxcvbnm,.",
@@ -2936,24 +2936,24 @@ delayed_write(Config) when is_list(Config) ->
     %% raw file, default parameters.
     Parent = self(),
     Fun = fun() ->
-	    Child = self(),
-	    Test = 
-	    fun () ->
-		    {ok, Fd} = ?FILE_MODULE:open(File, 
-			[raw, write, delayed_write]),
-		    ok = ?FILE_MODULE:write(Fd, Data1),
-		    Parent ! {Child, wrote},
-		    receive 
-			{Parent, continue, Reason} -> 
-			    {ok, Reason}
-		    end
-	    end,
-	    case (catch Test()) of
-		{ok, Reason} -> exit(Reason);
-		Unknown ->
-		    exit({Unknown, get(test_server_loc)})
-	    end
-    end,
+		  Child = self(),
+		  Test =
+		      fun () ->
+			      {ok, Fd} = ?FILE_MODULE:open(File,
+							   [raw, write, delayed_write]),
+			      ok = ?FILE_MODULE:write(Fd, Data1),
+			      Parent ! {Child, wrote},
+			      receive
+				  {Parent, continue, Reason} ->
+				      {ok, Reason}
+			      end
+		      end,
+		  case (catch Test()) of
+		      {ok, Reason} -> exit(Reason);
+		      Unknown ->
+			  exit({Unknown, get(test_server_loc)})
+		  end
+	  end,
     Child1 = spawn(Fun),
     Mref1 = erlang:monitor(process, Child1),
     receive 
@@ -3001,7 +3001,7 @@ delayed_write(Config) when is_list(Config) ->
     %%
     %% Test if file position works with delayed_write
     {ok, Fd5} = ?FILE_MODULE:open(File, [raw, read, write, 
-          			       delayed_write]),
+					 delayed_write]),
     ok = ?FILE_MODULE:truncate(Fd5),
     ok = ?FILE_MODULE:write(Fd5, [Data1|Data2]),
     {ok, 0} = ?FILE_MODULE:position(Fd5, bof),
@@ -3019,18 +3019,18 @@ delayed_write(Config) when is_list(Config) ->
 %% Tests file:pid2name/1.
 pid2name(Config) when is_list(Config) ->
     RootDir = proplists:get_value(priv_dir, Config),
-    ?line Base = test_server:temp_name(
-		   filename:join(RootDir, "pid2name_")),
-    ?line Name1 = [Base, '.txt'],
-    ?line Name2 = Base ++ ".txt",
+    Base = test_server:temp_name(
+	     filename:join(RootDir, "pid2name_")),
+    Name1 = [Base, '.txt'],
+    Name2 = Base ++ ".txt",
     %%
-    ?line {ok, Pid} = file:open(Name1, [write]),
-    ?line {ok, Name2} = file:pid2name(Pid),
-    ?line undefined = file:pid2name(self()),
-    ?line ok = file:close(Pid),
+    {ok, Pid} = file:open(Name1, [write]),
+    {ok, Name2} = file:pid2name(Pid),
+    undefined = file:pid2name(self()),
+    ok = file:close(Pid),
     ct:sleep(1000),
-    ?line false = is_process_alive(Pid),
-    ?line undefined = file:pid2name(Pid),
+    false = is_process_alive(Pid),
+    undefined = file:pid2name(Pid),
     ok.
 
 
@@ -3040,55 +3040,55 @@ pid2name(Config) when is_list(Config) ->
 
 read_ahead(Config) when is_list(Config) ->
     RootDir = proplists:get_value(priv_dir, Config),
-    ?line File = filename:join(RootDir, 
-			       atom_to_list(?MODULE)++"_read_ahead.txt"),
-    ?line Data1 = "asdfghjkl", % Must be
-    ?line Data2 = "qwertyuio", % same
-    ?line Data3 = "zxcvbnm,.", % length
-    ?line Size = length(Data1),
-    ?line Size = length(Data2),
-    ?line Size = length(Data3),
+    File = filename:join(RootDir,
+			 atom_to_list(?MODULE)++"_read_ahead.txt"),
+    Data1 = "asdfghjkl", % Must be
+    Data2 = "qwertyuio", % same
+    Data3 = "zxcvbnm,.", % length
+    Size = length(Data1),
+    Size = length(Data2),
+    Size = length(Data3),
     %%
     %% Test caching of normal non-raw file
-    ?line {ok, Fd1} = ?FILE_MODULE:open(File, [write]),
-    ?line ok = ?FILE_MODULE:write(Fd1, [Data1|Data1]),
+    {ok, Fd1} = ?FILE_MODULE:open(File, [write]),
+    ok = ?FILE_MODULE:write(Fd1, [Data1|Data1]),
     timer:sleep(1000), % Just in case the file system is slow
-    ?line {ok, Fd2} = ?FILE_MODULE:open(File, [read, {read_ahead, 2*Size}]),
-    ?line {ok, Data1} = ?FILE_MODULE:read(Fd2, Size),
-    ?line ok = ?FILE_MODULE:pwrite(Fd1, Size, Data2),
+    {ok, Fd2} = ?FILE_MODULE:open(File, [read, {read_ahead, 2*Size}]),
+    {ok, Data1} = ?FILE_MODULE:read(Fd2, Size),
+    ok = ?FILE_MODULE:pwrite(Fd1, Size, Data2),
     timer:sleep(1000), % Just in case the file system is slow
-    ?line {ok, Data1} = ?FILE_MODULE:read(Fd2, Size), % Will read cached data
-    ?line Data2Data2Data2 = Data2++Data2++Data2,
-    ?line ok = ?FILE_MODULE:pwrite(Fd1, eof, Data2Data2Data2),
+    {ok, Data1} = ?FILE_MODULE:read(Fd2, Size), % Will read cached data
+    Data2Data2Data2 = Data2++Data2++Data2,
+    ok = ?FILE_MODULE:pwrite(Fd1, eof, Data2Data2Data2),
     timer:sleep(1000), % Just in case the file system is slow
-    ?line {ok, Data2Data2Data2} = 
+    {ok, Data2Data2Data2} =
 	?FILE_MODULE:read(Fd2, 3*Size), % Read more than cache buffer
-    ?line ok = ?FILE_MODULE:close(Fd1),
-    ?line ok = ?FILE_MODULE:close(Fd2),
+    ok = ?FILE_MODULE:close(Fd1),
+    ok = ?FILE_MODULE:close(Fd2),
     %% Test caching of raw file and default parameters
-    ?line {ok, Fd3} = ?FILE_MODULE:open(File, [raw, write]),
-    ?line ok = ?FILE_MODULE:write(Fd3, [Data1|Data1]),
+    {ok, Fd3} = ?FILE_MODULE:open(File, [raw, write]),
+    ok = ?FILE_MODULE:write(Fd3, [Data1|Data1]),
     timer:sleep(1000), % Just in case the file system is slow
-    ?line {ok, Fd4} = ?FILE_MODULE:open(File, [raw, read, read_ahead]),
-    ?line {ok, Data1} = ?FILE_MODULE:read(Fd4, Size),
-    ?line ok = ?FILE_MODULE:pwrite(Fd3, Size, Data2),
+    {ok, Fd4} = ?FILE_MODULE:open(File, [raw, read, read_ahead]),
+    {ok, Data1} = ?FILE_MODULE:read(Fd4, Size),
+    ok = ?FILE_MODULE:pwrite(Fd3, Size, Data2),
     timer:sleep(1000), % Just in case the file system is slow
-    ?line {ok, Data1} = ?FILE_MODULE:read(Fd4, Size), % Will read cached data
-    ?line ok = ?FILE_MODULE:close(Fd3),
-    ?line ok = ?FILE_MODULE:close(Fd4),
+    {ok, Data1} = ?FILE_MODULE:read(Fd4, Size), % Will read cached data
+    ok = ?FILE_MODULE:close(Fd3),
+    ok = ?FILE_MODULE:close(Fd4),
     %% Test if the file position works in combination with read_ahead
-    ?line {ok, Fd5} = ?FILE_MODULE:open(File, [raw, read, write, read_ahead]),
-    ?line ok = ?FILE_MODULE:truncate(Fd5),
-    ?line ok = ?FILE_MODULE:write(Fd5, [Data1,Data1|Data3]),
-    ?line {ok, 0} = ?FILE_MODULE:position(Fd5, bof),
-    ?line {ok, Data1} = ?FILE_MODULE:read(Fd5, Size),
-    ?line ok = ?FILE_MODULE:write(Fd5, Data2),
-    ?line {ok, 0} = ?FILE_MODULE:position(Fd5, bof),
-    ?line Data1Data2Data3 = Data1++Data2++Data3,
-    ?line {ok, Data1Data2Data3} = ?FILE_MODULE:read(Fd5, 3*Size+1),
-    ?line ok = ?FILE_MODULE:close(Fd5),
+    {ok, Fd5} = ?FILE_MODULE:open(File, [raw, read, write, read_ahead]),
+    ok = ?FILE_MODULE:truncate(Fd5),
+    ok = ?FILE_MODULE:write(Fd5, [Data1,Data1|Data3]),
+    {ok, 0} = ?FILE_MODULE:position(Fd5, bof),
+    {ok, Data1} = ?FILE_MODULE:read(Fd5, Size),
+    ok = ?FILE_MODULE:write(Fd5, Data2),
+    {ok, 0} = ?FILE_MODULE:position(Fd5, bof),
+    Data1Data2Data3 = Data1++Data2++Data3,
+    {ok, Data1Data2Data3} = ?FILE_MODULE:read(Fd5, 3*Size+1),
+    ok = ?FILE_MODULE:close(Fd5),
     %%
-    ?line [] = flush(),
+    [] = flush(),
     ok.
 
 
@@ -3100,128 +3100,128 @@ read_ahead(Config) when is_list(Config) ->
 %% Tests the segmenting of large reads.
 segment_read(Config) when is_list(Config) ->
     Name = filename:join(proplists:get_value(priv_dir, Config),
-			       ?MODULE_STRING ++ "_segment_read"),
-    ?line SegSize = 256*1024,
-    ?line SegCnt = SegSize div 4,
-    ?line Cnt = 4 * SegCnt,
-    ?line ok = create_file(Name, Cnt),
+			 ?MODULE_STRING ++ "_segment_read"),
+    SegSize = 256*1024,
+    SegCnt = SegSize div 4,
+    Cnt = 4 * SegCnt,
+    ok = create_file(Name, Cnt),
     %% 
     %% read_file/1
     %%
-    ?line {ok, Bin} = ?FILE_MODULE:read_file(Name),
-    ?line true = verify_bin(Bin, 0, Cnt),
+    {ok, Bin} = ?FILE_MODULE:read_file(Name),
+    true = verify_bin(Bin, 0, Cnt),
     %%
     %% read/2
     %%
     %% Not segmented
-    ?line {ok, FD1} = ?FILE_MODULE:open(Name, [read, raw, binary]),
-    ?line {ok, B1a} = ?FILE_MODULE:read(FD1, SegSize),
-    ?line {ok, B1b} = ?FILE_MODULE:read(FD1, SegSize),
-    ?line {ok, B1c} = ?FILE_MODULE:read(FD1, SegSize),
-    ?line {ok, B1d} = ?FILE_MODULE:read(FD1, SegSize),
-    ?line ok = ?FILE_MODULE:close(FD1),
-    ?line true = verify_bin(B1a, 0*SegCnt, SegCnt),
-    ?line true = verify_bin(B1b, 1*SegCnt, SegCnt),
-    ?line true = verify_bin(B1c, 2*SegCnt, SegCnt),
-    ?line true = verify_bin(B1d, 3*SegCnt, SegCnt),
+    {ok, FD1} = ?FILE_MODULE:open(Name, [read, raw, binary]),
+    {ok, B1a} = ?FILE_MODULE:read(FD1, SegSize),
+    {ok, B1b} = ?FILE_MODULE:read(FD1, SegSize),
+    {ok, B1c} = ?FILE_MODULE:read(FD1, SegSize),
+    {ok, B1d} = ?FILE_MODULE:read(FD1, SegSize),
+    ok = ?FILE_MODULE:close(FD1),
+    true = verify_bin(B1a, 0*SegCnt, SegCnt),
+    true = verify_bin(B1b, 1*SegCnt, SegCnt),
+    true = verify_bin(B1c, 2*SegCnt, SegCnt),
+    true = verify_bin(B1d, 3*SegCnt, SegCnt),
     %%
     %% Segmented
-    ?line {ok, FD2} = ?FILE_MODULE:open(Name, [read, raw, binary]),
-    ?line {ok, B2a} = ?FILE_MODULE:read(FD2, 1*SegSize),
-    ?line {ok, B2b} = ?FILE_MODULE:read(FD2, 2*SegSize),
-    ?line {ok, B2c} = ?FILE_MODULE:read(FD2, 2*SegSize),
-    ?line ok = ?FILE_MODULE:close(FD2),
-    ?line true = verify_bin(B2a, 0*SegCnt, 1*SegCnt),
-    ?line true = verify_bin(B2b, 1*SegCnt, 2*SegCnt),
-    ?line true = verify_bin(B2c, 3*SegCnt, 1*SegCnt),
+    {ok, FD2} = ?FILE_MODULE:open(Name, [read, raw, binary]),
+    {ok, B2a} = ?FILE_MODULE:read(FD2, 1*SegSize),
+    {ok, B2b} = ?FILE_MODULE:read(FD2, 2*SegSize),
+    {ok, B2c} = ?FILE_MODULE:read(FD2, 2*SegSize),
+    ok = ?FILE_MODULE:close(FD2),
+    true = verify_bin(B2a, 0*SegCnt, 1*SegCnt),
+    true = verify_bin(B2b, 1*SegCnt, 2*SegCnt),
+    true = verify_bin(B2c, 3*SegCnt, 1*SegCnt),
     %%
     %% pread/3
     %%
-    ?line {ok, FD3} = ?FILE_MODULE:open(Name, [read, raw, binary]),
+    {ok, FD3} = ?FILE_MODULE:open(Name, [read, raw, binary]),
     %%
     %% Not segmented
-    ?line {ok, B3d} = ?FILE_MODULE:pread(FD3, 3*SegSize, SegSize),
-    ?line {ok, B3c} = ?FILE_MODULE:pread(FD3, 2*SegSize, SegSize),
-    ?line {ok, B3b} = ?FILE_MODULE:pread(FD3, 1*SegSize, SegSize),
-    ?line {ok, B3a} = ?FILE_MODULE:pread(FD3, 0*SegSize, SegSize),
-    ?line true = verify_bin(B3a, 0*SegCnt, SegCnt),
-    ?line true = verify_bin(B3b, 1*SegCnt, SegCnt),
-    ?line true = verify_bin(B3c, 2*SegCnt, SegCnt),
-    ?line true = verify_bin(B3d, 3*SegCnt, SegCnt),
+    {ok, B3d} = ?FILE_MODULE:pread(FD3, 3*SegSize, SegSize),
+    {ok, B3c} = ?FILE_MODULE:pread(FD3, 2*SegSize, SegSize),
+    {ok, B3b} = ?FILE_MODULE:pread(FD3, 1*SegSize, SegSize),
+    {ok, B3a} = ?FILE_MODULE:pread(FD3, 0*SegSize, SegSize),
+    true = verify_bin(B3a, 0*SegCnt, SegCnt),
+    true = verify_bin(B3b, 1*SegCnt, SegCnt),
+    true = verify_bin(B3c, 2*SegCnt, SegCnt),
+    true = verify_bin(B3d, 3*SegCnt, SegCnt),
     %%
     %% Segmented
-    ?line {ok, B3g} = ?FILE_MODULE:pread(FD3, 3*SegSize, 2*SegSize),
-    ?line {ok, B3f} = ?FILE_MODULE:pread(FD3, 1*SegSize, 2*SegSize),
-    ?line {ok, B3e} = ?FILE_MODULE:pread(FD3, 0*SegSize, 1*SegSize),
-    ?line true = verify_bin(B3e, 0*SegCnt, 1*SegCnt),
-    ?line true = verify_bin(B3f, 1*SegCnt, 2*SegCnt),
-    ?line true = verify_bin(B3g, 3*SegCnt, 1*SegCnt),
+    {ok, B3g} = ?FILE_MODULE:pread(FD3, 3*SegSize, 2*SegSize),
+    {ok, B3f} = ?FILE_MODULE:pread(FD3, 1*SegSize, 2*SegSize),
+    {ok, B3e} = ?FILE_MODULE:pread(FD3, 0*SegSize, 1*SegSize),
+    true = verify_bin(B3e, 0*SegCnt, 1*SegCnt),
+    true = verify_bin(B3f, 1*SegCnt, 2*SegCnt),
+    true = verify_bin(B3g, 3*SegCnt, 1*SegCnt),
     %%
-    ?line ok = ?FILE_MODULE:close(FD3),
+    ok = ?FILE_MODULE:close(FD3),
     %%
     %% pread/2
     %%
-    ?line {ok, FD5} = ?FILE_MODULE:open(Name, [read, raw, binary]),
+    {ok, FD5} = ?FILE_MODULE:open(Name, [read, raw, binary]),
     %%
     %% +---+---+---+---+
     %% | 4 | 3 | 2 | 1 |
     %% +---+---+---+---+
     %% <       ^       >
-    ?line {ok, [B5d, B5c, B5b, B5a]} = 
+    {ok, [B5d, B5c, B5b, B5a]} =
 	?FILE_MODULE:pread(FD5, [{3*SegSize, SegSize},
 				 {2*SegSize, SegSize},
 				 {1*SegSize, SegSize},
 				 {0*SegSize, SegSize}]),
-    ?line true = verify_bin(B5a, 0*SegCnt, SegCnt),
-    ?line true = verify_bin(B5b, 1*SegCnt, SegCnt),
-    ?line true = verify_bin(B5c, 2*SegCnt, SegCnt),
-    ?line true = verify_bin(B5d, 3*SegCnt, SegCnt),
+    true = verify_bin(B5a, 0*SegCnt, SegCnt),
+    true = verify_bin(B5b, 1*SegCnt, SegCnt),
+    true = verify_bin(B5c, 2*SegCnt, SegCnt),
+    true = verify_bin(B5d, 3*SegCnt, SegCnt),
     %%
     %% +---+-------+-------+
     %% | 3 |   2   |   1   |
     %% +---+-------+-------+
     %% <     ^     ^   >
-    ?line {ok, [B5g, B5f, B5e]} = 
+    {ok, [B5g, B5f, B5e]} =
 	?FILE_MODULE:pread(FD5, [{3*SegSize, 2*SegSize},
 				 {1*SegSize, 2*SegSize},
 				 {0*SegSize, 1*SegSize}]),
-    ?line true = verify_bin(B5e, 0*SegCnt, 1*SegCnt),
-    ?line true = verify_bin(B5f, 1*SegCnt, 2*SegCnt),
-    ?line true = verify_bin(B5g, 3*SegCnt, 1*SegCnt),
+    true = verify_bin(B5e, 0*SegCnt, 1*SegCnt),
+    true = verify_bin(B5f, 1*SegCnt, 2*SegCnt),
+    true = verify_bin(B5g, 3*SegCnt, 1*SegCnt),
     %%
     %%
     %% +-------+-----------+
     %% |   2   |     1     |
     %% +-------+-----------+
     %% <     ^     ^   >
-    ?line {ok, [B5i, B5h]} = 
+    {ok, [B5i, B5h]} =
 	?FILE_MODULE:pread(FD5, [{2*SegSize, 3*SegSize},
 				 {0*SegSize, 2*SegSize}]),
-    ?line true = verify_bin(B5h, 0*SegCnt, 2*SegCnt),
-    ?line true = verify_bin(B5i, 2*SegCnt, 2*SegCnt),
+    true = verify_bin(B5h, 0*SegCnt, 2*SegCnt),
+    true = verify_bin(B5i, 2*SegCnt, 2*SegCnt),
     %%
     %% +-------+---+---+
     %% |   3   | 2 | 1 |
     %% +-------+---+---+
     %% <     ^     ^   >
-    ?line {ok, [B5l, B5k, B5j]} = 
+    {ok, [B5l, B5k, B5j]} =
 	?FILE_MODULE:pread(FD5, [{3*SegSize, 1*SegSize},
 				 {2*SegSize, 1*SegSize},
 				 {0*SegSize, 2*SegSize}]),
-    ?line true = verify_bin(B5j, 0*SegCnt, 2*SegCnt),
-    ?line true = verify_bin(B5k, 2*SegCnt, 1*SegCnt),
-    ?line true = verify_bin(B5l, 3*SegCnt, 1*SegCnt),
+    true = verify_bin(B5j, 0*SegCnt, 2*SegCnt),
+    true = verify_bin(B5k, 2*SegCnt, 1*SegCnt),
+    true = verify_bin(B5l, 3*SegCnt, 1*SegCnt),
     %%
     %% Real time response time test.
     %%
     Req = lists:flatten(lists:duplicate(17,
 					[{2*SegSize, 2*SegSize},
 					 {0*SegSize, 2*SegSize}])),
-    ?line {{ok, _}, Comment} = 
+    {{ok, _}, Comment} =
 	response_analysis(?FILE_MODULE, pread, [FD5, Req]),
-    ?line ok = ?FILE_MODULE:close(FD5),
+    ok = ?FILE_MODULE:close(FD5),
     %%
-    ?line [] = flush(),
+    [] = flush(),
     {comment, Comment}.
 
 
@@ -3233,92 +3233,92 @@ segment_read(Config) when is_list(Config) ->
 %% Tests the segmenting of large writes.
 segment_write(Config) when is_list(Config) ->
     Name = filename:join(proplists:get_value(priv_dir, Config),
-			       ?MODULE_STRING ++ "_segment_write"),
-    ?line SegSize = 256*1024,
-    ?line SegCnt = SegSize div 4,
-    ?line Cnt = 4 * SegCnt,
-    ?line Bin = create_bin(0, Cnt),
+			 ?MODULE_STRING ++ "_segment_write"),
+    SegSize = 256*1024,
+    SegCnt = SegSize div 4,
+    Cnt = 4 * SegCnt,
+    Bin = create_bin(0, Cnt),
     %%
     %% write/2
     %%
     %% Not segmented
-    ?line {ok, FD1} = ?FILE_MODULE:open(Name, [write, raw, binary]),
-    ?line ok = ?FILE_MODULE:write(FD1, subbin(Bin, 0*SegSize, 1*SegSize)),
-    ?line ok = ?FILE_MODULE:write(FD1, subbin(Bin, 1*SegSize, 1*SegSize)),
-    ?line ok = ?FILE_MODULE:write(FD1, subbin(Bin, 2*SegSize, 1*SegSize)),
-    ?line ok = ?FILE_MODULE:write(FD1, subbin(Bin, 3*SegSize, 1*SegSize)),
-    ?line ok = ?FILE_MODULE:close(FD1),
-    ?line true = verify_file(Name, Cnt),
+    {ok, FD1} = ?FILE_MODULE:open(Name, [write, raw, binary]),
+    ok = ?FILE_MODULE:write(FD1, subbin(Bin, 0*SegSize, 1*SegSize)),
+    ok = ?FILE_MODULE:write(FD1, subbin(Bin, 1*SegSize, 1*SegSize)),
+    ok = ?FILE_MODULE:write(FD1, subbin(Bin, 2*SegSize, 1*SegSize)),
+    ok = ?FILE_MODULE:write(FD1, subbin(Bin, 3*SegSize, 1*SegSize)),
+    ok = ?FILE_MODULE:close(FD1),
+    true = verify_file(Name, Cnt),
     %%
     %% Segmented
-    ?line {ok, FD2} = ?FILE_MODULE:open(Name, [write, raw, binary]),
-    ?line ok = ?FILE_MODULE:write(FD2, subbin(Bin, 0*SegSize, 1*SegSize)),
-    ?line ok = ?FILE_MODULE:write(FD2, subbin(Bin, 1*SegSize, 2*SegSize)),
-    ?line ok = ?FILE_MODULE:write(FD2, subbin(Bin, 3*SegSize, 1*SegSize)),
-    ?line ok = ?FILE_MODULE:close(FD2),
-    ?line true = verify_file(Name, Cnt),
+    {ok, FD2} = ?FILE_MODULE:open(Name, [write, raw, binary]),
+    ok = ?FILE_MODULE:write(FD2, subbin(Bin, 0*SegSize, 1*SegSize)),
+    ok = ?FILE_MODULE:write(FD2, subbin(Bin, 1*SegSize, 2*SegSize)),
+    ok = ?FILE_MODULE:write(FD2, subbin(Bin, 3*SegSize, 1*SegSize)),
+    ok = ?FILE_MODULE:close(FD2),
+    true = verify_file(Name, Cnt),
     %%
     %% +---+---+---+---+
     %% |   |   |   |   |
     %% +---+---+---+---+
     %% <       ^       >
-    ?line ok = write_file(Name, [subbin(Bin, 0*SegSize, 1*SegSize),
-				 subbin(Bin, 1*SegSize, 1*SegSize),
-				 subbin(Bin, 2*SegSize, 1*SegSize),
-				 subbin(Bin, 3*SegSize, 1*SegSize)]),
-    ?line true = verify_file(Name, Cnt),
+    ok = write_file(Name, [subbin(Bin, 0*SegSize, 1*SegSize),
+			   subbin(Bin, 1*SegSize, 1*SegSize),
+			   subbin(Bin, 2*SegSize, 1*SegSize),
+			   subbin(Bin, 3*SegSize, 1*SegSize)]),
+    true = verify_file(Name, Cnt),
     %%
     %% +---+-------+---+
     %% |   |       |   |
     %% +---+-------+---+
     %% <     ^     ^   >
-    ?line ok = write_file(Name, [subbin(Bin, 0*SegSize, 1*SegSize),
-				 subbin(Bin, 1*SegSize, 2*SegSize),
-				 subbin(Bin, 3*SegSize, 1*SegSize)]),
-    ?line true = verify_file(Name, Cnt),
+    ok = write_file(Name, [subbin(Bin, 0*SegSize, 1*SegSize),
+			   subbin(Bin, 1*SegSize, 2*SegSize),
+			   subbin(Bin, 3*SegSize, 1*SegSize)]),
+    true = verify_file(Name, Cnt),
     %%
     %% +-------+-------+
     %% |       |       |
     %% +-------+-------+
     %% <     ^     ^   >
-    ?line ok = write_file(Name, [subbin(Bin, 0*SegSize, 2*SegSize),
-				 subbin(Bin, 2*SegSize, 2*SegSize)]),
-    ?line true = verify_file(Name, Cnt),
+    ok = write_file(Name, [subbin(Bin, 0*SegSize, 2*SegSize),
+			   subbin(Bin, 2*SegSize, 2*SegSize)]),
+    true = verify_file(Name, Cnt),
     %%
     %% +-------+---+---+
     %% |       |   |   |
     %% +-------+---+---+
     %% <     ^     ^   >
-    ?line ok = write_file(Name, [subbin(Bin, 0*SegSize, 2*SegSize),
-				 subbin(Bin, 2*SegSize, 1*SegSize),
-				 subbin(Bin, 3*SegSize, 1*SegSize)]),
-    ?line true = verify_file(Name, Cnt),
+    ok = write_file(Name, [subbin(Bin, 0*SegSize, 2*SegSize),
+			   subbin(Bin, 2*SegSize, 1*SegSize),
+			   subbin(Bin, 3*SegSize, 1*SegSize)]),
+    true = verify_file(Name, Cnt),
     %%
     %% pwrite/3
     %%
     %% Not segmented
-    ?line {ok, FD3} = ?FILE_MODULE:open(Name, [write, raw, binary]),
-    ?line ok = ?FILE_MODULE:pwrite(FD3, 3*SegSize, 
-				   subbin(Bin, 3*SegSize, 1*SegSize)),
-    ?line ok = ?FILE_MODULE:pwrite(FD3, 2*SegSize, 
-				   subbin(Bin, 2*SegSize, 1*SegSize)),
-    ?line ok = ?FILE_MODULE:pwrite(FD3, 1*SegSize, 
-				   subbin(Bin, 1*SegSize, 1*SegSize)),
-    ?line ok = ?FILE_MODULE:pwrite(FD3, 0*SegSize, 
-				   subbin(Bin, 0*SegSize, 1*SegSize)),
-    ?line ok = ?FILE_MODULE:close(FD3),
-    ?line true = verify_file(Name, Cnt),
+    {ok, FD3} = ?FILE_MODULE:open(Name, [write, raw, binary]),
+    ok = ?FILE_MODULE:pwrite(FD3, 3*SegSize,
+			     subbin(Bin, 3*SegSize, 1*SegSize)),
+    ok = ?FILE_MODULE:pwrite(FD3, 2*SegSize,
+			     subbin(Bin, 2*SegSize, 1*SegSize)),
+    ok = ?FILE_MODULE:pwrite(FD3, 1*SegSize,
+			     subbin(Bin, 1*SegSize, 1*SegSize)),
+    ok = ?FILE_MODULE:pwrite(FD3, 0*SegSize,
+			     subbin(Bin, 0*SegSize, 1*SegSize)),
+    ok = ?FILE_MODULE:close(FD3),
+    true = verify_file(Name, Cnt),
     %%
     %% Segmented
-    ?line {ok, FD4} = ?FILE_MODULE:open(Name, [write, raw, binary]),
-    ?line ok = ?FILE_MODULE:pwrite(FD4, 3*SegSize, 
-				   subbin(Bin, 3*SegSize, 1*SegSize)),
-    ?line ok = ?FILE_MODULE:pwrite(FD4, 1*SegSize, 
-				   subbin(Bin, 1*SegSize, 2*SegSize)),
-    ?line ok = ?FILE_MODULE:pwrite(FD4, 0*SegSize, 
-				   subbin(Bin, 0*SegSize, 1*SegSize)),
-    ?line ok = ?FILE_MODULE:close(FD4),
-    ?line true = verify_file(Name, Cnt),
+    {ok, FD4} = ?FILE_MODULE:open(Name, [write, raw, binary]),
+    ok = ?FILE_MODULE:pwrite(FD4, 3*SegSize,
+			     subbin(Bin, 3*SegSize, 1*SegSize)),
+    ok = ?FILE_MODULE:pwrite(FD4, 1*SegSize,
+			     subbin(Bin, 1*SegSize, 2*SegSize)),
+    ok = ?FILE_MODULE:pwrite(FD4, 0*SegSize,
+			     subbin(Bin, 0*SegSize, 1*SegSize)),
+    ok = ?FILE_MODULE:close(FD4),
+    true = verify_file(Name, Cnt),
 
 
 
@@ -3326,90 +3326,90 @@ segment_write(Config) when is_list(Config) ->
     %% pwrite/2
     %%
     %% Not segmented
-    ?line {ok, FD5} = ?FILE_MODULE:open(Name, [write, raw, binary]),
-    ?line ok = ?FILE_MODULE:pwrite(FD5, [{3*SegSize,
-					  subbin(Bin, 3*SegSize, 1*SegSize)}]),
-    ?line ok = ?FILE_MODULE:pwrite(FD5, [{2*SegSize,
-					  subbin(Bin, 2*SegSize, 1*SegSize)}]),
-    ?line ok = ?FILE_MODULE:pwrite(FD5, [{1*SegSize,
-					  subbin(Bin, 1*SegSize, 1*SegSize)}]),
-    ?line ok = ?FILE_MODULE:pwrite(FD5, [{0*SegSize,
-					  subbin(Bin, 0*SegSize, 1*SegSize)}]),
-    ?line ok = ?FILE_MODULE:close(FD5),
-    ?line true = verify_file(Name, Cnt),
+    {ok, FD5} = ?FILE_MODULE:open(Name, [write, raw, binary]),
+    ok = ?FILE_MODULE:pwrite(FD5, [{3*SegSize,
+				    subbin(Bin, 3*SegSize, 1*SegSize)}]),
+    ok = ?FILE_MODULE:pwrite(FD5, [{2*SegSize,
+				    subbin(Bin, 2*SegSize, 1*SegSize)}]),
+    ok = ?FILE_MODULE:pwrite(FD5, [{1*SegSize,
+				    subbin(Bin, 1*SegSize, 1*SegSize)}]),
+    ok = ?FILE_MODULE:pwrite(FD5, [{0*SegSize,
+				    subbin(Bin, 0*SegSize, 1*SegSize)}]),
+    ok = ?FILE_MODULE:close(FD5),
+    true = verify_file(Name, Cnt),
     %%
     %% Segmented
-    ?line {ok, FD6} = ?FILE_MODULE:open(Name, [write, raw, binary]),
-    ?line ok = ?FILE_MODULE:pwrite(FD6, [{3*SegSize,
-					  subbin(Bin, 3*SegSize, 1*SegSize)}]),
-    ?line ok = ?FILE_MODULE:pwrite(FD6, [{1*SegSize,
-					  subbin(Bin, 1*SegSize, 2*SegSize)}]),
-    ?line ok = ?FILE_MODULE:pwrite(FD6, [{0*SegSize,
-					  subbin(Bin, 0*SegSize, 1*SegSize)}]),
-    ?line ok = ?FILE_MODULE:close(FD6),
-    ?line true = verify_file(Name, Cnt),
+    {ok, FD6} = ?FILE_MODULE:open(Name, [write, raw, binary]),
+    ok = ?FILE_MODULE:pwrite(FD6, [{3*SegSize,
+				    subbin(Bin, 3*SegSize, 1*SegSize)}]),
+    ok = ?FILE_MODULE:pwrite(FD6, [{1*SegSize,
+				    subbin(Bin, 1*SegSize, 2*SegSize)}]),
+    ok = ?FILE_MODULE:pwrite(FD6, [{0*SegSize,
+				    subbin(Bin, 0*SegSize, 1*SegSize)}]),
+    ok = ?FILE_MODULE:close(FD6),
+    true = verify_file(Name, Cnt),
     %%
     %% +---+---+---+---+
     %% | 4 | 3 | 2 | 1 |
     %% +---+---+---+---+
     %% <       ^       >
-    ?line ok = pwrite_file(Name, [{3*SegSize, 
-				   subbin(Bin, 3*SegSize, 1*SegSize)},
-				  {2*SegSize, 
-				   subbin(Bin, 2*SegSize, 1*SegSize)},
-				  {1*SegSize, 
-				   subbin(Bin, 1*SegSize, 1*SegSize)},
-				  {0*SegSize, 
-				   subbin(Bin, 0*SegSize, 1*SegSize)}]),
-    ?line true = verify_file(Name, Cnt),
+    ok = pwrite_file(Name, [{3*SegSize,
+			     subbin(Bin, 3*SegSize, 1*SegSize)},
+			    {2*SegSize,
+			     subbin(Bin, 2*SegSize, 1*SegSize)},
+			    {1*SegSize,
+			     subbin(Bin, 1*SegSize, 1*SegSize)},
+			    {0*SegSize,
+			     subbin(Bin, 0*SegSize, 1*SegSize)}]),
+    true = verify_file(Name, Cnt),
     %%
     %% +---+-------+---+
     %% | 3 |   2   | 1 |
     %% +---+-------+---+
     %% <     ^     ^   >
-    ?line ok = pwrite_file(Name, [{3*SegSize, 
-				   subbin(Bin, 3*SegSize, 1*SegSize)},
-				  {1*SegSize, 
-				   subbin(Bin, 1*SegSize, 2*SegSize)},
-				  {0*SegSize, 
-				   subbin(Bin, 0*SegSize, 1*SegSize)}]),
-    ?line true = verify_file(Name, Cnt),
+    ok = pwrite_file(Name, [{3*SegSize,
+			     subbin(Bin, 3*SegSize, 1*SegSize)},
+			    {1*SegSize,
+			     subbin(Bin, 1*SegSize, 2*SegSize)},
+			    {0*SegSize,
+			     subbin(Bin, 0*SegSize, 1*SegSize)}]),
+    true = verify_file(Name, Cnt),
     %%
     %% +-------+-------+
     %% |   2   |   1   |
     %% +-------+-------+
     %% <     ^     ^   >
-    ?line ok = pwrite_file(Name, [{2*SegSize, 
-				   subbin(Bin, 2*SegSize, 2*SegSize)},
-				  {0*SegSize, 
-				   subbin(Bin, 0*SegSize, 2*SegSize)}]),
-    ?line true = verify_file(Name, Cnt),
+    ok = pwrite_file(Name, [{2*SegSize,
+			     subbin(Bin, 2*SegSize, 2*SegSize)},
+			    {0*SegSize,
+			     subbin(Bin, 0*SegSize, 2*SegSize)}]),
+    true = verify_file(Name, Cnt),
     %%
     %% +-------+---+---+
     %% |   3   | 2 | 1 |
     %% +-------+---+---+
     %% <     ^     ^   >
-    ?line ok = pwrite_file(Name, [{3*SegSize, 
-				   subbin(Bin, 3*SegSize, 1*SegSize)},
-				  {2*SegSize, 
-				   subbin(Bin, 2*SegSize, 1*SegSize)},
-				  {0*SegSize, 
-				   subbin(Bin, 0*SegSize, 2*SegSize)}]),
-    ?line true = verify_file(Name, Cnt),
+    ok = pwrite_file(Name, [{3*SegSize,
+			     subbin(Bin, 3*SegSize, 1*SegSize)},
+			    {2*SegSize,
+			     subbin(Bin, 2*SegSize, 1*SegSize)},
+			    {0*SegSize,
+			     subbin(Bin, 0*SegSize, 2*SegSize)}]),
+    true = verify_file(Name, Cnt),
     %%
     %% Real time response time test.
     %%
-    ?line {ok, FD7} = ?FILE_MODULE:open(Name, [write, raw, binary]),
+    {ok, FD7} = ?FILE_MODULE:open(Name, [write, raw, binary]),
     Req = lists:flatten(lists:duplicate(17,
 					[{2*SegSize, 
 					  subbin(Bin, 2*SegSize, 2*SegSize)},
-					{0*SegSize, 
-					 subbin(Bin, 0*SegSize, 2*SegSize)}])),
-    ?line {ok, Comment} = 
+					 {0*SegSize,
+					  subbin(Bin, 0*SegSize, 2*SegSize)}])),
+    {ok, Comment} =
 	response_analysis(?FILE_MODULE, pwrite, [FD7, Req]),
-    ?line ok = ?FILE_MODULE:close(FD7),
+    ok = ?FILE_MODULE:close(FD7),
     %%
-    ?line [] = flush(),
+    [] = flush(),
     {comment, Comment}.
 
 
@@ -3418,26 +3418,26 @@ segment_write(Config) when is_list(Config) ->
 %% Test Dets special indirect pread.
 ipread(Config) when is_list(Config) ->
     Dir = proplists:get_value(priv_dir, Config),
-    ?line ok = ipread_int(Dir, [raw, binary]),
-    ?line ok = ipread_int(Dir, [raw]),
-    ?line ok = ipread_int(Dir, [binary]),
-    ?line ok = ipread_int(Dir, []),
-    ?line ok = ipread_int(Dir, [ram, binary]),
-    ?line ok = ipread_int(Dir, [ram]),
+    ok = ipread_int(Dir, [raw, binary]),
+    ok = ipread_int(Dir, [raw]),
+    ok = ipread_int(Dir, [binary]),
+    ok = ipread_int(Dir, []),
+    ok = ipread_int(Dir, [ram, binary]),
+    ok = ipread_int(Dir, [ram]),
     %%
-    ?line [] = flush(),
+    [] = flush(),
     ok.
 
 ipread_int(Dir, ModeList) ->
-    ?line Name = 
+    Name =
 	filename:join(Dir, 
 		      lists:flatten([?MODULE_STRING, "_ipread",
-		       lists:map(fun (X) ->
-					 ["_", atom_to_list(X)]
-				 end,
-				 ModeList)])),
-    ?line io:format("ipread_int<~p, ~p>~n", [Name, ModeList]),
-    ?line {Conv, Sizeof} = 
+				     lists:map(fun (X) ->
+						       ["_", atom_to_list(X)]
+					       end,
+					       ModeList)])),
+    io:format("ipread_int<~p, ~p>~n", [Name, ModeList]),
+    {Conv, Sizeof} =
 	case lists:member(binary, ModeList) of
 	    true ->
 		{fun (Bin) when is_binary(Bin) -> Bin;
@@ -3450,59 +3450,59 @@ ipread_int(Dir, ModeList) ->
 		 end, 
 		 fun erlang:length/1}
 	end,
-    ?line Pos = 4711,
-    ?line Data = Conv("THE QUICK BROWN FOX JUMPS OVER A LAZY DOG"),
-    ?line Size = Sizeof(Data),
-    ?line Init = Conv("                 "),
-    ?line SizeInit = Sizeof(Init),
-    ?line Head = Conv(<<Size:32/big-unsigned, Pos:32/big-unsigned>>),
-    ?line Filler = Conv(bytes($ , Pos-SizeInit-Sizeof(Head))),
-    ?line Size1 = Size+1,
-    ?line SizePos = Size+Pos,
+    Pos = 4711,
+    Data = Conv("THE QUICK BROWN FOX JUMPS OVER A LAZY DOG"),
+    Size = Sizeof(Data),
+    Init = Conv("                 "),
+    SizeInit = Sizeof(Init),
+    Head = Conv(<<Size:32/big-unsigned, Pos:32/big-unsigned>>),
+    Filler = Conv(bytes($ , Pos-SizeInit-Sizeof(Head))),
+    Size1 = Size+1,
+    SizePos = Size+Pos,
     %%
-    ?line {ok, FD} = ?FILE_MODULE:open(Name, [write, read | ModeList]),
-    ?line ok = ?FILE_MODULE:truncate(FD),
-    ?line ok = ?FILE_MODULE:write(FD, Init),
-    ?line ok = ?FILE_MODULE:write(FD, Head),
-    ?line ok = ?FILE_MODULE:write(FD, Filler),
-    ?line ok = ?FILE_MODULE:write(FD, Data),
+    {ok, FD} = ?FILE_MODULE:open(Name, [write, read | ModeList]),
+    ok = ?FILE_MODULE:truncate(FD),
+    ok = ?FILE_MODULE:write(FD, Init),
+    ok = ?FILE_MODULE:write(FD, Head),
+    ok = ?FILE_MODULE:write(FD, Filler),
+    ok = ?FILE_MODULE:write(FD, Data),
     %% Correct read
-    ?line {ok, {Size, Pos, Data}} = 
+    {ok, {Size, Pos, Data}} =
 	?FILE_MODULE:ipread_s32bu_p32bu(FD, SizeInit, infinity),
     %% Invalid header - size > max
-    ?line eof = 
+    eof =
 	?FILE_MODULE:ipread_s32bu_p32bu(FD, SizeInit, Size-1),
     %% Data block protudes over eof
-    ?line ok = 
+    ok =
 	?FILE_MODULE:pwrite(FD, SizeInit, 
 			    <<Size1:32/big-unsigned, 
-			     Pos:32/big-unsigned>>),
-    ?line {ok, {Size1, Pos, Data}} = 
+			      Pos:32/big-unsigned>>),
+    {ok, {Size1, Pos, Data}} =
 	?FILE_MODULE:ipread_s32bu_p32bu(FD, SizeInit, Size1),
     %% Data block outside file
-    ?line ok =
+    ok =
 	?FILE_MODULE:pwrite(FD, SizeInit, 
 			    <<Size:32/big-unsigned, 
-			     SizePos:32/big-unsigned>>),
-    ?line {ok, {Size, SizePos, eof}} =
+			      SizePos:32/big-unsigned>>),
+    {ok, {Size, SizePos, eof}} =
 	?FILE_MODULE:ipread_s32bu_p32bu(FD, SizeInit, Size),
     %% Zero size
-    ?line ok = 
+    ok =
 	?FILE_MODULE:pwrite(FD, SizeInit, 
 			    <<0:32/big-unsigned, 
-			     Pos:32/big-unsigned>>),
-    ?line {ok, {0, Pos, eof}} = 
+			      Pos:32/big-unsigned>>),
+    {ok, {0, Pos, eof}} =
 	?FILE_MODULE:ipread_s32bu_p32bu(FD, SizeInit, Size),
     %% Invalid header - protudes over eof
-    ?line eof = 
+    eof =
 	?FILE_MODULE:ipread_s32bu_p32bu(FD, 
 					Pos+Size-(Sizeof(Head)-1), 
 					infinity),
     %% Header not even in file
-    ?line eof = 
+    eof =
 	?FILE_MODULE:ipread_s32bu_p32bu(FD, Pos+Size, infinity),
     %%
-    ?line ok = ?FILE_MODULE:close(FD),
+    ok = ?FILE_MODULE:close(FD),
     ok.
 
 
@@ -3512,25 +3512,25 @@ ipread_int(Dir, ModeList) ->
 %% Tests interleaved read and writes.
 interleaved_read_write(Config) when is_list(Config) ->
     Dir = proplists:get_value(priv_dir, Config),
-    ?line File = 
+    File =
 	filename:join(Dir, ?MODULE_STRING++"interleaved_read_write.txt"),
-    ?line {ok,F1} = ?FILE_MODULE:open(File, [write]),
-    ?line ok = ?FILE_MODULE:write(F1, "data---r1."), % 10 chars each
-    ?line ok = ?FILE_MODULE:write(F1, "data---r2."),
-    ?line ok = ?FILE_MODULE:write(F1, "data---r3."),
-    ?line ok = ?FILE_MODULE:close(F1),
-    ?line {ok,F2} = ?FILE_MODULE:open(File, [read, write]),
-    ?line {ok, "data---r1."} = ?FILE_MODULE:read(F2, 10),
-    ?line ok = ?FILE_MODULE:write(F2, "data---w2."),
-    ?line ok = ?FILE_MODULE:close(F2),
-    ?line {ok,F3} = ?FILE_MODULE:open(File, [read]),
-    ?line {ok, "data---r1."} = ?FILE_MODULE:read(F3, 10),
-    ?line {ok, "data---w2."} = ?FILE_MODULE:read(F3, 10),
-    ?line {ok, "data---r3."} = ?FILE_MODULE:read(F3, 10),
-    ?line eof = ?FILE_MODULE:read(F3, 1),
-    ?line ok = ?FILE_MODULE:close(F2),
+    {ok,F1} = ?FILE_MODULE:open(File, [write]),
+    ok = ?FILE_MODULE:write(F1, "data---r1."), % 10 chars each
+    ok = ?FILE_MODULE:write(F1, "data---r2."),
+    ok = ?FILE_MODULE:write(F1, "data---r3."),
+    ok = ?FILE_MODULE:close(F1),
+    {ok,F2} = ?FILE_MODULE:open(File, [read, write]),
+    {ok, "data---r1."} = ?FILE_MODULE:read(F2, 10),
+    ok = ?FILE_MODULE:write(F2, "data---w2."),
+    ok = ?FILE_MODULE:close(F2),
+    {ok,F3} = ?FILE_MODULE:open(File, [read]),
+    {ok, "data---r1."} = ?FILE_MODULE:read(F3, 10),
+    {ok, "data---w2."} = ?FILE_MODULE:read(F3, 10),
+    {ok, "data---r3."} = ?FILE_MODULE:read(F3, 10),
+    eof = ?FILE_MODULE:read(F3, 1),
+    ok = ?FILE_MODULE:close(F2),
     %%
-    ?line [] = flush(),
+    [] = flush(),
     ok.
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
@@ -3540,33 +3540,33 @@ otp_5814(Config) when is_list(Config) ->
     PrivDir = proplists:get_value(priv_dir, Config),
     File = filename:join(PrivDir, "otp_5814"),
     Path = [PrivDir],
-    ?line ok = file:write_file(File, <<"{a,b,c}.
+    ok = file:write_file(File, <<"{a,b,c}.
                                         a.
-                                        b.
-                                        c.
-                                        {d,e,
-                                        [}.">>),
-    ?line {error, {6,erl_parse,_}} = file:eval(File),
-    ?line {error, {6,erl_parse,_}} = file:consult(File),
-    ?line {error, {6,erl_parse,_}} = file:path_consult(Path, File),
-    ?line {error, {6,erl_parse,_}} = file:path_eval(Path, File),
-    ?line {error, {6,erl_parse,_}} = file:script(File),
-    ?line {error, {6,erl_parse,_}} = file:path_script(Path, File),
-
-    ?line ok = file:write_file(File, <<>>),
-    ?line {error, {1,file,undefined_script}} = file:path_script(Path, File),
+b.
+c.
+{d,e,
+ [}.">>),
+    {error, {6,erl_parse,_}} = file:eval(File),
+ {error, {6,erl_parse,_}} = file:consult(File),
+ {error, {6,erl_parse,_}} = file:path_consult(Path, File),
+ {error, {6,erl_parse,_}} = file:path_eval(Path, File),
+ {error, {6,erl_parse,_}} = file:script(File),
+ {error, {6,erl_parse,_}} = file:path_script(Path, File),
+
+ ok = file:write_file(File, <<>>),
+ {error, {1,file,undefined_script}} = file:path_script(Path, File),
 
     %% The error is not propagated...
-    ?line ok = file:write_file(File, <<"a.
+ ok = file:write_file(File, <<"a.
                                         b.
-                                        1/0.">>),
-    ?line {error, {3, file, {error, badarith, _}}} = file:eval(File),
-    
-    ?line ok = file:write_file(File, <<"erlang:raise(throw, apa, []).">>),
-    ?line {error, {1, file, {throw, apa, _}}} = file:eval(File),
+1/0.">>),
+    {error, {3, file, {error, badarith, _}}} = file:eval(File),
 
-    file:delete(File),
-    ok.
+ok = file:write_file(File, <<"erlang:raise(throw, apa, []).">>),
+{error, {1, file, {throw, apa, _}}} = file:eval(File),
+
+file:delete(File),
+ok.
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
@@ -3588,10 +3588,10 @@ otp_10852(Config) when is_list(Config) ->
     ok = rpc_call(Node, read_file, [B]),
     ok = rpc_call(Node, make_link, [B,B]),
     case rpc_call(Node, make_symlink, [B,B]) of
-		ok -> ok;
-		{error, E} when (E =:= enotsup) or (E =:= eperm) ->
-			{win32,_} = os:type()
-	end,
+	ok -> ok;
+	{error, E} when (E =:= enotsup) or (E =:= eperm) ->
+	    {win32,_} = os:type()
+    end,
     ok = rpc_call(Node, delete, [B]),
     ok = rpc_call(Node, make_dir, [B]),
     ok = rpc_call(Node, del_dir, [B]),
@@ -3624,40 +3624,40 @@ large_file(Config) when is_list(Config) ->
 			"_large_file").
 
 do_large_file(Name) ->
-    ?line S = "1234567890",
+    S = "1234567890",
     L = length(S),
     R = lists:reverse(S),
     P = 1 bsl 32,
     Ss = lists:sort(S),
     Rs = lists:reverse(Ss),
-    ?line {ok,F}  = ?FILE_MODULE:open(Name, [raw,read,write]),
-    ?line ok      = ?FILE_MODULE:write(F, S),
-    ?line {ok,P}  = ?FILE_MODULE:position(F, P),
-    ?line ok      = ?FILE_MODULE:write(F, R),
-    ?line {ok,0}  = ?FILE_MODULE:position(F, bof),
-    ?line {ok,S}  = ?FILE_MODULE:read(F, L),
-    ?line {ok,P}  = ?FILE_MODULE:position(F, {eof,-L}),
-    ?line {ok,R}  = ?FILE_MODULE:read(F, L+1),
-    ?line {ok,S}  = ?FILE_MODULE:pread(F, 0, L),
-    ?line {ok,R}  = ?FILE_MODULE:pread(F, P, L+1),
-    ?line ok      = ?FILE_MODULE:pwrite(F, 0, Ss),
-    ?line ok      = ?FILE_MODULE:pwrite(F, P, Rs),
-    ?line {ok,0}  = ?FILE_MODULE:position(F, bof),
-    ?line {ok,Ss} = ?FILE_MODULE:read(F, L),
-    ?line {ok,P}  = ?FILE_MODULE:position(F, {eof,-L}),
-    ?line {ok,Rs} = ?FILE_MODULE:read(F, L+1),
-    ?line ok      = ?FILE_MODULE:close(F),
+    {ok,F}  = ?FILE_MODULE:open(Name, [raw,read,write]),
+    ok      = ?FILE_MODULE:write(F, S),
+    {ok,P}  = ?FILE_MODULE:position(F, P),
+    ok      = ?FILE_MODULE:write(F, R),
+    {ok,0}  = ?FILE_MODULE:position(F, bof),
+    {ok,S}  = ?FILE_MODULE:read(F, L),
+    {ok,P}  = ?FILE_MODULE:position(F, {eof,-L}),
+    {ok,R}  = ?FILE_MODULE:read(F, L+1),
+    {ok,S}  = ?FILE_MODULE:pread(F, 0, L),
+    {ok,R}  = ?FILE_MODULE:pread(F, P, L+1),
+    ok      = ?FILE_MODULE:pwrite(F, 0, Ss),
+    ok      = ?FILE_MODULE:pwrite(F, P, Rs),
+    {ok,0}  = ?FILE_MODULE:position(F, bof),
+    {ok,Ss} = ?FILE_MODULE:read(F, L),
+    {ok,P}  = ?FILE_MODULE:position(F, {eof,-L}),
+    {ok,Rs} = ?FILE_MODULE:read(F, L+1),
+    ok      = ?FILE_MODULE:close(F),
     %% Reopen the file with 'append'; used to fail on Windows causing
     %% writes to go to the beginning of the file for files > 4GB.
-    ?line PL = P + L,
-    ?line PLL = PL + L,
-    ?line {ok,F1}  = ?FILE_MODULE:open(Name, [raw,read,write,append]),
-    ?line ok       = ?FILE_MODULE:write(F1, R),
-    ?line {ok,PLL} = ?FILE_MODULE:position(F1, {cur,0}),
-    ?line {ok,Rs}  = ?FILE_MODULE:pread(F1, P, L),
-    ?line {ok,PL}  = ?FILE_MODULE:position(F1, {eof,-L}),
-    ?line {ok,R}   = ?FILE_MODULE:read(F1, L+1),
-    ?line ok       = ?FILE_MODULE:close(F1),
+    PL = P + L,
+    PLL = PL + L,
+    {ok,F1}  = ?FILE_MODULE:open(Name, [raw,read,write,append]),
+    ok       = ?FILE_MODULE:write(F1, R),
+    {ok,PLL} = ?FILE_MODULE:position(F1, {cur,0}),
+    {ok,Rs}  = ?FILE_MODULE:pread(F1, P, L),
+    {ok,PL}  = ?FILE_MODULE:position(F1, {eof,-L}),
+    {ok,R}   = ?FILE_MODULE:read(F1, L+1),
+    ok       = ?FILE_MODULE:close(F1),
 
     ok.
 
@@ -3692,8 +3692,8 @@ do_large_write(Name) ->
 
 response_analysis(Module, Function, Arguments) ->
     Parent = self(),
-    ?line erlang:yield(), % Schedule out before test
-    ?line Child = 
+    erlang:yield(), % Schedule out before test
+    Child =
 	spawn_link(
 	  fun () ->
 		  receive {Parent, start, Ts} -> ok end,
@@ -3713,19 +3713,19 @@ response_analysis(Module, Function, Arguments) ->
 		  Parent ! {self(), stopped, response_stat(Stat, micro_ts())}
 	  end),
     Child ! {Parent, start, micro_ts()},
-    ?line Result = apply(Module, Function, Arguments),
-    ?line Child ! {Parent, stop},
-    ?line {N, Sum, _, M, Max} = receive {Child, stopped, X} -> X end,
-    ?line Mean_ms = (0.001*Sum) / (N-1),
-    ?line Max_ms = 0.001 * Max,
-    ?line Comment = 
+    Result = apply(Module, Function, Arguments),
+    Child ! {Parent, stop},
+    {N, Sum, _, M, Max} = receive {Child, stopped, X} -> X end,
+    Mean_ms = (0.001*Sum) / (N-1),
+    Max_ms = 0.001 * Max,
+    Comment =
 	lists:flatten(
 	  io_lib:format(
 	    "Scheduling interval: Mean = ~.3f ms, "
 	    ++"Max = ~.3f ms for no ~p of ~p.~n",
 	    [Mean_ms, Max_ms, M, (N-1)])),
-    ?line {Result, Comment}.
-    
+    {Result, Comment}.
+
 micro_ts() ->
     erlang:monotonic_time(micro_seconds).
 
@@ -3749,10 +3749,10 @@ response_stat({N, Sum, Ts0, M, Max}, Ts) ->
 %% create_file/2 below is some 44 times faster.
 
 create_file_slow(Name, N) when is_integer(N), N >= 0 ->
-    ?line {ok, FD} = 
+    {ok, FD} =
 	?FILE_MODULE:open(Name, [raw, write, delayed_write, binary]),
-    ?line ok = create_file_slow(FD, 0, N),
-    ?line ok = ?FILE_MODULE:close(FD),
+    ok = create_file_slow(FD, 0, N),
+    ok = ?FILE_MODULE:close(FD),
     ok.
 
 create_file_slow(_FD, M, M) ->
@@ -3767,10 +3767,10 @@ create_file_slow(FD, M, N) ->
 %% from 0 to N-1.
 
 create_file(Name, N) when is_integer(N), N >= 0 ->
-    ?line {ok, FD} = 
+    {ok, FD} =
 	?FILE_MODULE:open(Name, [raw, write, delayed_write, binary]),
-    ?line ok = create_file(FD, 0, N),
-    ?line ok = ?FILE_MODULE:close(FD),
+    ok = create_file(FD, 0, N),
+    ok = ?FILE_MODULE:close(FD),
     ok.
 
 create_file(_FD, M, M) ->
@@ -3787,10 +3787,10 @@ create_file(FD, M, N0, R) when M + 8 =< N0 ->
     N1  = N0-1,  N2  = N0-2,  N3  = N0-3,  N4  = N0-4, 
     N5  = N0-5,  N6  = N0-6,  N7  = N0-7,  N8  = N0-8, 
     create_file(FD, M, N8, 
-		  [<<N8:32/unsigned,  N7:32/unsigned, 
-		    N6:32/unsigned,  N5:32/unsigned, 
-		    N4:32/unsigned,  N3:32/unsigned, 
-		    N2:32/unsigned,  N1:32/unsigned>> | R]);
+		[<<N8:32/unsigned,  N7:32/unsigned,
+		   N6:32/unsigned,  N5:32/unsigned,
+		   N4:32/unsigned,  N3:32/unsigned,
+		   N2:32/unsigned,  N1:32/unsigned>> | R]);
 create_file(FD, M, N0, R) ->
     N1 = N0-1,
     create_file(FD, M, N1, [<<N1:32/unsigned>> | R]).
@@ -3807,14 +3807,14 @@ create_bin(M, N0, R) when M+8 =< N0 ->
     N5  = N0-5,  N6  = N0-6,  N7  = N0-7,  N8  = N0-8, 
     create_bin(M, N8,
 	       [<<N8:32/unsigned,  N7:32/unsigned, 
-		 N6:32/unsigned,  N5:32/unsigned, 
-		 N4:32/unsigned,  N3:32/unsigned, 
-		 N2:32/unsigned,  N1:32/unsigned>> | R]);
+		  N6:32/unsigned,  N5:32/unsigned,
+		  N4:32/unsigned,  N3:32/unsigned,
+		  N2:32/unsigned,  N1:32/unsigned>> | R]);
 create_bin(M, N0, R) ->
     N1 = N0-1,
     create_bin(M, N1, [<<N1:32/unsigned>> | R]).
-    
-    
+
+
 
 
 verify_bin(<<>>, _, 0) ->
@@ -3826,8 +3826,8 @@ verify_bin(Bin, N, Cnt) ->
     N4 = N + 4, N5 = N + 5, N6 = N + 6, N7 = N + 7, 
     case Bin of
 	<<N0:32/unsigned, N1:32/unsigned, N2:32/unsigned, N3:32/unsigned, 
-	 N4:32/unsigned, N5:32/unsigned, N6:32/unsigned, N7:32/unsigned,
-	 B/binary>> ->
+	  N4:32/unsigned, N5:32/unsigned, N6:32/unsigned, N7:32/unsigned,
+	  B/binary>> ->
 	    verify_bin(B, N+8, Cnt-8);
 	<<N:32/unsigned, B/binary>> ->
 	    verify_bin(B, N+1, Cnt-1);
@@ -3908,13 +3908,13 @@ pwrite_file(Name, Data) ->
 
 read_line_testdata(PrivDir) ->
     All0 = [{fun read_line_create0/1,"Testdata1.txt",5,10},
-	   {fun read_line_create1/1,"Testdata2.txt",401,802},
-	   {fun read_line_create2/1,"Testdata3.txt",1,2},
-	   {fun read_line_create3/1,"Testdata4.txt",601,fail},
-	   {fun read_line_create4/1,"Testdata5.txt",601,1002},
-	   {fun read_line_create5/1,"Testdata6.txt",601,1202},
-	   {fun read_line_create6/1,"Testdata7.txt",601,1202},
-	   {fun read_line_create7/1,"Testdata8.txt",4001,8002}],
+	    {fun read_line_create1/1,"Testdata2.txt",401,802},
+	    {fun read_line_create2/1,"Testdata3.txt",1,2},
+	    {fun read_line_create3/1,"Testdata4.txt",601,fail},
+	    {fun read_line_create4/1,"Testdata5.txt",601,1002},
+	    {fun read_line_create5/1,"Testdata6.txt",601,1202},
+	    {fun read_line_create6/1,"Testdata7.txt",601,1202},
+	    {fun read_line_create7/1,"Testdata8.txt",4001,8002}],
     [ {A,filename:join([PrivDir,B]),C,D} || {A,B,C,D} <- All0 ].
 
 read_line_create_files(TestData) ->
@@ -3926,90 +3926,90 @@ read_line_remove_files(TestData) ->
 %% read_line with prim_file.
 read_line_1(Config) when is_list(Config) ->
     PrivDir = proplists:get_value(priv_dir, Config),
-    ?line All = read_line_testdata(PrivDir),
-    ?line read_line_create_files(All),
-    ?line [ begin 
-		io:format("read_line_all: ~s~n",[File]),
-		{X,_} = read_line_all(File),
-		true
-	    end || {_,File,X,_} <- All ],
-    ?line [ begin 
-		io:format("read_line_all_alternating: ~s~n",[File]),
-		{Y,_} = read_line_all_alternating(File),
-		true
-	    end || {_,File,_,Y} <- All , Y =/= fail],
-    ?line [ begin 
-		io:format("read_line_all_alternating (failing as should): ~s~n",[File]),
-		{'EXIT',_} = (catch read_line_all_alternating(File)),
-		true
-	    end || {_,File,_,Y} <- All , Y =:= fail],
-    ?line read_line_remove_files(All),
+    All = read_line_testdata(PrivDir),
+    read_line_create_files(All),
+    [ begin
+	  io:format("read_line_all: ~s~n",[File]),
+	  {X,_} = read_line_all(File),
+	  true
+      end || {_,File,X,_} <- All ],
+    [ begin
+	  io:format("read_line_all_alternating: ~s~n",[File]),
+	  {Y,_} = read_line_all_alternating(File),
+	  true
+      end || {_,File,_,Y} <- All , Y =/= fail],
+    [ begin
+	  io:format("read_line_all_alternating (failing as should): ~s~n",[File]),
+	  {'EXIT',_} = (catch read_line_all_alternating(File)),
+	  true
+      end || {_,File,_,Y} <- All , Y =:= fail],
+    read_line_remove_files(All),
     ok.
 %% read_line with file.
 read_line_2(Config) when is_list(Config) ->
     PrivDir = proplists:get_value(priv_dir, Config),
-    ?line All = read_line_testdata(PrivDir),
-    ?line read_line_create_files(All),
-    ?line [ begin 
-		io:format("read_line_all: ~s~n",[File]),
-		{X,_} = read_line_all2(File),
-		true
-	    end || {_,File,X,_} <- All ],
-    ?line [ begin 
-		io:format("read_line_all_alternating: ~s~n",[File]),
-		{Y,_} = read_line_all_alternating2(File),
-		true
-	    end || {_,File,_,Y} <- All , Y =/= fail],
-    ?line [ begin 
-		io:format("read_line_all_alternating (failing as should): ~s~n",[File]),
-		{'EXIT',_} = (catch read_line_all_alternating2(File)),
-		true
-	    end || {_,File,_,Y} <- All , Y =:= fail],
-    ?line read_line_remove_files(All),
+    All = read_line_testdata(PrivDir),
+    read_line_create_files(All),
+    [ begin
+	  io:format("read_line_all: ~s~n",[File]),
+	  {X,_} = read_line_all2(File),
+	  true
+      end || {_,File,X,_} <- All ],
+    [ begin
+	  io:format("read_line_all_alternating: ~s~n",[File]),
+	  {Y,_} = read_line_all_alternating2(File),
+	  true
+      end || {_,File,_,Y} <- All , Y =/= fail],
+    [ begin
+	  io:format("read_line_all_alternating (failing as should): ~s~n",[File]),
+	  {'EXIT',_} = (catch read_line_all_alternating2(File)),
+	  true
+      end || {_,File,_,Y} <- All , Y =:= fail],
+    read_line_remove_files(All),
     ok.
 %% read_line with raw file.
 read_line_3(Config) when is_list(Config) ->
     PrivDir = proplists:get_value(priv_dir, Config),
-    ?line All = read_line_testdata(PrivDir),
-    ?line read_line_create_files(All),
-    ?line [ begin 
-		io:format("read_line_all: ~s~n",[File]),
-		{X,_} = read_line_all3(File),
-		true
-	    end || {_,File,X,_} <- All ],
-    ?line [ begin 
-		io:format("read_line_all_alternating: ~s~n",[File]),
-		{Y,_} = read_line_all_alternating3(File),
-		true
-	    end || {_,File,_,Y} <- All , Y =/= fail],
-    ?line [ begin 
-		io:format("read_line_all_alternating (failing as should): ~s~n",[File]),
-		{'EXIT',_} = (catch read_line_all_alternating3(File)),
-		true
-	    end || {_,File,_,Y} <- All , Y =:= fail],
-    ?line read_line_remove_files(All),
+    All = read_line_testdata(PrivDir),
+    read_line_create_files(All),
+    [ begin
+	  io:format("read_line_all: ~s~n",[File]),
+	  {X,_} = read_line_all3(File),
+	  true
+      end || {_,File,X,_} <- All ],
+    [ begin
+	  io:format("read_line_all_alternating: ~s~n",[File]),
+	  {Y,_} = read_line_all_alternating3(File),
+	  true
+      end || {_,File,_,Y} <- All , Y =/= fail],
+    [ begin
+	  io:format("read_line_all_alternating (failing as should): ~s~n",[File]),
+	  {'EXIT',_} = (catch read_line_all_alternating3(File)),
+	  true
+      end || {_,File,_,Y} <- All , Y =:= fail],
+    read_line_remove_files(All),
     ok.
 %% read_line with raw buffered file.
 read_line_4(Config) when is_list(Config) ->
     PrivDir = proplists:get_value(priv_dir, Config),
-    ?line All = read_line_testdata(PrivDir),
-    ?line read_line_create_files(All),
-    ?line [ begin 
-		io:format("read_line_all: ~s~n",[File]),
-		{X,_} = read_line_all4(File),
-		true
-	    end || {_,File,X,_} <- All ],
-    ?line [ begin 
-		io:format("read_line_all_alternating: ~s~n",[File]),
-		{Y,_} = read_line_all_alternating4(File),
-		true
-	    end || {_,File,_,Y} <- All , Y =/= fail],
-    ?line [ begin 
-		io:format("read_line_all_alternating (failing as should): ~s~n",[File]),
-		{'EXIT',_} = (catch read_line_all_alternating4(File)),
-		true
-	    end || {_,File,_,Y} <- All , Y =:= fail],
-    ?line read_line_remove_files(All),
+    All = read_line_testdata(PrivDir),
+    read_line_create_files(All),
+    [ begin
+	  io:format("read_line_all: ~s~n",[File]),
+	  {X,_} = read_line_all4(File),
+	  true
+      end || {_,File,X,_} <- All ],
+    [ begin
+	  io:format("read_line_all_alternating: ~s~n",[File]),
+	  {Y,_} = read_line_all_alternating4(File),
+	  true
+      end || {_,File,_,Y} <- All , Y =/= fail],
+    [ begin
+	  io:format("read_line_all_alternating (failing as should): ~s~n",[File]),
+	  {'EXIT',_} = (catch read_line_all_alternating4(File)),
+	  true
+      end || {_,File,_,Y} <- All , Y =:= fail],
+    read_line_remove_files(All),
     ok.
 
 rl_lines() ->
@@ -4280,7 +4280,7 @@ run_large_file_test(Config, Run, Name) ->
 do_run_large_file_test(Config, Run, Name0) ->
     Name = filename:join(proplists:get_value(priv_dir, Config),
 			 ?MODULE_STRING ++ Name0),
-    
+
     %% Set up a process that will delete this file.
     Tester = self(),
     Deleter = 
@@ -4293,7 +4293,7 @@ do_run_large_file_test(Config, Run, Name0) ->
 		  end,
 		  ?FILE_MODULE:delete(Name)
 	  end),
-    
+
     %% Run the test case.
     Res = Run(Name),