Account for new behavior in tests that touch prim_file

This also hides the module behind ?PRIM_FILE to make testing new
implementations less painful.

6 files changed, 239 insertions, 561 deletions

diff --git a/lib/kernel/test/erl_prim_loader_SUITE.erl b/lib/kernel/test/erl_prim_loader_SUITE.erl
index b6417210b9..3502a4ad08 100644
--- a/lib/kernel/test/erl_prim_loader_SUITE.erl
+++ b/lib/kernel/test/erl_prim_loader_SUITE.erl
@@ -33,6 +33,7 @@
 	 primary_archive/1, virtual_dir_in_archive/1,
 	 get_modules/1]).
 
+-define(PRIM_FILE, prim_file).
 
 %%-----------------------------------------------------------------
 %% Test suite for erl_prim_loader. (Most code is run during system start/stop.)
@@ -461,7 +462,7 @@ primary_archive(Config) when is_list(Config) ->
     %% Set primary archive 
     ExpectedEbins = [Archive, DictDir ++ "/ebin", DummyDir ++ "/ebin"],
     io:format("ExpectedEbins: ~p\n", [ExpectedEbins]),
-    {ok, FileInfo} = prim_file:read_file_info(Archive),
+    {ok, FileInfo} = ?PRIM_FILE:read_file_info(Archive),
     {ok, Ebins} = rpc:call(Node, erl_prim_loader, set_primary_archive,
 			   [Archive, ArchiveBin, FileInfo,
 			    fun escript:parse_file/1]),
diff --git a/lib/kernel/test/file_SUITE.erl b/lib/kernel/test/file_SUITE.erl
index 119e1f24bb..69cf8274a2 100644
--- a/lib/kernel/test/file_SUITE.erl
+++ b/lib/kernel/test/file_SUITE.erl
@@ -39,6 +39,8 @@
 -define(FILE_FIN_PER_TESTCASE(Config), Config).
 -endif.
 
+-define(PRIM_FILE, prim_file).
+
 -module(?FILE_SUITE).
 
 -export([all/0, suite/0,groups/0,init_per_suite/1, end_per_suite/1, 
@@ -3934,7 +3936,7 @@ read_line_create_files(TestData) ->
 read_line_remove_files(TestData) ->
     [ file:delete(File) || {_Function,File,_,_} <- TestData ].
 
-%% read_line with prim_file.
+%% read_line with ?PRIM_FILE.
 read_line_1(Config) when is_list(Config) ->
     PrivDir = proplists:get_value(priv_dir, Config),
     All = read_line_testdata(PrivDir),
@@ -4103,9 +4105,9 @@ read_line_create7(Filename) ->
     file:close(F).
 
 read_line_all(Filename) ->
-    {ok,F} = prim_file:open(Filename,[read,binary]),
+    {ok,F} = ?PRIM_FILE:open(Filename,[read,binary]),
     X=read_rl_lines(F),
-    prim_file:close(F),
+    ?PRIM_FILE:close(F),
     Bin = list_to_binary([B || {ok,B} <- X]),
     Bin = re:replace(list_to_binary([element(2,file:read_file(Filename))]),
 		     "\r\n","\n",[global,{return,binary}]),
@@ -4138,7 +4140,7 @@ read_line_all4(Filename) ->
     {length(X),Bin}.
 
 read_rl_lines(F) ->
-    case prim_file:read_line(F) of
+    case ?PRIM_FILE:read_line(F) of
 	eof ->
 	    [];
 	{error,X} ->
@@ -4158,9 +4160,9 @@ read_rl_lines2(F) ->
     end.
 
 read_line_all_alternating(Filename) ->
-    {ok,F} = prim_file:open(Filename,[read,binary]),
+    {ok,F} = ?PRIM_FILE:open(Filename,[read,binary]),
     X=read_rl_lines(F,true),
-    prim_file:close(F),
+    ?PRIM_FILE:close(F),
     Bin = list_to_binary([B || {ok,B} <- X]),
     Bin = re:replace(list_to_binary([element(2,file:read_file(Filename))]),
 		     "\r\n","\n",[global,{return,binary}]),
@@ -4194,8 +4196,8 @@ read_line_all_alternating4(Filename) ->
 read_rl_lines(F,Alternate) ->
     case begin
 	     case Alternate of
-		 true -> prim_file:read(F,1);
-		 false -> prim_file:read_line(F)
+		 true -> ?PRIM_FILE:read(F,1);
+		 false -> ?PRIM_FILE:read_line(F)
 	     end 
 	 end of
 	eof ->
diff --git a/lib/kernel/test/file_name_SUITE.erl b/lib/kernel/test/file_name_SUITE.erl
index f23529fec9..3afc647081 100644
--- a/lib/kernel/test/file_name_SUITE.erl
+++ b/lib/kernel/test/file_name_SUITE.erl
@@ -77,6 +77,7 @@
 	 init_per_testcase/2, end_per_testcase/2]).
 -export([normal/1,icky/1,very_icky/1,normalize/1,home_dir/1]).
 
+-define(PRIM_FILE, prim_file).
 
 init_per_testcase(_Func, Config) ->
     Config.
@@ -131,7 +132,7 @@ home_dir(Config) when is_list(Config) ->
 					     os:putenv("HOME",NewHome),
 					     {"HOME",Save};
 					 _ ->
-					     rm_rf(prim_file,NewHome),
+					     rm_rf(?PRIM_FILE,NewHome),
 					     throw(unsupported_os)
 				     end,
 	try
@@ -145,7 +146,7 @@ home_dir(Config) when is_list(Config) ->
 		_ ->
 		    os:putenv(SaveOldName,SaveOldValue)
 	    end,
-	    rm_rf(prim_file,NewHome)
+	    rm_rf(?PRIM_FILE,NewHome)
 	end
     catch
 	throw:need_unicode_mode ->
@@ -190,7 +191,7 @@ normal(Config) when is_list(Config) ->
     try
 	Priv = proplists:get_value(priv_dir, Config),
 	file:set_cwd(Priv),
-	ok = check_normal(prim_file),
+	ok = check_normal(?PRIM_FILE),
 	ok = check_normal(file),
 	%% If all is good, delete dir again (avoid hanging dir on windows)
 	rm_rf(file,"normal_dir"),
@@ -210,7 +211,7 @@ icky(Config) when is_list(Config) ->
 	    try
 		Priv = proplists:get_value(priv_dir, Config),
 		file:set_cwd(Priv),
-		ok = check_icky(prim_file),
+		ok = check_icky(?PRIM_FILE),
 		ok = check_icky(file),
 		%% If all is good, delete dir again (avoid hanging dir on windows)
 		rm_rf(file,"icky_dir"),
@@ -229,7 +230,7 @@ very_icky(Config) when is_list(Config) ->
 	    try
 		Priv = proplists:get_value(priv_dir, Config),
 		file:set_cwd(Priv),
-		case check_very_icky(prim_file) of
+		case check_very_icky(?PRIM_FILE) of
 		    need_unicode_mode ->
 			{skipped,"VM needs to be started in Unicode filename mode"};
 		    ok ->
@@ -292,11 +293,6 @@ check_normal(Mod) ->
 		ok
 	end,
 	[ begin
-	      {ok, FD} = Mod:open(Name,[read]),
-	      {ok, Content} = Mod:read(FD,1024),
-	      ok = file:close(FD)
-	  end || {regular,Name,Content} <- NormalDir ],
-	[ begin
 	      {ok, FD} = Mod:open(Name,[read,binary]),
 	      BC = list_to_binary(Content),
 	      {ok, BC} = Mod:read(FD,1024),
@@ -412,11 +408,6 @@ check_icky(Mod) ->
 		ok
 	end,
 	[ begin
-	      {ok, FD} = Mod:open(Name,[read]),
-	      {ok, Content} = Mod:read(FD,1024),
-	      ok = file:close(FD)
-	  end || {regular,Name,Content} <- IckyDir ],
-	[ begin
 	      {ok, FD} = Mod:open(Name,[read,binary]),
 	      BC = list_to_binary([Content]),
 	      {ok, BC} = Mod:read(FD,1024),
@@ -521,11 +512,6 @@ check_very_icky(Mod) ->
 		ok
 	end,
 	[ begin
-	      {ok, FD} = Mod:open(Name,[read]),
-	      {ok, Content} = Mod:read(FD,1024),
-	      ok = file:close(FD)
-	  end || {regular,Name,Content} <- VeryIckyDir ],
-	[ begin
 	      {ok, FD} = Mod:open(Name,[read,binary]),
 	      BC = list_to_binary([Content]),
 	      {ok, BC} = Mod:read(FD,1024),
diff --git a/lib/kernel/test/prim_file_SUITE.erl b/lib/kernel/test/prim_file_SUITE.erl
index 2f4330c217..8a1e99b332 100644
--- a/lib/kernel/test/prim_file_SUITE.erl
+++ b/lib/kernel/test/prim_file_SUITE.erl
@@ -21,38 +21,23 @@
 -export([all/0, suite/0,groups/0,init_per_suite/1, end_per_suite/1, 
 	 init_per_group/2,end_per_group/2, init_per_testcase/2, end_per_testcase/2,
 	 read_write_file/1, free_memory/0]).
--export([cur_dir_0a/1, cur_dir_0b/1, 
-	 cur_dir_1a/1, cur_dir_1b/1, 
-	 make_del_dir_a/1, make_del_dir_b/1,
-	 pos1/1, pos2/1]).
--export([close/1, 
-	 delete_a/1, delete_b/1]).
--export([ open1/1, modes/1]).
--export([ 
-	  file_info_basic_file_a/1, file_info_basic_file_b/1,
-	  file_info_basic_directory_a/1, file_info_basic_directory_b/1,
-	  file_info_bad_a/1, file_info_bad_b/1, 
-	  file_info_times_a/1, file_info_times_b/1, 
-	  file_write_file_info_a/1, file_write_file_info_b/1,
-	  file_read_file_info_opts/1, file_write_file_info_opts/1,
-	  file_write_read_file_info_opts/1
-	]).
--export([rename_a/1, rename_b/1, 
-	 access/1, truncate/1, datasync/1, sync/1,
+-export([cur_dir_0/1, cur_dir_1/1,
+	 make_del_dir/1, pos1/1, pos2/1]).
+-export([close/1, delete/1]).
+-export([open1/1, modes/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_read_file_info_opts/1, file_write_file_info_opts/1,
+	 file_write_read_file_info_opts/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([e_delete/1, e_rename/1, e_make_dir/1, e_del_dir/1]).
 
--export([ read_not_really_compressed/1,
-	  read_compressed/1, write_compressed/1,
-	  compress_errors/1]).
-
--export([ 
-	  make_link_a/1, make_link_b/1,
-	  read_link_info_for_non_link/1, 
-	  symlinks_a/1, symlinks_b/1,
-	  list_dir_limit/1,
-	  list_dir_error/1,
-	  list_dir/1]).
+-export([make_link/1, read_link_info_for_non_link/1,
+	 symlinks/1,
+	 list_dir_limit/1,
+	 list_dir_error/1,
+	 list_dir/1]).
 
 -export([advise/1]).
 -export([large_write/1]).
@@ -67,29 +52,16 @@
 
 -define(PRIM_FILE, prim_file).
 
-%% Calls ?PRIM_FILE:F with arguments A and an optional handle H 
-%% as first argument, unless the handle is [], i.e no handle.
-%% This is a macro to give the compiler and thereby 
-%% the cross reference tool the possibility to interprete
-%% the call, since M, F, A (or [H | A]) can all be known at 
-%% compile time.
--define(PRIM_FILE_call(F, H, A), 
-	case H of
-	    [] -> apply(?PRIM_FILE, F, A);
-	    _ ->  apply(?PRIM_FILE, F, [H | A])
-	end).
-
 suite() -> [].
 
 all() -> 
     [read_write_file, {group, dirs}, {group, files},
-     delete_a, delete_b, rename_a, rename_b, {group, errors},
-     {group, compression}, {group, links}, list_dir_limit, list_dir].
+     delete, rename, {group, errors}, {group, links},
+     list_dir_limit, list_dir].
 
 groups() -> 
     [{dirs, [],
-      [make_del_dir_a, make_del_dir_b, cur_dir_0a, cur_dir_0b,
-       cur_dir_1a, cur_dir_1b]},
+      [make_del_dir, cur_dir_0, cur_dir_1]},
      {files, [],
       [{group, open}, {group, pos}, {group, file_info},
        truncate, sync, datasync, advise, large_write, allocate]},
@@ -98,22 +70,14 @@ groups() ->
        append, exclusive]},
      {pos, [], [pos1, pos2]},
      {file_info, [],
-      [file_info_basic_file_a, file_info_basic_file_b,
-       file_info_basic_directory_a,
-       file_info_basic_directory_b, file_info_bad_a,
-       file_info_bad_b, file_info_times_a, file_info_times_b,
-       file_write_file_info_a, file_write_file_info_b,
-       file_read_file_info_opts, file_write_file_info_opts,
-       file_write_read_file_info_opts
+      [file_info_basic_file,file_info_basic_directory, file_info_bad,
+       file_info_times, file_write_file_info, file_read_file_info_opts,
+       file_write_file_info_opts, file_write_read_file_info_opts
       ]},
      {errors, [],
       [e_delete, e_rename, e_make_dir, e_del_dir]},
-     {compression, [],
-      [read_compressed, read_not_really_compressed,
-       write_compressed, compress_errors]},
      {links, [],
-      [make_link_a, make_link_b, read_link_info_for_non_link,
-       symlinks_a, symlinks_b, list_dir_error]}].
+      [make_link, read_link_info_for_non_link, symlinks, list_dir_error]}].
 
 init_per_testcase(large_write, Config) ->
     {ok, Started} = application:ensure_all_started(os_mon),
@@ -246,39 +210,27 @@ read_write_file(Config) when is_list(Config) ->
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
-
-make_del_dir_a(Config) when is_list(Config) ->
-    make_del_dir(Config, [], "_a").
-
-make_del_dir_b(Config) when is_list(Config) ->
-    {ok, Handle} = ?PRIM_FILE:start(),
-    Result = make_del_dir(Config, Handle, "_b"),
-    ok = ?PRIM_FILE:stop(Handle),
-    %% Just to make sure the state of the server makes a difference
-    {error, einval} = ?PRIM_FILE_call(get_cwd, Handle, []),
-    Result.
-
-make_del_dir(Config, Handle, Suffix) ->
+make_del_dir(Config) when is_list(Config) ->
     RootDir = proplists:get_value(priv_dir,Config),
     NewDir = filename:join(RootDir,
 			   atom_to_list(?MODULE)
-			   ++"_mk-dir"++Suffix),
-    ok = ?PRIM_FILE_call(make_dir, Handle, [NewDir]),
-    {error, eexist} = ?PRIM_FILE_call(make_dir, Handle, [NewDir]),
-    ok = ?PRIM_FILE_call(del_dir, Handle, [NewDir]),
-    {error, enoent} = ?PRIM_FILE_call(del_dir, Handle, [NewDir]),
+			   ++"_mk-dir"),
+    ok = ?PRIM_FILE:make_dir(NewDir),
+    {error, eexist} = ?PRIM_FILE:make_dir(NewDir),
+    ok = ?PRIM_FILE:del_dir(NewDir),
+    {error, enoent} = ?PRIM_FILE: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.
-    ok = ?PRIM_FILE_call(make_dir, Handle, [NewDir]),
-    {ok, CurrentDir} = ?PRIM_FILE_call(get_cwd, Handle, []),
+    ok = ?PRIM_FILE:make_dir(NewDir),
+    {ok, CurrentDir} = ?PRIM_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]);
 	_ ->
-	    ok = ?PRIM_FILE_call(set_cwd, Handle, [NewDir])
+	    ok = ?PRIM_FILE:set_cwd(NewDir)
     end,
     try
 	%% Check that we get an error when trying to create...
@@ -286,14 +238,14 @@ make_del_dir(Config, Handle, Suffix) ->
 	NewDir2 = filename:join(RootDir,
 				atom_to_list(?MODULE)
 				++"_mk-dir-noexist/foo"),
-	{error, enoent} = ?PRIM_FILE_call(make_dir, Handle, [NewDir2]),
+	{error, enoent} = ?PRIM_FILE:make_dir(NewDir2),
 	%% a nameless directory
-	{error, enoent} = ?PRIM_FILE_call(make_dir, Handle, [""]),
+	{error, enoent} = ?PRIM_FILE:make_dir(""),
 	%% a directory with illegal name
-	{error, badarg} = ?PRIM_FILE_call(make_dir, Handle, ['mk-dir']),
+	{error, badarg} = ?PRIM_FILE:make_dir('mk-dir'),
 
 	%% a directory with illegal name, even if it's a (bad) list
-	{error, badarg} = ?PRIM_FILE_call(make_dir, Handle, [[1,2,3,{}]]),
+	{error, badarg} = ?PRIM_FILE:make_dir([1,2,3,{}]),
 
 	%% Maybe this isn't an error, exactly, but worth mentioning anyway:
 	%% ok = ?PRIM_FILE:make_dir([$f,$o,$o,0,$b,$a,$r])),
@@ -306,125 +258,101 @@ make_del_dir(Config, Handle, Suffix) ->
 	%% 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?
-	case ?PRIM_FILE_call(del_dir, Handle, [".."]) of
+	case ?PRIM_FILE:del_dir("..") of
 	    {error, eexist} -> ok;
 	    {error, eacces} -> ok;	%OpenBSD
 	    {error, einval} -> ok		%FreeBSD
 	end,
-	{error, enoent} = ?PRIM_FILE_call(del_dir, Handle, [""]),
-	{error, badarg} = ?PRIM_FILE_call(del_dir, Handle, [[3,2,1,{}]])
+	{error, enoent} = ?PRIM_FILE:del_dir(""),
+	{error, badarg} = ?PRIM_FILE:del_dir([3,2,1,{}])
     after
-	ok = ?PRIM_FILE_call(set_cwd, Handle, [CurrentDir])
+	ok = ?PRIM_FILE:set_cwd(CurrentDir)
     end,
     ok.
 
-cur_dir_0a(Config) when is_list(Config) ->
-    cur_dir_0(Config, []).
-
-cur_dir_0b(Config) when is_list(Config) ->
-    {ok, Handle} = ?PRIM_FILE:start(),
-    Result = cur_dir_0(Config, Handle),
-    ok = ?PRIM_FILE:stop(Handle),
-    Result.
-
-cur_dir_0(Config, Handle) ->
+cur_dir_0(Config) when is_list(Config) ->
     %% Find out the current dir, and cd to it ;-)
-    {ok,BaseDir} = ?PRIM_FILE_call(get_cwd, Handle, []),
+    {ok,BaseDir} = ?PRIM_FILE:get_cwd(),
     Dir1 = BaseDir ++ "", %% Check that it's a string
-    ok = ?PRIM_FILE_call(set_cwd, Handle, [Dir1]),
-    DirName = atom_to_list(?MODULE) ++
-	case Handle of
-	    [] ->
-		"_curdir";
-	    _ ->
-		"_curdir_h"
-	end,
+    ok = ?PRIM_FILE:set_cwd(Dir1),
+    DirName = atom_to_list(?MODULE) ++ "_curdir",
 
     %% Make a new dir, and cd to that
     RootDir = proplists:get_value(priv_dir,Config),
     NewDir = filename:join(RootDir, DirName),
-    ok = ?PRIM_FILE_call(make_dir, Handle, [NewDir]),
+    ok = ?PRIM_FILE: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"),
 	    io:format("\nNewDir = ~p\n", [NewDir]);
 	_ ->
 	    io:format("cd to ~s",[NewDir]),
-	    ok = ?PRIM_FILE_call(set_cwd, Handle, [NewDir]),
+	    ok = ?PRIM_FILE:set_cwd(NewDir),
 
 	    %% Create a file in the new current directory, and check that it
 	    %% really is created there
 	    UncommonName = "uncommon.fil",
 	    {ok,Fd} = ?PRIM_FILE:open(UncommonName, [read, write]),
 	    ok = ?PRIM_FILE:close(Fd),
-	    {ok,NewDirFiles} = ?PRIM_FILE_call(list_dir, Handle, ["."]),
+	    {ok,NewDirFiles} = ?PRIM_FILE:list_dir("."),
 	    true = lists:member(UncommonName,NewDirFiles),
 
 	    %% Delete the directory and return to the old current directory
 	    %% and check that the created file isn't there (too!)
 	    expect({error, einval}, {error, eacces}, {error, eexist},
-		   ?PRIM_FILE_call(del_dir, Handle, [NewDir])),
-	    ?PRIM_FILE_call(delete, Handle, [UncommonName]),
-	    {ok,[]} = ?PRIM_FILE_call(list_dir, Handle, ["."]),
-	    ok = ?PRIM_FILE_call(set_cwd, Handle, [Dir1]),
+		   ?PRIM_FILE:del_dir(NewDir)),
+	    ?PRIM_FILE:delete(UncommonName),
+	    {ok,[]} = ?PRIM_FILE:list_dir("."),
+	    ok = ?PRIM_FILE:set_cwd(Dir1),
 	    io:format("cd back to ~s",[Dir1]),
-	    ok = ?PRIM_FILE_call(del_dir, Handle, [NewDir]),
-	    {error, enoent} = ?PRIM_FILE_call(set_cwd, Handle, [NewDir]),
-	    ok = ?PRIM_FILE_call(set_cwd, Handle, [Dir1]),
+	    ok = ?PRIM_FILE:del_dir(NewDir),
+	    {error, enoent} = ?PRIM_FILE:set_cwd(NewDir),
+	    ok = ?PRIM_FILE:set_cwd(Dir1),
 	    io:format("cd back to ~s",[Dir1]),
-	    {ok,OldDirFiles} = ?PRIM_FILE_call(list_dir, Handle, ["."]),
+	    {ok,OldDirFiles} = ?PRIM_FILE:list_dir("."),
 	    false = lists:member(UncommonName,OldDirFiles)
     end,
 
     %% Try doing some bad things
     {error, badarg} =
-	?PRIM_FILE_call(set_cwd, Handle, [{foo,bar}]),
+	?PRIM_FILE:set_cwd({foo,bar}),
     {error, enoent} =
-	?PRIM_FILE_call(set_cwd, Handle, [""]),
+	?PRIM_FILE:set_cwd(""),
     {error, enoent} =
-	?PRIM_FILE_call(set_cwd, Handle, [".......a......"]),
+	?PRIM_FILE:set_cwd(".......a......"),
     {ok,BaseDir} =
-	?PRIM_FILE_call(get_cwd, Handle, []), %% Still there?
+	?PRIM_FILE: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.)
 
-    {ok, BaseDir} = ?PRIM_FILE_call(get_cwd, Handle, []),
+    {ok, BaseDir} = ?PRIM_FILE:get_cwd(),
     false = lists:member($\\, BaseDir),
 
     ok.
 
 %% Tests ?PRIM_FILE:get_cwd/1.
 
-cur_dir_1a(Config) when is_list(Config) ->
-    cur_dir_1(Config, []).
-
-cur_dir_1b(Config) when is_list(Config) ->
-    {ok, Handle} = ?PRIM_FILE:start(),
-    Result = cur_dir_1(Config, Handle),
-    ok = ?PRIM_FILE:stop(Handle),
-    Result.
-
-cur_dir_1(Config, Handle) ->
+cur_dir_1(Config) when is_list(Config) ->
     case os:type() of
 	{win32, _} ->
-	    win_cur_dir_1(Config, Handle);
+	    win_cur_dir_1(Config);
 	_ ->
 	    {error, enotsup} =
-		?PRIM_FILE_call(get_cwd, Handle, ["d:"])
+		?PRIM_FILE:get_cwd("d:")
     end,
     ok.
 
-win_cur_dir_1(_Config, Handle) ->
-    {ok, BaseDir} = ?PRIM_FILE_call(get_cwd, Handle, []),
+win_cur_dir_1(_Config) ->
+    {ok, BaseDir} = ?PRIM_FILE:get_cwd(),
 
     %% Get the drive letter from the current directory,
     %% and try to get current directory for that drive.
 
     [Drive, $:|_] = BaseDir,
-    {ok, BaseDir} = ?PRIM_FILE_call(get_cwd, Handle, [[Drive, $:]]),
+    {ok, BaseDir} = ?PRIM_FILE:get_cwd([Drive, $:]),
     io:format("BaseDir = ~s\n", [BaseDir]),
 
     %% Unfortunately, there is no way to move away from the
@@ -446,12 +374,12 @@ open1(Config) when is_list(Config) ->
     Name = filename:join(NewDir, "foo1.fil"),
     {ok,Fd1} = ?PRIM_FILE:open(Name, [read, write]),
     {ok,Fd2} = ?PRIM_FILE:open(Name, [read]),
-    Str = "{a,tuple}.\n",
-    Length = length(Str),
-    ?PRIM_FILE:write(Fd1,Str),
+    Bin = list_to_binary("{a,tuple}.\n"),
+    Length = byte_size(Bin),
+    ?PRIM_FILE:write(Fd1,Bin),
     {ok,0} = ?PRIM_FILE:position(Fd1,bof),
-    {ok, Str} = ?PRIM_FILE:read(Fd1,Length),
-    {ok, Str} = ?PRIM_FILE:read(Fd2,Length),
+    {ok, Bin} = ?PRIM_FILE:read(Fd1,Length),
+    {ok, Bin} = ?PRIM_FILE:read(Fd2,Length),
     ok = ?PRIM_FILE:close(Fd2),
     {ok,0} = ?PRIM_FILE:position(Fd1,bof),
     ok = ?PRIM_FILE:truncate(Fd1),
@@ -471,13 +399,13 @@ modes(Config) when is_list(Config) ->
 			   ++"_open_modes"),
     ok = ?PRIM_FILE:make_dir(NewDir),
     Name1 = filename:join(NewDir, "foo1.fil"),
-    Marker = "hello, world",
-    Length = length(Marker),
+    Marker = <<"hello, world">>,
+    Length = byte_size(Marker),
 
     %% write
     {ok, Fd1} = ?PRIM_FILE:open(Name1, [write]),
     ok = ?PRIM_FILE:write(Fd1, Marker),
-    ok = ?PRIM_FILE:write(Fd1, ".\n"),
+    ok = ?PRIM_FILE:write(Fd1, <<".\n">>),
     ok = ?PRIM_FILE:close(Fd1),
 
     %% read
@@ -496,12 +424,6 @@ modes(Config) when is_list(Config) ->
     {ok, Marker} = ?PRIM_FILE:read(Fd4, Length),
     ok = ?PRIM_FILE:close(Fd4),
 
-    %% read and binary
-    BinaryMarker = list_to_binary(Marker),
-    {ok, Fd5} = ?PRIM_FILE:open(Name1, [read, binary]),
-    {ok, BinaryMarker} = ?PRIM_FILE:read(Fd5, Length),
-    ok = ?PRIM_FILE:close(Fd5),
-
     ok.
 
 close(Config) when is_list(Config) ->
@@ -528,9 +450,9 @@ access(Config) when is_list(Config) ->
     Name = filename:join(RootDir,
 			 atom_to_list(?MODULE)
 			 ++"_access.fil"),
-    Str = "ABCDEFGH",
+    Bin = <<"ABCDEFGH">>,
     {ok,Fd1} = ?PRIM_FILE:open(Name, [write]),
-    ?PRIM_FILE:write(Fd1,Str),
+    ?PRIM_FILE:write(Fd1,Bin),
     ok = ?PRIM_FILE:close(Fd1),
     %% Check that we can't write when in read only mode
     {ok,Fd2} = ?PRIM_FILE:open(Name, [read]),
@@ -542,7 +464,7 @@ access(Config) when is_list(Config) ->
     end,
     ok = ?PRIM_FILE:close(Fd2),
     {ok, Fd3} = ?PRIM_FILE:open(Name, [read]),
-    {ok, Str} = ?PRIM_FILE:read(Fd3,length(Str)),
+    {ok, Bin} = ?PRIM_FILE:read(Fd3,byte_size(Bin)),
     ok = ?PRIM_FILE:close(Fd3),
 
     ok.
@@ -564,7 +486,7 @@ read_write(Config) when is_list(Config) ->
     ok.
 
 read_write_test(File) ->
-    Marker = "hello, world",
+    Marker = <<"hello, world">>,
     ok = ?PRIM_FILE:write(File, Marker),
     {ok, 0} = ?PRIM_FILE:position(File, 0),
     {ok, Marker} = ?PRIM_FILE:read(File, 100),
@@ -590,15 +512,15 @@ pread_write(Config) when is_list(Config) ->
     ok.
 
 pread_write_test(File) ->
-    Marker = "hello, world",
-    Len = length(Marker),
+    Marker = <<"hello, world">>,
+    Len = byte_size(Marker),
     ok = ?PRIM_FILE:write(File, Marker),
     {ok, Marker} = ?PRIM_FILE:pread(File, 0, 100),
     eof = ?PRIM_FILE:pread(File, 100, 1),
     ok = ?PRIM_FILE:pwrite(File, Len, Marker),
     {ok, Marker} = ?PRIM_FILE:pread(File, Len, 100),
     eof = ?PRIM_FILE:pread(File, 100, 1),
-    MM = Marker ++ Marker,
+    MM = <<Marker/binary,Marker/binary>>,
     {ok, MM} = ?PRIM_FILE:pread(File, 0, 100),
     ok = ?PRIM_FILE:close(File),
     ok.
@@ -655,24 +577,24 @@ pos1(Config) when is_list(Config) ->
 			 atom_to_list(?MODULE)
 			 ++"_pos1.fil"),
     {ok, Fd1} = ?PRIM_FILE:open(Name, [write]),
-    ?PRIM_FILE:write(Fd1,"ABCDEFGH"),
+    ?PRIM_FILE:write(Fd1,<<"ABCDEFGH">>),
     ok        = ?PRIM_FILE:close(Fd1),
     {ok, Fd2} = ?PRIM_FILE:open(Name, [read]),
 
     %% Start pos is first char
     io:format("Relative positions"),
-    {ok, "A"} = ?PRIM_FILE:read(Fd2,1),
+    {ok, <<"A">>} = ?PRIM_FILE:read(Fd2,1),
     {ok, 2}   = ?PRIM_FILE:position(Fd2,{cur,1}),
-    {ok, "C"} = ?PRIM_FILE:read(Fd2,1),
+    {ok, <<"C">>} = ?PRIM_FILE:read(Fd2,1),
     {ok, 0}   = ?PRIM_FILE:position(Fd2,{cur,-3}),
-    {ok, "A"} = ?PRIM_FILE:read(Fd2,1),
+    {ok, <<"A">>} = ?PRIM_FILE:read(Fd2,1),
     %% Backwards from first char should be an error
     {ok,0}    = ?PRIM_FILE:position(Fd2,{cur,-1}),
     {error, einval} = ?PRIM_FILE:position(Fd2,{cur,-1}),
     %% Reset position and move again
     {ok, 0}   = ?PRIM_FILE:position(Fd2,0),
     {ok, 2}   = ?PRIM_FILE:position(Fd2,{cur,2}),
-    {ok, "C"} = ?PRIM_FILE:read(Fd2,1),
+    {ok, <<"C">>} = ?PRIM_FILE:read(Fd2,1),
     %% Go a lot forwards
     {ok, 13}  = ?PRIM_FILE:position(Fd2,{cur,10}),
     eof       = ?PRIM_FILE:read(Fd2,1),
@@ -684,27 +606,27 @@ pos1(Config) when is_list(Config) ->
     {ok, 8}   = ?PRIM_FILE:position(Fd2,cur),
     eof = ?PRIM_FILE:read(Fd2,1),
     {ok, 7}   = ?PRIM_FILE:position(Fd2,7),
-    {ok, "H"} = ?PRIM_FILE:read(Fd2,1),
+    {ok, <<"H">>} = ?PRIM_FILE:read(Fd2,1),
     {ok, 0}   = ?PRIM_FILE:position(Fd2,0),
-    {ok, "A"} = ?PRIM_FILE:read(Fd2,1),
+    {ok, <<"A">>} = ?PRIM_FILE:read(Fd2,1),
     {ok, 3}   = ?PRIM_FILE:position(Fd2,3),
-    {ok, "D"} = ?PRIM_FILE:read(Fd2,1),
+    {ok, <<"D">>} = ?PRIM_FILE:read(Fd2,1),
     {ok, 12}  = ?PRIM_FILE:position(Fd2,12),
     eof       = ?PRIM_FILE:read(Fd2,1),
     {ok, 3}   = ?PRIM_FILE:position(Fd2,3),
-    {ok, "D"} = ?PRIM_FILE:read(Fd2,1),
+    {ok, <<"D">>} = ?PRIM_FILE:read(Fd2,1),
     %% Try the {bof,X} notation
     {ok, 3}   = ?PRIM_FILE:position(Fd2,{bof,3}),
-    {ok, "D"} = ?PRIM_FILE:read(Fd2,1),
+    {ok, <<"D">>} = ?PRIM_FILE:read(Fd2,1),
 
     %% Try eof positions
     io:format("EOF positions"),
     {ok, 8}   = ?PRIM_FILE:position(Fd2,{eof,0}),
     eof       = ?PRIM_FILE:read(Fd2,1),
     {ok, 7}   = ?PRIM_FILE:position(Fd2,{eof,-1}),
-    {ok, "H"} = ?PRIM_FILE:read(Fd2,1),
+    {ok, <<"H">>} = ?PRIM_FILE:read(Fd2,1),
     {ok, 0}   = ?PRIM_FILE:position(Fd2,{eof,-8}),
-    {ok, "A"} = ?PRIM_FILE:read(Fd2,1),
+    {ok, <<"A">>} = ?PRIM_FILE:read(Fd2,1),
     {error, einval} = ?PRIM_FILE:position(Fd2,{eof,-9}),
     ok.
 
@@ -714,7 +636,7 @@ pos2(Config) when is_list(Config) ->
 			 atom_to_list(?MODULE)
 			 ++"_pos2.fil"),
     {ok,Fd1} = ?PRIM_FILE:open(Name, [write]),
-    ?PRIM_FILE:write(Fd1,"ABCDEFGH"),
+    ?PRIM_FILE:write(Fd1,<<"ABCDEFGH">>),
     ok = ?PRIM_FILE:close(Fd1),
     {ok, Fd2} = ?PRIM_FILE:open(Name, [read]),
     {error, einval} = ?PRIM_FILE:position(Fd2,-1),
@@ -722,35 +644,25 @@ pos2(Config) when is_list(Config) ->
     %% Make sure that we still can search after an error.
     {ok, 0}   = ?PRIM_FILE:position(Fd2, 0),
     {ok, 3}   = ?PRIM_FILE:position(Fd2, {bof,3}),
-    {ok, "D"} = ?PRIM_FILE:read(Fd2,1),
+    {ok, <<"D">>} = ?PRIM_FILE:read(Fd2,1),
 
     io:format("DONE"),
     ok.
 
-
-file_info_basic_file_a(Config) when is_list(Config) ->
-    file_info_basic_file(Config, [], "_a").
-
-file_info_basic_file_b(Config) when is_list(Config) ->
-    {ok, Handle} = ?PRIM_FILE:start(),
-    Result = file_info_basic_file(Config, Handle, "_b"),
-    ok = ?PRIM_FILE:stop(Handle),
-    Result.
-
-file_info_basic_file(Config, Handle, Suffix) ->
+file_info_basic_file(Config) when is_list(Config) ->
     RootDir = proplists:get_value(priv_dir, Config),
 
     %% Create a short file.
     Name = filename:join(RootDir,
 			 atom_to_list(?MODULE)
-			 ++"_basic_test"++Suffix++".fil"),
+			 ++"_basic_test"".fil"),
     {ok,Fd1} = ?PRIM_FILE:open(Name, [write]),
     ?PRIM_FILE:write(Fd1, "foo bar"),
     ok = ?PRIM_FILE: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} = ?PRIM_FILE_call(read_file_info, Handle, [Name]),
+    {ok, FileInfo} = ?PRIM_FILE:read_file_info(Name),
     #file_info{size = Size, type = Type, access = Access,
 	       atime = AccessTime, mtime = ModifyTime} =
 	FileInfo,
@@ -768,39 +680,30 @@ file_info_basic_file(Config, Handle, Suffix) ->
 
     ok.
 
-file_info_basic_directory_a(Config) when is_list(Config) ->
-    file_info_basic_directory(Config, []).
-
-file_info_basic_directory_b(Config) when is_list(Config) ->
-    {ok, Handle} = ?PRIM_FILE:start(),
-    Result = file_info_basic_directory(Config, Handle),
-    ok = ?PRIM_FILE:stop(Handle),
-    Result.
-
-file_info_basic_directory(Config, Handle) ->
+file_info_basic_directory(Config) when is_list(Config) ->
     %% Note: filename:join/1 removes any trailing slash,
     %% which is essential for ?PRIM_FILE:read_file_info/1 to work on
     %% platforms such as Windows95.
     RootDir = filename:join([proplists:get_value(priv_dir, Config)]),
 
     %% Test that the RootDir directory has the expected attributes.
-    test_directory(RootDir, read_write, Handle),
+    test_directory(RootDir, read_write),
 
     %% Note that on Windows file systems, "/" or "c:/" are *NOT* directories.
     %% Therefore, test that ?PRIM_FILE:read_file_info/1 behaves 
     %% as if they were directories.
     case os:type() of
 	{win32, _} ->
-	    test_directory("/", read_write, Handle),
-	    test_directory("c:/", read_write, Handle),
-	    test_directory("c:\\", read_write, Handle);
+	    test_directory("/", read_write),
+	    test_directory("c:/", read_write),
+	    test_directory("c:\\", read_write);
 	_ ->
-	    test_directory("/", read, Handle)
+	    test_directory("/", read)
     end,
     ok.
 
-test_directory(Name, ExpectedAccess, Handle) ->
-    {ok, FileInfo} = ?PRIM_FILE_call(read_file_info, Handle, [Name]),
+test_directory(Name, ExpectedAccess) ->
+    {ok, FileInfo} = ?PRIM_FILE:read_file_info(Name),
     #file_info{size = Size, type = Type, access = Access,
 	       atime = AccessTime, mtime = ModifyTime} =
 	FileInfo,
@@ -824,45 +727,24 @@ all_integers([]) ->
 
 %% Try something nonexistent.
 
-file_info_bad_a(Config) when is_list(Config) ->
-    file_info_bad(Config, []).
-
-file_info_bad_b(Config) when is_list(Config) ->
-    {ok, Handle} = ?PRIM_FILE:start(),
-    Result = file_info_bad(Config, Handle),
-    ok = ?PRIM_FILE:stop(Handle),
-    Result.
-
-file_info_bad(Config, Handle) ->
+file_info_bad(Config) when is_list(Config) ->
     RootDir = filename:join([proplists:get_value(priv_dir, Config)]),
-    {error, enoent} =
-	?PRIM_FILE_call(
-	   read_file_info, Handle, 
-	   [filename:join(RootDir,
-			  atom_to_list(?MODULE)++"_nonexistent")]),
+    NonExistent = filename:join(RootDir, atom_to_list(?MODULE)++"_nonexistent"),
+    {error, enoent} = ?PRIM_FILE:read_file_info(NonExistent),
     ok.
 
 %% Test that the file times behave as they should.
 
-file_info_times_a(Config) when is_list(Config) ->
-    file_info_times(Config, [], "_a").
-
-file_info_times_b(Config) when is_list(Config) ->
-    {ok, Handle} = ?PRIM_FILE:start(),
-    Result = file_info_times(Config, Handle, "_b"),
-    ok = ?PRIM_FILE:stop(Handle),
-    Result.
-
-file_info_times(Config, Handle, Suffix) ->
+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.
     test_server:m_out_of_n(
       1,2,
-      fun() -> file_info_int(Config, Handle, Suffix) end),
+      fun() -> file_info_int(Config) end),
     ok.
 
-file_info_int(Config, Handle, Suffix) ->
+file_info_int(Config) ->
     %% Note: filename:join/1 removes any trailing slash,
     %% which is essential for ?PRIM_FILE:read_file_info/1 to work on
     %% platforms such as Windows95.
@@ -872,14 +754,14 @@ file_info_int(Config, Handle, Suffix) ->
 
     Name = filename:join(RootDir,
 			 atom_to_list(?MODULE)
-			 ++"_file_info"++Suffix++".fil"),
+			 ++"_file_info.fil"),
     {ok,Fd1} = ?PRIM_FILE:open(Name, [write]),
     ?PRIM_FILE:write(Fd1,"foo"),
 
     %% check that the file got a modify date max a few seconds away from now
     {ok, #file_info{type = regular,
 		    atime = AccTime1, mtime = ModTime1}} =
-	?PRIM_FILE_call(read_file_info, Handle, [Name]),
+	?PRIM_FILE:read_file_info(Name),
     Now = erlang:localtime(),
     io:format("Now ~p",[Now]),
     io:format("Open file Acc ~p Mod ~p",[AccTime1,ModTime1]),
@@ -897,7 +779,7 @@ file_info_int(Config, Handle, Suffix) ->
     ok = ?PRIM_FILE:close(Fd1),
     {ok, #file_info{size = Size, type = regular, access = Access,
 		    atime = AccTime2, mtime = ModTime2}} =
-	?PRIM_FILE_call(read_file_info, Handle, [Name]),
+	?PRIM_FILE:read_file_info(Name),
     io:format("Closed file Acc ~p Mod ~p",[AccTime2,ModTime2]),
     true = time_dist(ModTime1, ModTime2) >= 0,
 
@@ -909,7 +791,7 @@ file_info_int(Config, Handle, Suffix) ->
     {ok, #file_info{size = DSize, type = directory,
 		    access = DAccess,
 		    atime = AccTime3, mtime = ModTime3}} =
-	?PRIM_FILE_call(read_file_info, Handle, [RootDir]),
+	?PRIM_FILE:read_file_info(RootDir),
     %% this dir was modified only a few secs ago
     io:format("Dir Acc ~p; Mod ~p; Now ~p",
 	      [AccTime3, ModTime3, Now]),
@@ -936,16 +818,7 @@ filter_atime(Atime, Config) ->
 
 %% Test the write_file_info/2 function.
 
-file_write_file_info_a(Config) when is_list(Config) ->
-    file_write_file_info(Config, [], "_a").
-
-file_write_file_info_b(Config) when is_list(Config) ->
-    {ok, Handle} = ?PRIM_FILE:start(),
-    Result = file_write_file_info(Config, Handle, "_b"),
-    ok = ?PRIM_FILE:stop(Handle),
-    Result.
-
-file_write_file_info(Config, Handle, Suffix) ->
+file_write_file_info(Config) when is_list(Config) ->
     RootDir = get_good_directory(Config),
     io:format("RootDir = ~p", [RootDir]),
 
@@ -955,16 +828,16 @@ file_write_file_info(Config, Handle, Suffix) ->
 
     Name = filename:join(RootDir,
 			 atom_to_list(?MODULE)
-			 ++"_write_file_info_ro"++Suffix),
+			 ++"_write_file_info_ro"),
     ok = ?PRIM_FILE:write_file(Name, "hello"),
     Time = {{1997, 01, 02}, {12, 35, 42}},
     Info = #file_info{mode=8#400, atime=Time, mtime=Time, ctime=Time},
-    ok = ?PRIM_FILE_call(write_file_info, Handle, [Name, Info]),
+    ok = ?PRIM_FILE:write_file_info(Name, Info),
 
     %% Read back the times.
 
     {ok, ActualInfo} =
-	?PRIM_FILE_call(read_file_info, Handle, [Name]),
+	?PRIM_FILE:read_file_info(Name),
     #file_info{mode=_Mode, atime=ActAtime, mtime=Time,
 	       ctime=ActCtime} = ActualInfo,
     FilteredAtime = filter_atime(Time, Config),
@@ -980,14 +853,11 @@ file_write_file_info(Config, Handle, Suffix) ->
     {error, eacces} = ?PRIM_FILE:write_file(Name, "hello again"),
 
     %% Make the file writable again.
-
-    ?PRIM_FILE_call(write_file_info, Handle,
-		    [Name, #file_info{mode=8#600}]),
+    ?PRIM_FILE:write_file_info(Name, #file_info{mode=8#600}),
     ok = ?PRIM_FILE:write_file(Name, "hello again"),
 
     %% And unwritable.
-    ?PRIM_FILE_call(write_file_info, Handle,
-		    [Name, #file_info{mode=8#400}]),
+    ?PRIM_FILE:write_file_info(Name, #file_info{mode=8#400}),
     {error, eacces} = ?PRIM_FILE:write_file(Name, "hello again"),
 
     %% Write the times again.
@@ -995,9 +865,9 @@ file_write_file_info(Config, Handle, Suffix) ->
 
     NewTime = {{1997, 02, 15}, {13, 18, 20}},
     NewInfo = #file_info{atime=NewTime, mtime=NewTime, ctime=NewTime},
-    ok = ?PRIM_FILE_call(write_file_info, Handle, [Name, NewInfo]),
+    ok = ?PRIM_FILE:write_file_info(Name, NewInfo),
     {ok, ActualInfo2} =
-	?PRIM_FILE_call(read_file_info, Handle, [Name]),
+	?PRIM_FILE:read_file_info(Name),
     #file_info{atime=NewActAtime, mtime=NewTime,
 	       ctime=NewActCtime} = ActualInfo2,
     NewFilteredAtime = filter_atime(NewTime, Config),
@@ -1012,14 +882,12 @@ file_write_file_info(Config, Handle, Suffix) ->
 
     %% Make the file writeable again, so that we can remove the
     %% test suites ... :-)
-    ?PRIM_FILE_call(write_file_info, Handle,
-		    [Name, #file_info{mode=8#600}]),
+    ?PRIM_FILE:write_file_info(Name, #file_info{mode=8#600}),
     ok.
 
 %% Test the write_file_info/3 function.
 
 file_write_file_info_opts(Config) when is_list(Config) ->
-    {ok, Handle} = ?PRIM_FILE:start(),
     RootDir = get_good_directory(Config),
     io:format("RootDir = ~p", [RootDir]),
 
@@ -1028,7 +896,7 @@ file_write_file_info_opts(Config) when is_list(Config) ->
 
     lists:foreach(fun
 		      ({FI, Opts}) ->
-			 ok = ?PRIM_FILE_call(write_file_info, Handle, [Name, FI, Opts])
+			 ok = ?PRIM_FILE:write_file_info(Name, FI, Opts)
 		 end, [
 			{#file_info{ mode=8#600, atime = Time, mtime = Time, ctime = Time}, Opts} ||
 			  Opts <- [[{time, posix}]],
@@ -1038,7 +906,7 @@ file_write_file_info_opts(Config) when is_list(Config) ->
     %% REM: determine date range dependent on time_t = Uint32 | Sint32 | Sint64 | Uint64
     %% Determine time_t on os:type()?
     lists:foreach(fun ({FI, Opts}) ->
-			 ok = ?PRIM_FILE_call(write_file_info, Handle, [Name, FI, Opts])
+			 ok = ?PRIM_FILE:write_file_info(Name, FI, Opts)
 		 end, [ {#file_info{ mode=8#400, atime = Time, mtime = Time, ctime = Time}, Opts} ||
 			  Opts <- [[{time, universal}],[{time, local}]],
 			  Time <- [
@@ -1050,11 +918,9 @@ file_write_file_info_opts(Config) when is_list(Config) ->
 				   {{2037,2,3},{23,59,59}},
 				   erlang:localtime()
 				  ]]),
-    ok   = ?PRIM_FILE:stop(Handle),
     ok.
 
 file_read_file_info_opts(Config) when is_list(Config) ->
-    {ok, Handle} = ?PRIM_FILE:start(),
     RootDir = get_good_directory(Config),
     io:format("RootDir = ~p", [RootDir]),
 
@@ -1063,41 +929,38 @@ file_read_file_info_opts(Config) when is_list(Config) ->
 
     lists:foreach(fun
 		      (Opts) ->
-			 {ok,_} = ?PRIM_FILE_call(read_file_info, Handle, [Name, Opts])
+			 {ok,_} = ?PRIM_FILE:read_file_info(Name, Opts)
 		 end, [[{time, Type}] || Type <- [local, universal, posix]]),
-    ok   = ?PRIM_FILE:stop(Handle),
     ok.
 
 %% Test the write and read back *_file_info/3 functions.
 
 file_write_read_file_info_opts(Config) when is_list(Config) ->
-    {ok, Handle} = ?PRIM_FILE:start(),
     RootDir = get_good_directory(Config),
     io:format("RootDir = ~p", [RootDir]),
 
     Name = filename:join(RootDir, atom_to_list(?MODULE) ++"_read_write_file_info_opts"),
     ok   = ?PRIM_FILE:write_file(Name, "hello_opts2"),
 
-    ok = file_write_read_file_info_opts(Handle, Name, {{1989, 04, 28}, {19,30,22}}, [{time, local}]),
-    ok = file_write_read_file_info_opts(Handle, Name, {{1989, 04, 28}, {19,30,22}}, [{time, universal}]),
+    ok = file_write_read_file_info_opts(Name, {{1989, 04, 28}, {19,30,22}}, [{time, local}]),
+    ok = file_write_read_file_info_opts(Name, {{1989, 04, 28}, {19,30,22}}, [{time, universal}]),
     %% will not work on platforms with unsigned time_t
-    %ok = file_write_read_file_info_opts(Handle, Name, {{1930, 04, 28}, {19,30,22}}, [{time, local}]),
-    %ok = file_write_read_file_info_opts(Handle, Name, {{1930, 04, 28}, {19,30,22}}, [{time, universal}]),
-    ok = file_write_read_file_info_opts(Handle, Name, 1, [{time, posix}]),
+    %ok = file_write_read_file_info_opts(Name, {{1930, 04, 28}, {19,30,22}}, [{time, local}]),
+    %ok = file_write_read_file_info_opts(Name, {{1930, 04, 28}, {19,30,22}}, [{time, universal}]),
+    ok = file_write_read_file_info_opts(Name, 1, [{time, posix}]),
     %% will not work on platforms with unsigned time_t
-    %ok = file_write_read_file_info_opts(Handle, Name, -1, [{time, posix}]),
-    %ok = file_write_read_file_info_opts(Handle, Name, -300000, [{time, posix}]),
-    ok = file_write_read_file_info_opts(Handle, Name, 300000, [{time, posix}]),
-    ok = file_write_read_file_info_opts(Handle, Name, 0, [{time, posix}]),
+    %ok = file_write_read_file_info_opts(Name, -1, [{time, posix}]),
+    %ok = file_write_read_file_info_opts(Name, -300000, [{time, posix}]),
+    ok = file_write_read_file_info_opts(Name, 300000, [{time, posix}]),
+    ok = file_write_read_file_info_opts(Name, 0, [{time, posix}]),
 
-    ok = ?PRIM_FILE:stop(Handle),
     ok.
 
-file_write_read_file_info_opts(Handle, Name, Mtime, Opts) ->
-    {ok, FI} = ?PRIM_FILE_call(read_file_info, Handle, [Name, Opts]),
+file_write_read_file_info_opts(Name, Mtime, Opts) ->
+    {ok, FI} = ?PRIM_FILE:read_file_info(Name, Opts),
     FI2 = FI#file_info{ mtime = Mtime },
-    ok = ?PRIM_FILE_call(write_file_info, Handle, [Name, FI2, Opts]),
-    {ok, FI3} = ?PRIM_FILE_call(read_file_info, Handle, [Name, Opts]),
+    ok = ?PRIM_FILE:write_file_info(Name, FI2, Opts),
+    {ok, FI3} = ?PRIM_FILE:read_file_info(Name, Opts),
     io:format("Expecting mtime = ~p, got ~p~n", [FI2#file_info.mtime, FI3#file_info.mtime]),
     FI2 = FI3,
     ok.
@@ -1175,8 +1038,8 @@ advise(Config) when is_list(Config) ->
 			   atom_to_list(?MODULE)
 			   ++"_advise.fil"),
 
-    Line1 = "Hello\n",
-    Line2 = "World!\n",
+    Line1 = <<"Hello\n">>,
+    Line2 = <<"World!\n">>,
 
     {ok, Fd} = ?PRIM_FILE:open(Advise, [write]),
     ok = ?PRIM_FILE:advise(Fd, 0, 0, normal),
@@ -1226,7 +1089,7 @@ advise(Config) when is_list(Config) ->
     {ok, Fd9} = ?PRIM_FILE:open(Advise, [read]),
     Offset = 0,
     %% same as a 0 length in some implementations
-    Length = length(Line1) + length(Line2),
+    Length = byte_size(Line1) + byte_size(Line2),
     ok = ?PRIM_FILE:advise(Fd9, Offset, Length, sequential),
     {ok, Line1} = ?PRIM_FILE:read_line(Fd9),
     {ok, Line2} = ?PRIM_FILE:read_line(Fd9),
@@ -1251,10 +1114,10 @@ do_large_write(Name) ->
     Data = zip_data(lists:duplicate(Chunks, Chunk), Interleave),
     Size = Chunks * ChunkSize + Chunks,	% 4 G + 32
     Wordsize = erlang:system_info(wordsize),
-    case prim_file:write_file(Name, Data) of
+    case ?PRIM_FILE:write_file(Name, Data) of
 	ok when Wordsize =:= 8 ->
 	    {ok,#file_info{size=Size}} = file:read_file_info(Name),
-	    {ok,Fd} = prim_file:open(Name, [read]),
+	    {ok,Fd} = ?PRIM_FILE:open(Name, [read]),
 	    check_large_write(Fd, ChunkSize, 0, Interleave);
 	{error,einval} when Wordsize =:= 4 ->
 	    ok
@@ -1262,11 +1125,11 @@ do_large_write(Name) ->
 
 check_large_write(Fd, ChunkSize, Pos, [X|Interleave]) ->
     Pos1 = Pos + ChunkSize,
-    {ok,Pos1} = prim_file:position(Fd, {cur,ChunkSize}),
-    {ok,[X]} = prim_file:read(Fd, 1),
+    {ok,Pos1} = ?PRIM_FILE:position(Fd, {cur,ChunkSize}),
+    {ok,<<X>>} = ?PRIM_FILE:read(Fd, 1),
     check_large_write(Fd, ChunkSize, Pos1+1, Interleave);
 check_large_write(Fd, _, _, []) ->
-    eof = prim_file:read(Fd, 1),
+    eof = ?PRIM_FILE:read(Fd, 1),
     ok.
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
@@ -1338,71 +1201,53 @@ allocate_and_assert(Fd, Offset, Length) ->
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
-delete_a(Config) when is_list(Config) ->
-    delete(Config, [], "_a").
-
-delete_b(Config) when is_list(Config) ->
-    {ok, Handle} = ?PRIM_FILE:start(),
-    Result = delete(Config, Handle, "_b"),
-    ok = ?PRIM_FILE:stop(Handle),
-    Result.
-
-delete(Config, Handle, Suffix) ->
+delete(Config) when is_list(Config) ->
     RootDir = proplists:get_value(priv_dir,Config),
     Name = filename:join(RootDir,
 			 atom_to_list(?MODULE)
-			 ++"_delete"++Suffix++".fil"),
+			 ++"_delete.fil"),
     {ok, Fd1} = ?PRIM_FILE:open(Name, [write]),
     ?PRIM_FILE:write(Fd1,"ok.\n"),
     ok = ?PRIM_FILE:close(Fd1),
     %% Check that the file is readable
     {ok, Fd2} = ?PRIM_FILE:open(Name, [read]),
     ok = ?PRIM_FILE:close(Fd2),
-    ok = ?PRIM_FILE_call(delete, Handle, [Name]),
+    ok = ?PRIM_FILE:delete(Name),
     %% Check that the file is not readable anymore
     {error, _} = ?PRIM_FILE:open(Name, [read]),
     %% Try deleting a nonexistent file
-    {error, enoent} = ?PRIM_FILE_call(delete, Handle, [Name]),
+    {error, enoent} = ?PRIM_FILE:delete(Name),
     ok.
 
-rename_a(Config) when is_list(Config) ->
-    rename(Config, [], "_a").
-
-rename_b(Config) when is_list(Config) ->
-    {ok, Handle} = ?PRIM_FILE:start(),
-    Result = rename(Config, Handle, "_b"),
-    ok = ?PRIM_FILE:stop(Handle),
-    Result.
-
-rename(Config, Handle, Suffix) ->
+rename(Config) when is_list(Config) ->
     RootDir = proplists:get_value(priv_dir,Config),
-    FileName1 = atom_to_list(?MODULE)++"_rename"++Suffix++".fil",
-    FileName2 = atom_to_list(?MODULE)++"_rename"++Suffix++".ful",
+    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} = ?PRIM_FILE:open(Name1, [write]),
     ok = ?PRIM_FILE:close(Fd1),
     %% Rename, and check that it really changed name
-    ok = ?PRIM_FILE_call(rename, Handle, [Name1, Name2]),
+    ok = ?PRIM_FILE:rename(Name1, Name2),
     {error, _} = ?PRIM_FILE:open(Name1, [read]),
     {ok, Fd2} = ?PRIM_FILE:open(Name2, [read]),
     ok = ?PRIM_FILE:close(Fd2),
     %% Try renaming something to itself
-    ok = ?PRIM_FILE_call(rename, Handle, [Name2, Name2]),
+    ok = ?PRIM_FILE:rename(Name2, Name2),
     %% Try renaming something that doesn't exist
     {error, enoent} =
-	?PRIM_FILE_call(rename, Handle, [Name1, Name2]),
+	?PRIM_FILE:rename(Name1, Name2),
     %% Try renaming to something else than a string
     {error, badarg} =
-	?PRIM_FILE_call(rename, Handle, [Name1, foobar]),
+	?PRIM_FILE:rename(Name1, foobar),
 
     %% Move between directories
     DirName1 = filename:join(RootDir,
 			     atom_to_list(?MODULE)
-			     ++"_rename_dir"++Suffix),
+			     ++"_rename_dir"),
     DirName2 = filename:join(RootDir,
 			     atom_to_list(?MODULE)
-			     ++"_second_rename_dir"++Suffix),
+			     ++"_second_rename_dir"),
     Name1foo = filename:join(DirName1, "foo.fil"),
     Name2foo = filename:join(DirName2, "foo.fil"),
     Name2bar = filename:join(DirName2, "bar.dir"),
@@ -1410,21 +1255,21 @@ rename(Config, Handle, Suffix) ->
     %% The name has to include the full file name, path is not enough
     expect(
       {error, eexist}, {error, eisdir},
-      ?PRIM_FILE_call(rename, Handle, [Name2, DirName1])),
+      ?PRIM_FILE:rename(Name2, DirName1)),
     ok =
-	?PRIM_FILE_call(rename, Handle, [Name2, Name1foo]),
+	?PRIM_FILE:rename(Name2, Name1foo),
     %% Now rename the directory
-    ok = ?PRIM_FILE_call(rename, Handle, [DirName1, DirName2]),
+    ok = ?PRIM_FILE:rename(DirName1, DirName2),
     %% And check that the file is there now
     {ok,Fd3} = ?PRIM_FILE:open(Name2foo, [read]),
     ok = ?PRIM_FILE:close(Fd3),
     %% Try some dirty things now: move the directory into itself
     {error, Msg1} =
-	?PRIM_FILE_call(rename, Handle, [DirName2, Name2bar]),
+	?PRIM_FILE:rename(DirName2, Name2bar),
     io:format("Errmsg1: ~p",[Msg1]),
     %% move dir into a file in itself
     {error, Msg2} =
-	?PRIM_FILE_call(rename, Handle, [DirName2, Name2foo]),
+	?PRIM_FILE:rename(DirName2, Name2foo),
     io:format("Errmsg2: ~p",[Msg2]),
 
     ok.
@@ -1657,165 +1502,19 @@ e_del_dir(Config) when is_list(Config) ->
     ok.
 
 
-%% Trying reading and positioning from a compressed file.
-
-read_compressed(Config) when is_list(Config) ->
-    Data = proplists:get_value(data_dir, Config),
-    Real = filename:join(Data, "realmen.html.gz"),
-    {ok, Fd} = ?PRIM_FILE:open(Real, [read, compressed]),
-    try_read_file(Fd).
-
-%% Trying reading and positioning from an uncompressed file,
-%% but with the compressed flag given.
-
-read_not_really_compressed(Config) when is_list(Config) ->
-    Data = proplists:get_value(data_dir, Config),
-    Priv = proplists:get_value(priv_dir, Config),
-
-    %% The file realmen.html might have got CRs added (by WinZip).
-    %% Remove them, or the file positions will not be correct.
-
-    Real = filename:join(Data, "realmen.html"),
-    RealPriv = filename:join(Priv,
-			     atom_to_list(?MODULE)++"_realmen.html"),
-    {ok, RealDataBin} = ?PRIM_FILE:read_file(Real),
-    RealData = remove_crs(binary_to_list(RealDataBin), []),
-    ok = ?PRIM_FILE:write_file(RealPriv, RealData),
-    {ok, Fd} = ?PRIM_FILE:open(RealPriv, [read, compressed]),
-    try_read_file(Fd).
-
-remove_crs([$\r|Rest], Result) ->
-    remove_crs(Rest, Result);
-remove_crs([C|Rest], Result) ->
-    remove_crs(Rest, [C|Result]);
-remove_crs([], Result) ->
-    lists:reverse(Result).
-
-try_read_file(Fd) ->
-    %% Seek to the current position (nothing should happen).
-
-    {ok, 0} = ?PRIM_FILE:position(Fd, 0),
-    {ok, 0} = ?PRIM_FILE:position(Fd, {cur, 0}),
-
-    %% Read a few lines from a compressed file.
-
-    ShouldBe = "<TITLE>Real Programmers Don't Use PASCAL</TITLE>\n",
-    {ok, ShouldBe} = ?PRIM_FILE:read(Fd, length(ShouldBe)),
-
-    %% Now seek forward.
-
-    {ok, 381} = ?PRIM_FILE:position(Fd, 381),
-    Back = "Back in the good old days -- the \"Golden Era\" " ++
-	"of computers, it was\n",
-    {ok, Back} = ?PRIM_FILE:read(Fd, length(Back)),
-
-    %% Try to search forward relative to the current position.
-
-    {ok, CurPos} = ?PRIM_FILE:position(Fd, {cur, 0}),
-    RealPos = 4273,
-    {ok, RealPos} = ?PRIM_FILE:position(Fd, {cur, RealPos-CurPos}),
-    RealProg = "<LI> Real Programmers aren't afraid to use GOTOs.\n",
-    {ok, RealProg} = ?PRIM_FILE:read(Fd, length(RealProg)),
-
-    %% Seek backward.
-
-    AfterTitle = length("<TITLE>"),
-    {ok, AfterTitle} = ?PRIM_FILE:position(Fd, AfterTitle),
-    Title = "Real Programmers Don't Use PASCAL</TITLE>\n",
-    {ok, Title} = ?PRIM_FILE:read(Fd, length(Title)),
-
-    %% Done.
-
-    ?PRIM_FILE:close(Fd),
-    ok.
-
-write_compressed(Config) when is_list(Config) ->
-    Priv = proplists:get_value(priv_dir, Config),
-    MyFile = filename:join(Priv,
-			   atom_to_list(?MODULE)++"_test.gz"),
-
-    %% Write a file.
-
-    {ok, Fd} = ?PRIM_FILE:open(MyFile, [write, compressed]),
-    {ok, 0} = ?PRIM_FILE:position(Fd, 0),
-    Prefix = "hello\n",
-    End = "end\n",
-    ok = ?PRIM_FILE:write(Fd, Prefix),
-    {ok, 143} = ?PRIM_FILE:position(Fd, 143),
-    ok = ?PRIM_FILE:write(Fd, End),
-    ok = ?PRIM_FILE:close(Fd),
-
-    %% Read the file and verify the contents.
-
-    {ok, Fd1} = ?PRIM_FILE:open(MyFile, [read, compressed]),
-    {ok, Prefix} = ?PRIM_FILE:read(Fd1, length(Prefix)),
-    Second = lists:duplicate(143-length(Prefix), 0) ++ End,
-    {ok, Second} = ?PRIM_FILE:read(Fd1, length(Second)),
-    ok = ?PRIM_FILE:close(Fd1),
-
-    %% Ensure that the file is compressed.
-
-    TotalSize = 143 + length(End),
-    case ?PRIM_FILE:read_file_info(MyFile) of
-	{ok, #file_info{size=Size}} when Size < TotalSize ->
-	    ok;
-	{ok, #file_info{size=Size}} when Size == TotalSize ->
-	    ct:fail(file_not_compressed)
-    end,
-
-    %% Write again to ensure that the file is truncated.
-
-    {ok, Fd2} = ?PRIM_FILE:open(MyFile, [write, compressed]),
-    NewString = "aaaaaaaaaaa",
-    ok = ?PRIM_FILE:write(Fd2, NewString),
-    ok = ?PRIM_FILE:close(Fd2),
-    {ok, Fd3} = ?PRIM_FILE:open(MyFile, [read, compressed]),
-    {ok, NewString} = ?PRIM_FILE:read(Fd3, 1024),
-    ok = ?PRIM_FILE:close(Fd3),
-
-    ok.
-
-compress_errors(Config) when is_list(Config) ->
-    Data = proplists:get_value(data_dir, Config),
-    {error, enoent} = ?PRIM_FILE:open("non_existing__",
-				      [compressed, read]),
-    {error, einval} = ?PRIM_FILE:open("non_existing__",
-				      [compressed, read, write]),
-
-    %% Read a corrupted .gz file.
-
-    Corrupted = filename:join(Data, "corrupted.gz"),
-    {ok, Fd} = ?PRIM_FILE:open(Corrupted, [read, compressed]),
-    {error, eio} = ?PRIM_FILE:read(Fd, 100),
-    ?PRIM_FILE:close(Fd),
-
-    ok.
-
-
-%% Test creating a hard link.
-make_link_a(Config) when is_list(Config) ->
-    make_link(Config, [], "_a").
-
-%% Test creating a hard link.
-make_link_b(Config) when is_list(Config) ->
-    {ok, Handle} = ?PRIM_FILE:start(),
-    Result = make_link(Config, Handle, "_b"),
-    ok = ?PRIM_FILE:stop(Handle),
-    Result.
-
-make_link(Config, Handle, Suffix) ->
+make_link(Config) when is_list(Config) ->
     RootDir = proplists:get_value(priv_dir, Config),
     NewDir = filename:join(RootDir,
 			   atom_to_list(?MODULE)
-			   ++"_make_link"++Suffix),
-    ok = ?PRIM_FILE_call(make_dir, Handle, [NewDir]),
+			   ++"_make_link"),
+    ok = ?PRIM_FILE:make_dir(NewDir),
 
     Name = filename:join(NewDir, "a_file"),
     ok = ?PRIM_FILE:write_file(Name, "some contents\n"),
 
     Alias = filename:join(NewDir, "an_alias"),
     Result =
-	case ?PRIM_FILE_call(make_link, Handle, [Name, Alias]) of
+	case ?PRIM_FILE:make_link(Name, Alias) of
 	    {error, enotsup} ->
 		{skipped, "Links not supported on this platform"};
 	    ok ->
@@ -1826,12 +1525,12 @@ make_link(Config, Handle, Suffix) ->
 		%% since they are not used on symbolic links.
 
 		{ok, Info} =
-		    ?PRIM_FILE_call(read_link_info, Handle, [Name]),
+		    ?PRIM_FILE:read_link_info(Name),
 		{ok, Info} =
-		    ?PRIM_FILE_call(read_link_info, Handle, [Alias]),
+		    ?PRIM_FILE:read_link_info(Alias),
 		#file_info{links = 2, type = regular} = Info,
 		{error, eexist} =
-		    ?PRIM_FILE_call(make_link, Handle, [Name, Alias]),
+		    ?PRIM_FILE:make_link(Name, Alias),
 		ok
 	end,
 
@@ -1843,30 +1542,19 @@ read_link_info_for_non_link(Config) when is_list(Config) ->
     {ok, #file_info{type=directory}} = ?PRIM_FILE:read_link_info("."),
     ok.
 
-%% Test operations on symbolic links (for Unix).
-symlinks_a(Config) when is_list(Config) ->
-    symlinks(Config, [], "_a").
-
-%% Test operations on symbolic links (for Unix).
-symlinks_b(Config) when is_list(Config) ->
-    {ok, Handle} = ?PRIM_FILE:start(),
-    Result = symlinks(Config, Handle, "_b"),
-    ok = ?PRIM_FILE:stop(Handle),
-    Result.
-
-symlinks(Config, Handle, Suffix) ->
+symlinks(Config) when is_list(Config)  ->
     RootDir = proplists:get_value(priv_dir, Config),
     NewDir = filename:join(RootDir,
 			   atom_to_list(?MODULE)
-			   ++"_make_symlink"++Suffix),
-    ok = ?PRIM_FILE_call(make_dir, Handle, [NewDir]),
+			   ++"_make_symlink"),
+    ok = ?PRIM_FILE:make_dir(NewDir),
 
     Name = filename:join(NewDir, "a_plain_file"),
     ok = ?PRIM_FILE:write_file(Name, "some stupid content\n"),
 
     Alias = filename:join(NewDir, "a_symlink_alias"),
     Result =
-	case ?PRIM_FILE_call(make_symlink, Handle, [Name, Alias]) of
+	case ?PRIM_FILE:make_symlink(Name, Alias) of
 	    {error, enotsup} ->
 		{skipped, "Links not supported on this platform"};
 	    {error, eperm} ->
@@ -1874,20 +1562,20 @@ symlinks(Config, Handle, Suffix) ->
 		{skipped, "Windows user not privileged to create links"};
 	    ok ->
 		{ok, Info1} =
-		    ?PRIM_FILE_call(read_file_info, Handle, [Name]),
+		    ?PRIM_FILE:read_file_info(Name),
 		{ok, Info1} =
-		    ?PRIM_FILE_call(read_file_info, Handle, [Alias]),
+		    ?PRIM_FILE:read_file_info(Alias),
 		{ok, Info1} =
-		    ?PRIM_FILE_call(read_link_info, Handle, [Name]),
+		    ?PRIM_FILE:read_link_info(Name),
 		#file_info{links = 1, type = regular} = Info1,
 
 		{ok, Info2} =
-		    ?PRIM_FILE_call(read_link_info, Handle, [Alias]),
+		    ?PRIM_FILE:read_link_info(Alias),
 		#file_info{links=1, type=symlink} = Info2,
 		{ok, Name} =
-		    ?PRIM_FILE_call(read_link, Handle, [Alias]),
+		    ?PRIM_FILE:read_link(Alias),
 		{ok, Name} =
-		    ?PRIM_FILE_call(read_link_all, Handle, [Alias]),
+		    ?PRIM_FILE:read_link_all(Alias),
 		%% If all is good, delete dir again (avoid hanging dir on windows)
 		rm_rf(?PRIM_FILE,NewDir),
 		ok
@@ -1907,10 +1595,9 @@ list_dir_limit(Config) when is_list(Config) ->
     RootDir = proplists:get_value(priv_dir, Config),
     NewDir = filename:join(RootDir,
 			   atom_to_list(?MODULE)++"_list_dir_limit"),
-    {ok, Handle1} = ?PRIM_FILE:start(),
-    ok = ?PRIM_FILE_call(make_dir, Handle1, [NewDir]),
+    ok = ?PRIM_FILE:make_dir(NewDir),
     Ref = erlang:start_timer(MaxTime*1000, self(), []),
-    Result = list_dir_limit_loop(NewDir, Handle1, Ref, MaxNumber, 0),
+    Result = list_dir_limit_loop(NewDir, Ref, MaxNumber, 0),
     Time = case erlang:cancel_timer(Ref) of
 	       false -> MaxTime;
 	       T -> MaxTime - (T div 1000)
@@ -1920,21 +1607,18 @@ list_dir_limit(Config) when is_list(Config) ->
 		 {error, _Reason, N} -> N;
 		 _ -> 0
 	     end,
-    {ok, Handle2} = ?PRIM_FILE:start(),
-    list_dir_limit_cleanup(NewDir, Handle2, Number, 0),
-    ok = ?PRIM_FILE:stop(Handle1),
-    ok = ?PRIM_FILE:stop(Handle2),
+    list_dir_limit_cleanup(NewDir, Number, 0),
     {ok, Number} = Result,
     {comment, 
      "Created " ++ integer_to_list(Number) ++ " files in " 
      ++ integer_to_list(Time) ++ " seconds."}.
 
-list_dir_limit_loop(Dir, Handle, _Ref, N, Cnt) when Cnt >= N ->
-    list_dir_check(Dir, Handle, Cnt);
-list_dir_limit_loop(Dir, Handle, Ref, N, Cnt) ->
+list_dir_limit_loop(Dir, _Ref, N, Cnt) when Cnt >= N ->
+    list_dir_check(Dir, Cnt);
+list_dir_limit_loop(Dir, Ref, N, Cnt) ->
     receive 
 	{timeout, Ref, []} -> 
-	    list_dir_check(Dir, Handle, Cnt)
+	    list_dir_check(Dir, Cnt)
     after 0 ->
 	    Name = integer_to_list(Cnt),
 	    case ?PRIM_FILE:write_file(filename:join(Dir, Name), Name) of
@@ -1942,23 +1626,23 @@ list_dir_limit_loop(Dir, Handle, Ref, N, Cnt) ->
 		    Next = Cnt + 1,
 		    case Cnt rem 100 of
 			0 ->
-			    case list_dir_check(Dir, Handle, Next) of
+			    case list_dir_check(Dir, Next) of
 				{ok, Next} ->
 				    list_dir_limit_loop(
-				      Dir, Handle, Ref, N, Next);
+				      Dir, Ref, N, Next);
 				Other ->
 				    Other
 			    end;
 			_ ->
-			    list_dir_limit_loop(Dir, Handle, Ref, N, Next)
+			    list_dir_limit_loop(Dir, Ref, N, Next)
 		    end;
 		{error, Reason} ->
 		    {error, Reason, Cnt}
 	    end
     end.
 
-list_dir_check(Dir, Handle, Cnt) ->
-    case ?PRIM_FILE:list_dir(Handle, Dir) of
+list_dir_check(Dir, Cnt) ->
+    case ?PRIM_FILE:list_dir(Dir) of
 	{ok, ListDir} ->
 	    case length(ListDir) of
 		Cnt ->
@@ -1975,18 +1659,18 @@ list_dir_check(Dir, Handle, Cnt) ->
 %% Deletes N files while ignoring errors, then continues deleting
 %% as long as they exist.
 
-list_dir_limit_cleanup(Dir, Handle, N, Cnt) when Cnt >= N ->
+list_dir_limit_cleanup(Dir, N, Cnt) when Cnt >= N ->
     Name = integer_to_list(Cnt),
-    case ?PRIM_FILE:delete(Handle, filename:join(Dir, Name)) of
+    case ?PRIM_FILE:delete(filename:join(Dir, Name)) of
 	ok ->
-	    list_dir_limit_cleanup(Dir, Handle, N, Cnt+1);
+	    list_dir_limit_cleanup(Dir, N, Cnt+1);
 	_ ->
 	    ok
     end;
-list_dir_limit_cleanup(Dir, Handle, N, Cnt) ->
+list_dir_limit_cleanup(Dir, N, Cnt) ->
     Name = integer_to_list(Cnt),
-    ?PRIM_FILE:delete(Handle, filename:join(Dir, Name)),
-    list_dir_limit_cleanup(Dir, Handle, N, Cnt+1).
+    ?PRIM_FILE:delete(filename:join(Dir, Name)),
+    list_dir_limit_cleanup(Dir, N, Cnt+1).
 
 %%%
 %%% Test list_dir() on a non-existing pathname.
@@ -1995,7 +1679,7 @@ list_dir_limit_cleanup(Dir, Handle, N, Cnt) ->
 list_dir_error(Config) ->
     Priv = proplists:get_value(priv_dir, Config),
     NonExisting = filename:join(Priv, "non-existing-dir"),
-    {error,enoent} = prim_file:list_dir(NonExisting),
+    {error,enoent} = ?PRIM_FILE:list_dir(NonExisting),
     ok.
 
 %%%
@@ -2063,7 +1747,7 @@ do_run_large_file_test(Config, Run, Name0) ->
 		      {'DOWN',Mref,_,_,_} -> ok;
 		      {Tester,done} -> ok
 		  end,
-		  prim_file:delete(Name)
+		  ?PRIM_FILE:delete(Name)
 	  end),
 
     %% Run the test case.
diff --git a/lib/kernel/test/sendfile_SUITE.erl b/lib/kernel/test/sendfile_SUITE.erl
index bfa564c32c..b68903ed39 100644
--- a/lib/kernel/test/sendfile_SUITE.erl
+++ b/lib/kernel/test/sendfile_SUITE.erl
@@ -91,9 +91,12 @@ init_per_testcase(TC,Config) when TC == t_sendfile_recvduring;
 
     Send = fun(Sock) ->
 		   {_Size, Data} = sendfile_file_info(Filename),
-		   {ok,D} = file:open(Filename, [raw,binary,read]),
-		   prim_file:sendfile(D, Sock, 0, 0, 0,
-				      [],[],[]),
+		   {ok,Fd} = file:open(Filename, [raw,binary,read]),
+                   %% Determine whether the driver has native support by
+                   %% hitting the raw module directly; file:sendfile/5 will
+                   %% land in the fallback if it doesn't.
+                   RawModule = Fd#file_descriptor.module,
+                   {ok, _Ignored} = RawModule:sendfile(Fd,Sock,0,0,0,[],[],[]),
 		   Data
 	   end,
 
diff --git a/lib/stdlib/test/filelib_SUITE.erl b/lib/stdlib/test/filelib_SUITE.erl
index 1236fe45f4..930cea347f 100644
--- a/lib/stdlib/test/filelib_SUITE.erl
+++ b/lib/stdlib/test/filelib_SUITE.erl
@@ -33,6 +33,8 @@
 -include_lib("common_test/include/ct.hrl").
 -include_lib("kernel/include/file.hrl").
 
+-define(PRIM_FILE, prim_file).
+
 init_per_testcase(_Case, Config) ->
     Config.
 
@@ -446,10 +448,10 @@ wildcard_symlink(Config) when is_list(Config) ->
 						erl_prim_loader)),
 	    ["sub","symlink"] =
 		basenames(Dir, filelib:wildcard(filename:join(Dir, "*"),
-						prim_file)),
+						?PRIM_FILE)),
 	    ["symlink"] =
 		basenames(Dir, filelib:wildcard(filename:join(Dir, "symlink"),
-						prim_file)),
+						?PRIM_FILE)),
 	    ok = file:delete(AFile),
 	    %% The symlink should still be visible even when its target
 	    %% has been deleted.
@@ -465,10 +467,10 @@ wildcard_symlink(Config) when is_list(Config) ->
 						erl_prim_loader)),
 	    ["sub","symlink"] =
 		basenames(Dir, filelib:wildcard(filename:join(Dir, "*"),
-						prim_file)),
+						?PRIM_FILE)),
 	    ["symlink"] =
 		basenames(Dir, filelib:wildcard(filename:join(Dir, "symlink"),
-						prim_file)),
+						?PRIM_FILE)),
 	    ok
     end.
 
@@ -497,17 +499,17 @@ is_file_symlink(Config) ->
 	ok ->
 	    true = filelib:is_dir(DirAlias),
 	    true = filelib:is_dir(DirAlias, erl_prim_loader),
-	    true = filelib:is_dir(DirAlias, prim_file),
+	    true = filelib:is_dir(DirAlias, ?PRIM_FILE),
 	    true = filelib:is_file(DirAlias),
 	    true = filelib:is_file(DirAlias, erl_prim_loader),
-	    true = filelib:is_file(DirAlias, prim_file),
+	    true = filelib:is_file(DirAlias, ?PRIM_FILE),
 	    ok = file:make_symlink(AFile,FileAlias),
 	    true = filelib:is_file(FileAlias),
 	    true = filelib:is_file(FileAlias, erl_prim_loader),
-	    true = filelib:is_file(FileAlias, prim_file),
+	    true = filelib:is_file(FileAlias, ?PRIM_FILE),
 	    true = filelib:is_regular(FileAlias),
 	    true = filelib:is_regular(FileAlias, erl_prim_loader),
-	    true = filelib:is_regular(FileAlias, prim_file),
+	    true = filelib:is_regular(FileAlias, ?PRIM_FILE),
 	    ok
     end.
 
@@ -528,11 +530,11 @@ file_props_symlink(Config) ->
 	    {_,_} = LastMod = filelib:last_modified(AFile),
 	    LastMod = filelib:last_modified(Alias),
 	    LastMod = filelib:last_modified(Alias, erl_prim_loader),
-	    LastMod = filelib:last_modified(Alias, prim_file),
+	    LastMod = filelib:last_modified(Alias, ?PRIM_FILE),
 	    FileSize = filelib:file_size(AFile),
 	    FileSize = filelib:file_size(Alias),
 	    FileSize = filelib:file_size(Alias, erl_prim_loader),
-	    FileSize = filelib:file_size(Alias, prim_file)
+	    FileSize = filelib:file_size(Alias, ?PRIM_FILE)
     end.
 
 find_source(Config) when is_list(Config) ->