The R13B03 release.OTP_R13B03

1 files changed, 1810 insertions, 0 deletions

diff --git a/lib/kernel/test/prim_file_SUITE.erl b/lib/kernel/test/prim_file_SUITE.erl
new file mode 100644
index 0000000000..860aeecbf4
--- /dev/null
+++ b/lib/kernel/test/prim_file_SUITE.erl
@@ -0,0 +1,1810 @@
+%%
+%% %CopyrightBegin%
+%% 
+%% Copyright Ericsson AB 2000-2009. All Rights Reserved.
+%% 
+%% The contents of this file are subject to the Erlang Public License,
+%% Version 1.1, (the "License"); you may not use this file except in
+%% compliance with the License. You should have received a copy of the
+%% Erlang Public License along with this software. If not, it can be
+%% retrieved online at http://www.erlang.org/.
+%% 
+%% Software distributed under the License is distributed on an "AS IS"
+%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+%% the License for the specific language governing rights and limitations
+%% under the License.
+%% 
+%% %CopyrightEnd%
+%%
+-module(prim_file_SUITE).
+-export([all/1,
+	init/1, fini/1,
+	read_write_file/1, dirs/1, files/1]).
+-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,
+	 pos/1, pos1/1, pos2/1]).
+-export([close/1, 
+	 delete_a/1, delete_b/1]).
+-export([open/1, open1/1, modes/1]).
+-export([file_info/1, 
+	 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]).
+-export([rename_a/1, rename_b/1, 
+	 access/1, truncate/1, sync/1,
+	 read_write/1, pread_write/1, append/1]).
+-export([errors/1, e_delete/1, e_rename/1, e_make_dir/1, e_del_dir/1]).
+
+-export([compression/1, read_not_really_compressed/1,
+	 read_compressed/1, write_compressed/1,
+	 compress_errors/1]).
+
+-export([links/1, 
+	 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]).
+
+-include("test_server.hrl").
+-include_lib("kernel/include/file.hrl").
+
+-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).
+
+all(suite) -> {req, [kernel],
+	       {conf, init,
+		[read_write_file, dirs, files, 
+		 delete_a, delete_b, rename_a, rename_b, errors,
+		 compression, links, list_dir_limit],
+		fini}}.
+
+init(Config) when is_list(Config) ->
+    case os:type() of
+	{win32, _} ->
+	    Priv = ?config(priv_dir, Config),
+	    HasAccessTime =
+		case file:read_file_info(Priv) of
+		    {ok, #file_info{atime={_, {0, 0, 0}}}} ->
+			%% This is a unfortunately a FAT file system.
+			[no_access_time];
+		    {ok, _} ->
+			[]
+		end,
+	    HasAccessTime++Config;
+	_ ->
+	    Config
+    end.
+
+fini(Config) when is_list(Config) ->
+    case os:type() of
+	{win32, _} ->
+	    os:cmd("subst z: /d");
+	_ ->
+	    ok
+    end,
+    Config.
+
+%% Matches a term (the last) against alternatives
+expect(X, _, X) ->
+    X;
+expect(_, X, X) ->
+    X.
+
+expect(X, _, _, X) ->
+    X;
+expect(_, X, _, X) ->
+    X;
+expect(_, _, X, X) ->
+    X.
+
+expect(X, _, _, _, X) ->
+    X;
+expect(_, X, _, _, X) ->
+    X;
+expect(_, _, X, _, X) ->
+    X;
+expect(_, _, _, X, X) ->
+    X.
+
+%% Calculate the time difference
+time_dist({YY, MM, DD, H, M, S}, DT) ->
+    time_dist({{YY, MM, DD}, {H, M, S}}, DT);
+time_dist(DT, {YY, MM, DD, H, M, S}) ->
+    time_dist(DT, {{YY, MM, DD}, {H, M, S}});
+time_dist({_D1, _T1} = DT1, {_D2, _T2} = DT2) ->
+    calendar:datetime_to_gregorian_seconds(DT2)
+	- calendar:datetime_to_gregorian_seconds(DT1).
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+read_write_file(suite) -> [];
+read_write_file(doc) -> [];
+read_write_file(Config) when is_list(Config) ->
+    ?line Dog = test_server:timetrap(test_server:seconds(5)),
+    ?line RootDir = ?config(priv_dir,Config),
+    ?line 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 = ?PRIM_FILE:write_file(Name,term_to_binary(SomeTerm)),
+    ?line {ok,Bin1} = ?PRIM_FILE:read_file(Name),
+    ?line SomeTerm = binary_to_term(Bin1),
+  
+    %% Try a "null" term
+    ?line NullTerm = [],
+    ?line ok = ?PRIM_FILE:write_file(Name,term_to_binary(NullTerm)),
+    ?line {ok,Bin2} = ?PRIM_FILE:read_file(Name),
+    ?line NullTerm = binary_to_term(Bin2),
+
+    %% Try some "complicated" types
+    ?line BigNum = 123456789012345678901234567890,
+    ?line ComplTerm = {self(),make_ref(),BigNum,3.14159},
+    ?line ok = ?PRIM_FILE:write_file(Name,term_to_binary(ComplTerm)),
+    ?line {ok,Bin3} = ?PRIM_FILE:read_file(Name),
+    ?line ComplTerm = binary_to_term(Bin3),
+
+    %% Try reading a nonexistent file
+    ?line Name2 = filename:join(RootDir, 
+				atom_to_list(?MODULE)
+				++"_nonexistent_file"),
+    ?line {error, enoent} = ?PRIM_FILE:read_file(Name2),
+    ?line {error, enoent} = ?PRIM_FILE:read_file(""),
+
+    % Try writing to a bad filename
+    ?line {error, enoent} = 
+	?PRIM_FILE:write_file("",term_to_binary(NullTerm)),
+
+    % Try writing something else than a binary
+    ?line {error, badarg} = ?PRIM_FILE:write_file(Name,{1,2,3}),
+    ?line {error, badarg} = ?PRIM_FILE:write_file(Name,self()),
+
+    %% Some non-term binaries
+    ?line ok = ?PRIM_FILE:write_file(Name,[]),
+    ?line {ok,Bin4} = ?PRIM_FILE:read_file(Name),
+    ?line 0 = byte_size(Bin4),
+
+    ?line ok = ?PRIM_FILE:write_file(Name,[Bin1,[],[[Bin2]]]),
+    ?line {ok,Bin5} = ?PRIM_FILE:read_file(Name),
+    ?line {Bin1,Bin2} = split_binary(Bin5,byte_size(Bin1)),
+
+    ?line test_server:timetrap_cancel(Dog),
+    ok.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+dirs(suite) -> [make_del_dir_a, make_del_dir_b, 
+		cur_dir_0a, cur_dir_0b, 
+		cur_dir_1a, cur_dir_1b].
+
+make_del_dir_a(suite) -> [];
+make_del_dir_a(doc) -> [];
+make_del_dir_a(Config) when is_list(Config) ->
+    make_del_dir(Config, [], "_a").
+
+make_del_dir_b(suite) -> [];
+make_del_dir_b(doc) -> [];
+make_del_dir_b(Config) when is_list(Config) ->
+    ?line {ok, Handle} = ?PRIM_FILE:start(),
+    Result = make_del_dir(Config, Handle, "_b"),
+    ?line ok = ?PRIM_FILE:stop(Handle),
+    %% Just to make sure the state of the server makes a difference
+    ?line {error, einval} = ?PRIM_FILE_call(get_cwd, Handle, []),
+    Result.
+
+make_del_dir(Config, Handle, Suffix) ->
+    ?line Dog = test_server:timetrap(test_server:seconds(5)),
+    ?line RootDir = ?config(priv_dir,Config),
+    ?line NewDir = filename:join(RootDir, 
+				 atom_to_list(?MODULE)
+				 ++"_mk-dir"++Suffix),
+    ?line ok = ?PRIM_FILE_call(make_dir, Handle, [NewDir]),
+    ?line {error, eexist} = ?PRIM_FILE_call(make_dir, Handle, [NewDir]),
+    ?line ok = ?PRIM_FILE_call(del_dir, Handle, [NewDir]),
+    ?line {error, enoent} = ?PRIM_FILE_call(del_dir, Handle, [NewDir]),
+
+    %% Check that we get an error when trying to create...
+    %% a deep directory
+    ?line NewDir2 = filename:join(RootDir, 
+				  atom_to_list(?MODULE)
+				  ++"_mk-dir/foo"),
+    ?line {error, enoent} = ?PRIM_FILE_call(make_dir, Handle, [NewDir2]),
+    %% a nameless directory
+    ?line {error, enoent} = ?PRIM_FILE_call(make_dir, Handle, [""]),
+    %% a directory with illegal name
+    ?line {error, badarg} = ?PRIM_FILE_call(make_dir, Handle, ['mk-dir']),
+
+    %% a directory with illegal name, even if it's a (bad) list
+    ?line {error, badarg} = ?PRIM_FILE_call(make_dir, Handle, [[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])),
+    %% The above line works, and created a directory "./foo"
+    %% More elegant would maybe have been to fail, or to really create
+    %% 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 {error, eexist} = ?PRIM_FILE_call(del_dir, Handle, [".."]),
+    ?line {error, enoent} = ?PRIM_FILE_call(del_dir, Handle, [""]),
+    ?line {error, badarg} = ?PRIM_FILE_call(del_dir, Handle, [[3,2,1,{}]]),
+
+    ?line test_server:timetrap_cancel(Dog),
+    ok.
+
+cur_dir_0a(suite) -> [];
+cur_dir_0a(doc) -> [];
+cur_dir_0a(Config) when is_list(Config) ->
+    cur_dir_0(Config, []).
+
+cur_dir_0b(suite) -> [];
+cur_dir_0b(doc) -> [];
+cur_dir_0b(Config) when is_list(Config) ->
+    ?line {ok, Handle} = ?PRIM_FILE:start(),
+    Result = cur_dir_0(Config, Handle),
+    ?line ok = ?PRIM_FILE:stop(Handle),
+    Result.
+
+cur_dir_0(Config, Handle) ->
+    ?line Dog = test_server:timetrap(test_server:seconds(5)),
+    %% Find out the current dir, and cd to it ;-)
+    ?line {ok,BaseDir} = ?PRIM_FILE_call(get_cwd, Handle, []),
+    ?line Dir1 = BaseDir ++ "", %% Check that it's a string
+    ?line ok = ?PRIM_FILE_call(set_cwd, Handle, [Dir1]),
+    ?line DirName = atom_to_list(?MODULE) ++
+	case Handle of
+	    [] ->
+		"_curdir";
+	    _ ->
+		"_curdir_h"
+	end,
+
+    %% Make a new dir, and cd to that
+    ?line RootDir = ?config(priv_dir,Config),
+    ?line NewDir = filename:join(RootDir, DirName),
+    ?line ok = ?PRIM_FILE_call(make_dir, Handle, [NewDir]),
+    ?line io:format("cd to ~s",[NewDir]),
+    ?line ok = ?PRIM_FILE_call(set_cwd, Handle, [NewDir]),
+
+    %% Create a file in the new current directory, and check that it
+    %% really is created there
+    ?line UncommonName = "uncommon.fil",
+    ?line {ok,Fd} = ?PRIM_FILE:open(UncommonName, [read, write]),
+    ?line ok = ?PRIM_FILE:close(Fd),
+    ?line {ok,NewDirFiles} = ?PRIM_FILE_call(list_dir, Handle, ["."]),
+    ?line 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!)
+    ?line expect({error, einval}, {error, eacces}, {error, eexist}, 
+		 ?PRIM_FILE_call(del_dir, Handle, [NewDir])),
+    ?line ?PRIM_FILE_call(delete, Handle, [UncommonName]),
+    ?line {ok,[]} = ?PRIM_FILE_call(list_dir, Handle, ["."]),
+    ?line ok = ?PRIM_FILE_call(set_cwd, Handle, [Dir1]),
+    ?line io:format("cd back to ~s",[Dir1]),
+    ?line ok = ?PRIM_FILE_call(del_dir, Handle, [NewDir]),
+    ?line {error, enoent} = ?PRIM_FILE_call(set_cwd, Handle, [NewDir]),
+    ?line ok = ?PRIM_FILE_call(set_cwd, Handle, [Dir1]),
+    ?line io:format("cd back to ~s",[Dir1]),
+    ?line {ok,OldDirFiles} = ?PRIM_FILE_call(list_dir, Handle, ["."]),
+    ?line false = lists:member(UncommonName,OldDirFiles),
+
+    %% Try doing some bad things
+    ?line {error, badarg} = 
+	?PRIM_FILE_call(set_cwd, Handle, [{foo,bar}]),
+    ?line {error, enoent} = 
+	?PRIM_FILE_call(set_cwd, Handle, [""]),
+    ?line {error, enoent} = 
+	?PRIM_FILE_call(set_cwd, Handle, [".......a......"]),
+    ?line {ok,BaseDir} = 
+	?PRIM_FILE_call(get_cwd, Handle, []), %% 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} = ?PRIM_FILE_call(get_cwd, Handle, []),
+    ?line false = lists:member($\\, BaseDir),
+
+    ?line test_server:timetrap_cancel(Dog),
+    ok.
+
+%% Tests ?PRIM_FILE:get_cwd/1.
+
+cur_dir_1a(suite) -> [];
+cur_dir_1a(doc) -> [];
+cur_dir_1a(Config) when is_list(Config) ->
+    cur_dir_1(Config, []).
+
+cur_dir_1b(suite) -> [];
+cur_dir_1b(doc) -> [];
+cur_dir_1b(Config) when is_list(Config) ->
+    ?line {ok, Handle} = ?PRIM_FILE:start(),
+    Result = cur_dir_1(Config, Handle),
+    ?line ok = ?PRIM_FILE:stop(Handle),
+    Result.
+
+cur_dir_1(Config, Handle) ->
+    ?line Dog = test_server:timetrap(test_server:seconds(5)),
+
+    ?line case os:type() of
+	      {unix, _} ->
+		  ?line {error, enotsup} = 
+		      ?PRIM_FILE_call(get_cwd, Handle, ["d:"]);
+	      vxworks ->
+		  ?line {error, enotsup} = 
+		      ?PRIM_FILE_call(get_cwd, Handle,  ["d:"]);
+	      {win32, _} ->
+		  win_cur_dir_1(Config, Handle)
+	  end,
+    ?line test_server:timetrap_cancel(Dog),
+    ok.
+	
+win_cur_dir_1(_Config, Handle) ->
+    ?line {ok, BaseDir} = ?PRIM_FILE_call(get_cwd, Handle, []),
+
+    %% Get the drive letter from the current directory,
+    %% and try to get current directory for that drive.
+
+    ?line [Drive, $:|_] = BaseDir,
+    ?line {ok, BaseDir} = ?PRIM_FILE_call(get_cwd, Handle, [[Drive, $:]]),
+    io:format("BaseDir = ~s\n", [BaseDir]),
+
+    %% Unfortunately, there is no way to move away from the
+    %% current drive as we can't use the "subst" command from
+    %% a SSH connection. We can't test any more. Too bad.
+
+    ok.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+files(suite) -> [open,pos,file_info,truncate,sync].
+
+open(suite) -> [open1,modes,close,access,read_write,
+	       pread_write,append].
+
+open1(suite) -> [];
+open1(doc) -> [];
+open1(Config) when is_list(Config) ->
+    ?line Dog = test_server:timetrap(test_server:seconds(5)),
+    ?line RootDir = ?config(priv_dir,Config),
+    ?line NewDir = filename:join(RootDir, 
+				 atom_to_list(?MODULE)
+				 ++"_files"),
+    ?line ok = ?PRIM_FILE:make_dir(NewDir),
+    ?line Name = filename:join(NewDir, "foo1.fil"),
+    ?line {ok,Fd1} = ?PRIM_FILE:open(Name, [read, write]),
+    ?line {ok,Fd2} = ?PRIM_FILE:open(Name, [read]),
+    ?line Str = "{a,tuple}.\n",
+    ?line Length = length(Str),
+    ?line ?PRIM_FILE:write(Fd1,Str),
+    ?line {ok,0} = ?PRIM_FILE:position(Fd1,bof),
+    ?line {ok, Str} = ?PRIM_FILE:read(Fd1,Length),
+    ?line {ok, Str} = ?PRIM_FILE:read(Fd2,Length),
+    ?line ok = ?PRIM_FILE:close(Fd2),
+    ?line {ok,0} = ?PRIM_FILE:position(Fd1,bof),
+    ?line ok = ?PRIM_FILE:truncate(Fd1),
+    ?line eof = ?PRIM_FILE:read(Fd1,Length),
+    ?line ok = ?PRIM_FILE:close(Fd1),
+    ?line {ok,Fd3} = ?PRIM_FILE:open(Name, [read]),
+    ?line eof = ?PRIM_FILE:read(Fd3,Length),
+    ?line ok = ?PRIM_FILE:close(Fd3),
+    ?line test_server:timetrap_cancel(Dog),
+    ok.
+
+%% Tests all open modes.
+
+modes(suite) -> [];
+modes(doc) -> [];
+modes(Config) when is_list(Config) ->
+    ?line Dog = test_server:timetrap(test_server:seconds(10)),
+    ?line RootDir = ?config(priv_dir, Config),
+    ?line NewDir = filename:join(RootDir, 
+				 atom_to_list(?MODULE)
+				 ++"_open_modes"),
+    ?line ok = ?PRIM_FILE:make_dir(NewDir),
+    ?line Name1 = filename:join(NewDir, "foo1.fil"),
+    ?line Marker = "hello, world",
+    ?line Length = length(Marker),
+
+    %% write
+    ?line {ok, Fd1} = ?PRIM_FILE:open(Name1, [write]),
+    ?line ok = ?PRIM_FILE:write(Fd1, Marker),
+    ?line ok = ?PRIM_FILE:write(Fd1, ".\n"),
+    ?line ok = ?PRIM_FILE:close(Fd1),
+
+    %% read
+    ?line {ok, Fd2} = ?PRIM_FILE:open(Name1, [read]),
+    ?line {ok, Marker} = ?PRIM_FILE:read(Fd2, Length),
+    ?line ok = ?PRIM_FILE:close(Fd2),
+
+    %% read and write
+    ?line {ok, Fd3} = ?PRIM_FILE:open(Name1, [read, write]),
+    ?line {ok, Marker} = ?PRIM_FILE:read(Fd3, Length),
+    ?line ok = ?PRIM_FILE:write(Fd3, Marker),
+    ?line ok = ?PRIM_FILE:close(Fd3),
+
+    %% read by default
+    ?line {ok, Fd4} = ?PRIM_FILE:open(Name1, []),
+    ?line {ok, Marker} = ?PRIM_FILE:read(Fd4, Length),
+    ?line ok = ?PRIM_FILE:close(Fd4),
+
+    %% read and binary
+    ?line BinaryMarker = list_to_binary(Marker),
+    ?line {ok, Fd5} = ?PRIM_FILE:open(Name1, [read, binary]),
+    ?line {ok, BinaryMarker} = ?PRIM_FILE:read(Fd5, Length),
+    ?line ok = ?PRIM_FILE:close(Fd5),
+
+    ?line test_server:timetrap_cancel(Dog),
+    ok.
+
+close(suite) -> [];
+close(doc) -> [];
+close(Config) when is_list(Config) ->
+    ?line Dog = test_server:timetrap(test_server:seconds(5)),
+    ?line RootDir = ?config(priv_dir,Config),
+    ?line Name = filename:join(RootDir, 
+			       atom_to_list(?MODULE)
+			       ++"_close.fil"),
+    ?line {ok,Fd1} = ?PRIM_FILE: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 ?PRIM_FILE:open just returned a Pid, and not everyone
+    %% really checked what they got.
+    ?line {'EXIT',_Msg} = (catch ok = ?PRIM_FILE:close({ok,Fd1})),
+    ?line ok = ?PRIM_FILE:close(Fd1),
+
+    %% Try closing one more time
+    ?line Val = ?PRIM_FILE:close(Fd1),
+    ?line io:format("Second close gave: ~p", [Val]),
+
+    ?line test_server:timetrap_cancel(Dog),
+    ok.
+
+access(suite) -> [];
+access(doc) -> [];
+access(Config) when is_list(Config) ->
+    ?line Dog = test_server:timetrap(test_server:seconds(5)),
+    ?line RootDir = ?config(priv_dir,Config),
+    ?line Name = filename:join(RootDir, 
+			       atom_to_list(?MODULE)
+			       ++"_access.fil"),
+    ?line Str = "ABCDEFGH",
+    ?line {ok,Fd1} = ?PRIM_FILE:open(Name, [write]),
+    ?line ?PRIM_FILE:write(Fd1,Str),
+    ?line ok = ?PRIM_FILE:close(Fd1),
+    %% Check that we can't write when in read only mode
+    ?line {ok,Fd2} = ?PRIM_FILE:open(Name, [read]),
+    ?line case catch ?PRIM_FILE:write(Fd2,"XXXX") of
+	      ok ->
+		  test_server:fail({access,write});
+	      _ ->
+		  ok
+	  end,
+    ?line ok = ?PRIM_FILE:close(Fd2),
+    ?line {ok, Fd3} = ?PRIM_FILE:open(Name, [read]),
+    ?line {ok, Str} = ?PRIM_FILE:read(Fd3,length(Str)),
+    ?line ok = ?PRIM_FILE:close(Fd3),
+
+    ?line test_server:timetrap_cancel(Dog),
+    ok.
+
+%% Tests ?PRIM_FILE:read/2 and ?PRIM_FILE:write/2.
+
+read_write(suite) -> [];
+read_write(doc) -> [];
+read_write(Config) when is_list(Config) ->
+    ?line Dog = test_server:timetrap(test_server:seconds(5)),
+    ?line RootDir = ?config(priv_dir, Config),
+    ?line NewDir = filename:join(RootDir, 
+				 atom_to_list(?MODULE)
+				 ++"_read_write"),
+    ?line ok = ?PRIM_FILE:make_dir(NewDir),
+
+    %% Raw file.
+    ?line Name = filename:join(NewDir, "raw.fil"),
+    ?line {ok, Fd} = ?PRIM_FILE:open(Name, [read, write]),
+    ?line read_write_test(Fd),
+
+    ?line test_server:timetrap_cancel(Dog),
+    ok.
+
+read_write_test(File) ->
+    ?line Marker = "hello, world",
+    ?line ok = ?PRIM_FILE:write(File, Marker),
+    ?line {ok, 0} = ?PRIM_FILE:position(File, 0),
+    ?line {ok, Marker} = ?PRIM_FILE:read(File, 100),
+    ?line eof = ?PRIM_FILE:read(File, 100),
+    ?line ok = ?PRIM_FILE:close(File),
+    ok.
+
+
+%% Tests ?PRIM_FILE:pread/2 and ?PRIM_FILE:pwrite/2.
+
+pread_write(suite) -> [];
+pread_write(doc) -> [];
+pread_write(Config) when is_list(Config) ->
+    ?line Dog = test_server:timetrap(test_server:seconds(5)),
+    ?line RootDir = ?config(priv_dir, Config),
+    ?line NewDir = filename:join(RootDir, 
+				 atom_to_list(?MODULE)
+				 ++"_pread_write"),
+    ?line ok = ?PRIM_FILE:make_dir(NewDir),
+
+    %% Raw file.
+    ?line Name = filename:join(NewDir, "raw.fil"),
+    ?line {ok, Fd} = ?PRIM_FILE:open(Name, [read, write]),
+    ?line pread_write_test(Fd),
+
+    ?line test_server:timetrap_cancel(Dog),
+    ok.
+
+pread_write_test(File) ->
+    ?line Marker = "hello, world",
+    ?line Len = length(Marker),
+    ?line ok = ?PRIM_FILE:write(File, Marker),
+    ?line {ok, Marker} = ?PRIM_FILE:pread(File, 0, 100),
+    ?line eof = ?PRIM_FILE:pread(File, 100, 1),
+    ?line ok = ?PRIM_FILE:pwrite(File, Len, Marker),
+    ?line {ok, Marker} = ?PRIM_FILE:pread(File, Len, 100),
+    ?line eof = ?PRIM_FILE:pread(File, 100, 1),
+    ?line MM = Marker ++ Marker,
+    ?line {ok, MM} = ?PRIM_FILE:pread(File, 0, 100),
+    ?line ok = ?PRIM_FILE:close(File),
+    ok.
+
+append(doc) -> "Test appending to a file.";
+append(suite) -> [];
+append(Config) when is_list(Config) ->
+    ?line Dog = test_server:timetrap(test_server:seconds(5)),
+    ?line RootDir = ?config(priv_dir, Config),
+    ?line NewDir = filename:join(RootDir, 
+				 atom_to_list(?MODULE)
+				 ++"_append"),
+    ?line ok = ?PRIM_FILE:make_dir(NewDir),
+
+    ?line First = "First line\n",
+    ?line Second = "Seond lines comes here\n",
+    ?line Third = "And here is the third line\n",
+
+    %% Write a small text file.
+    ?line Name1 = filename:join(NewDir, "a_file.txt"),
+    ?line {ok, Fd1} = ?PRIM_FILE:open(Name1, [write]),
+    ?line ok = ?PRIM_FILE:write(Fd1, First),
+    ?line ok = ?PRIM_FILE:write(Fd1, Second),
+    ?line ok = ?PRIM_FILE:close(Fd1),
+
+    %% Open it a again and a append a line to it.
+    ?line {ok, Fd2} = ?PRIM_FILE:open(Name1, [append]),
+    ?line ok = ?PRIM_FILE:write(Fd2, Third),
+    ?line ok = ?PRIM_FILE:close(Fd2),
+
+    %% Read it back and verify.
+    ?line Expected = list_to_binary([First, Second, Third]),
+    ?line {ok, Expected} = ?PRIM_FILE:read_file(Name1),
+
+    ?line test_server:timetrap_cancel(Dog),
+    ok.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+pos(suite) -> [pos1,pos2].
+
+pos1(suite) -> [];
+pos1(doc) -> [];
+pos1(Config) when is_list(Config) ->
+    ?line Dog = test_server:timetrap(test_server:seconds(5)),
+    ?line RootDir = ?config(priv_dir,Config),
+    ?line Name = filename:join(RootDir, 
+			       atom_to_list(?MODULE)
+			       ++"_pos1.fil"),
+    ?line {ok, Fd1} = ?PRIM_FILE:open(Name, [write]),
+    ?line ?PRIM_FILE:write(Fd1,"ABCDEFGH"),
+    ?line ok        = ?PRIM_FILE:close(Fd1),
+    ?line {ok, Fd2} = ?PRIM_FILE:open(Name, [read]),
+
+    %% Start pos is first char
+    ?line io:format("Relative positions"),
+    ?line {ok, "A"} = ?PRIM_FILE:read(Fd2,1),
+    ?line {ok, 2}   = ?PRIM_FILE:position(Fd2,{cur,1}), 
+    ?line {ok, "C"} = ?PRIM_FILE:read(Fd2,1),
+    ?line {ok, 0}   = ?PRIM_FILE:position(Fd2,{cur,-3}), 
+    ?line {ok, "A"} = ?PRIM_FILE:read(Fd2,1),
+    %% Backwards from first char should be an error
+    ?line {ok,0}    = ?PRIM_FILE:position(Fd2,{cur,-1}),
+    ?line {error, einval} = ?PRIM_FILE:position(Fd2,{cur,-1}),
+    %% Reset position and move again
+    ?line {ok, 0}   = ?PRIM_FILE:position(Fd2,0),
+    ?line {ok, 2}   = ?PRIM_FILE:position(Fd2,{cur,2}), 
+    ?line {ok, "C"} = ?PRIM_FILE:read(Fd2,1),
+    %% Go a lot forwards
+    ?line {ok, 13}  = ?PRIM_FILE:position(Fd2,{cur,10}), 
+    ?line eof       = ?PRIM_FILE:read(Fd2,1),
+
+    %% Try some fixed positions
+    ?line io:format("Fixed positions"),
+    ?line {ok, 8}   = ?PRIM_FILE:position(Fd2,8), 
+    ?line eof = ?PRIM_FILE:read(Fd2,1),
+    ?line {ok, 8}   = ?PRIM_FILE:position(Fd2,cur), 
+    ?line eof = ?PRIM_FILE:read(Fd2,1),
+    ?line {ok, 7}   = ?PRIM_FILE:position(Fd2,7), 
+    ?line {ok, "H"} = ?PRIM_FILE:read(Fd2,1),
+    ?line {ok, 0}   = ?PRIM_FILE:position(Fd2,0), 
+    ?line {ok, "A"} = ?PRIM_FILE:read(Fd2,1),
+    ?line {ok, 3}   = ?PRIM_FILE:position(Fd2,3), 
+    ?line {ok, "D"} = ?PRIM_FILE:read(Fd2,1),
+    ?line {ok, 12}  = ?PRIM_FILE:position(Fd2,12), 
+    ?line eof       = ?PRIM_FILE:read(Fd2,1),
+    ?line {ok, 3}   = ?PRIM_FILE:position(Fd2,3), 
+    ?line {ok, "D"} = ?PRIM_FILE:read(Fd2,1),
+    %% Try the {bof,X} notation
+    ?line {ok, 3}   = ?PRIM_FILE:position(Fd2,{bof,3}),
+    ?line {ok, "D"} = ?PRIM_FILE:read(Fd2,1),
+
+    %% Try eof positions
+    ?line io:format("EOF positions"),
+    ?line {ok, 8}   = ?PRIM_FILE:position(Fd2,{eof,0}), 
+    ?line eof       = ?PRIM_FILE:read(Fd2,1),
+    ?line {ok, 7}   = ?PRIM_FILE:position(Fd2,{eof,-1}),
+    ?line {ok, "H"} = ?PRIM_FILE:read(Fd2,1),
+    ?line {ok, 0}   = ?PRIM_FILE:position(Fd2,{eof,-8}), 
+    ?line {ok, "A"} = ?PRIM_FILE:read(Fd2,1),
+    ?line {error, einval} = ?PRIM_FILE:position(Fd2,{eof,-9}),
+    ?line test_server:timetrap_cancel(Dog),
+    ok.
+
+pos2(suite) -> [];
+pos2(doc) -> [];
+pos2(Config) when is_list(Config) ->
+    ?line Dog = test_server:timetrap(test_server:seconds(5)),
+    ?line RootDir = ?config(priv_dir,Config),
+    ?line Name = filename:join(RootDir, 
+			       atom_to_list(?MODULE)
+			       ++"_pos2.fil"),
+    ?line {ok,Fd1} = ?PRIM_FILE:open(Name, [write]),
+    ?line ?PRIM_FILE:write(Fd1,"ABCDEFGH"),
+    ?line ok = ?PRIM_FILE:close(Fd1),
+    ?line {ok, Fd2} = ?PRIM_FILE:open(Name, [read]),
+    ?line {error, einval} = ?PRIM_FILE:position(Fd2,-1),
+
+    %% Make sure that we still can search after an error.
+    ?line {ok, 0}   = ?PRIM_FILE:position(Fd2, 0),
+    ?line {ok, 3}   = ?PRIM_FILE:position(Fd2, {bof,3}),
+    ?line {ok, "D"} = ?PRIM_FILE:read(Fd2,1),
+
+    ?line io:format("DONE"),
+    ?line test_server:timetrap_cancel(Dog),
+    ok.
+
+file_info(suite) -> [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_info_basic_file_a(suite) -> [];
+file_info_basic_file_a(doc) -> [];
+file_info_basic_file_a(Config) when is_list(Config) ->
+    file_info_basic_file(Config, [], "_a").
+
+file_info_basic_file_b(suite) -> [];
+file_info_basic_file_b(doc) -> [];
+file_info_basic_file_b(Config) when is_list(Config) ->
+    ?line {ok, Handle} = ?PRIM_FILE:start(),
+    Result = file_info_basic_file(Config, Handle, "_b"),
+    ?line ok = ?PRIM_FILE:stop(Handle),
+    Result.
+
+file_info_basic_file(Config, Handle, Suffix) ->
+    ?line Dog = test_server:timetrap(test_server:seconds(5)),
+    ?line RootDir = ?config(priv_dir, Config),
+
+    %% Create a short file.
+    ?line Name = filename:join(RootDir, 
+			       atom_to_list(?MODULE)
+			       ++"_basic_test"++Suffix++".fil"),
+    ?line {ok,Fd1} = ?PRIM_FILE:open(Name, [write]),
+    ?line ?PRIM_FILE:write(Fd1, "foo bar"),
+    ?line 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.
+    ?line {ok, FileInfo} = ?PRIM_FILE_call(read_file_info, Handle, [Name]),
+    ?line #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 Access = read_write,
+    ?line true = abs(time_dist(filter_atime(AccessTime, Config),
+			       filter_atime(ModifyTime,
+					    Config))) < 2,
+    ?line {AD, AT} = AccessTime,
+    ?line all_integers(tuple_to_list(AD) ++ tuple_to_list(AT)),
+    ?line {MD, MT} = ModifyTime,
+    ?line all_integers(tuple_to_list(MD) ++ tuple_to_list(MT)),
+
+    ?line test_server:timetrap_cancel(Dog),
+    ok.
+
+file_info_basic_directory_a(suite) -> [];
+file_info_basic_directory_a(doc) -> [];
+file_info_basic_directory_a(Config) when is_list(Config) ->
+    file_info_basic_directory(Config, []).
+
+file_info_basic_directory_b(suite) -> [];
+file_info_basic_directory_b(doc) -> [];
+file_info_basic_directory_b(Config) when is_list(Config) ->
+    ?line {ok, Handle} = ?PRIM_FILE:start(),
+    Result = file_info_basic_directory(Config, Handle),
+    ?line ok = ?PRIM_FILE:stop(Handle),
+    Result.
+
+file_info_basic_directory(Config, Handle) ->
+    ?line Dog = test_server:timetrap(test_server:seconds(5)),
+
+    %% 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.
+    ?line RootDir = filename:join([?config(priv_dir, Config)]),
+
+    %% Test that the RootDir directory has the expected attributes.
+    ?line test_directory(RootDir, read_write, Handle),
+
+    %% 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.
+    ?line case os:type() of
+	      {win32, _} ->
+		  ?line test_directory("/", read_write, Handle),
+		  ?line test_directory("c:/", read_write, Handle),
+		  ?line test_directory("c:\\", read_write, Handle);
+	      {unix, _} ->
+		  ?line test_directory("/", read, Handle);
+	      vxworks ->
+		  %% Check is just done for owner
+		  ?line test_directory("/", read_write, Handle)
+	  end,
+    ?line test_server:timetrap_cancel(Dog).
+
+test_directory(Name, ExpectedAccess, Handle) ->
+    ?line {ok, FileInfo} = ?PRIM_FILE_call(read_file_info, Handle, [Name]),
+    ?line #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 {AD, AT} = AccessTime,
+    ?line all_integers(tuple_to_list(AD) ++ tuple_to_list(AT)),
+    ?line {MD, MT} = ModifyTime,
+    ?line all_integers(tuple_to_list(MD) ++ tuple_to_list(MT)),
+    ok.
+
+all_integers([Int|Rest]) when is_integer(Int) ->
+    ?line all_integers(Rest);
+all_integers([]) ->
+    ok.
+
+%% Try something nonexistent.
+
+file_info_bad_a(suite) -> [];
+file_info_bad_a(doc) -> [];
+file_info_bad_a(Config) when is_list(Config) ->
+    file_info_bad(Config, []).
+
+file_info_bad_b(suite) -> [];
+file_info_bad_b(doc) -> [];
+file_info_bad_b(Config) when is_list(Config) ->
+    ?line {ok, Handle} = ?PRIM_FILE:start(),
+    Result = file_info_bad(Config, Handle),
+    ?line ok = ?PRIM_FILE:stop(Handle),
+    Result.
+
+file_info_bad(Config, Handle) ->
+    ?line Dog = test_server:timetrap(test_server:seconds(5)),
+    ?line RootDir = filename:join([?config(priv_dir, Config)]),
+    ?line {error, enoent} = 
+	?PRIM_FILE_call(
+	   read_file_info, Handle, 
+	   [filename:join(RootDir,
+			  atom_to_list(?MODULE)++"_nonexistent")]),
+    ?line test_server:timetrap_cancel(Dog),
+    ok.
+
+%% Test that the file times behave as they should.
+
+file_info_times_a(suite) -> [];
+file_info_times_a(doc) -> [];
+file_info_times_a(Config) when is_list(Config) ->
+    file_info_times(Config, [], "_a").
+
+file_info_times_b(suite) -> [];
+file_info_times_b(doc) -> [];
+file_info_times_b(Config) when is_list(Config) ->
+    ?line {ok, Handle} = ?PRIM_FILE:start(),
+    Result = file_info_times(Config, Handle, "_b"),
+    ?line ok = ?PRIM_FILE:stop(Handle),
+    Result.
+
+file_info_times(Config, Handle, Suffix) ->
+    ?line Dog = test_server:timetrap(test_server:seconds(60)),
+    %% 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, Handle, Suffix) end),
+    ?line test_server:timetrap_cancel(Dog),
+    ok.
+
+file_info_int(Config, Handle, Suffix) ->
+    %% 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.
+
+    ?line RootDir = filename:join([?config(priv_dir, Config)]),
+    ?line test_server:format("RootDir = ~p", [RootDir]),
+
+    ?line Name = filename:join(RootDir, 
+			       atom_to_list(?MODULE)
+			       ++"_file_info"++Suffix++".fil"),
+    ?line {ok,Fd1} = ?PRIM_FILE:open(Name, [write]),
+    ?line ?PRIM_FILE:write(Fd1,"foo"),
+
+    %% check that the file got a modify date max a few seconds away from now
+    ?line {ok, #file_info{type = regular, 
+			  atime = AccTime1, mtime = ModTime1}} = 
+	?PRIM_FILE_call(read_file_info, Handle, [Name]),
+    ?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,
+    
+    %% Sleep until we can be sure the seconds value has changed.
+    %% Note: FAT-based filesystem (like on Windows 95) have
+    %% a resolution of 2 seconds.
+    ?line test_server:sleep(test_server:seconds(2.2)),
+
+    %% close the file, and watch the modify date change
+    ?line ok = ?PRIM_FILE:close(Fd1),
+    ?line {ok, #file_info{size = Size, type = regular, access = Access, 
+			  atime = AccTime2, mtime = ModTime2}} = 
+	?PRIM_FILE_call(read_file_info, Handle, [Name]),
+    ?line io:format("Closed file Acc ~p Mod ~p",[AccTime2,ModTime2]),
+    ?line 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,
+
+    %% Do some directory checking
+    ?line {ok, #file_info{size = DSize, type = directory, 
+			  access = DAccess, 
+			  atime = AccTime3, mtime = ModTime3}} = 
+	?PRIM_FILE_call(read_file_info, Handle, [RootDir]),
+    %% 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]),
+    ok.
+
+%% Filter access times, to cope with a deficiency of FAT file systems
+%% (on Windows): The access time is actually only a date.
+
+filter_atime(Atime, Config) ->
+    case lists:member(no_access_time, Config) of
+	true ->
+	    case Atime of
+	    	{Date, _} ->
+	    	   {Date, {0, 0, 0}};
+		{Y, M, D, _, _, _} ->
+		   {Y, M, D, 0, 0, 0}
+	    end;
+	false ->
+	    Atime
+    end.
+
+%% Test the write_file_info/2 function.
+
+file_write_file_info_a(suite) -> [];
+file_write_file_info_a(doc) -> [];
+file_write_file_info_a(Config) when is_list(Config) ->
+    file_write_file_info(Config, [], "_a").
+
+file_write_file_info_b(suite) -> [];
+file_write_file_info_b(doc) -> [];
+file_write_file_info_b(Config) when is_list(Config) ->
+    ?line {ok, Handle} = ?PRIM_FILE:start(),
+    Result = file_write_file_info(Config, Handle, "_b"),
+    ?line ok = ?PRIM_FILE:stop(Handle),
+    Result.
+
+file_write_file_info(Config, Handle, Suffix) ->
+    ?line Dog = test_server:timetrap(test_server:seconds(10)),
+    ?line RootDir = get_good_directory(Config),
+    ?line test_server: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 Name = filename:join(RootDir, 
+			       atom_to_list(?MODULE)
+			       ++"_write_file_info_ro"++Suffix),
+    ?line ok = ?PRIM_FILE:write_file(Name, "hello"),
+    ?line Time = {{1997, 01, 02}, {12, 35, 42}},
+    ?line Info = #file_info{mode=8#400, atime=Time, mtime=Time, ctime=Time},
+    ?line ok = ?PRIM_FILE_call(write_file_info, Handle, [Name, Info]),
+
+    %% Read back the times.
+
+    ?line {ok, ActualInfo} = 
+	?PRIM_FILE_call(read_file_info, Handle, [Name]),
+    ?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} = ?PRIM_FILE:write_file(Name, "hello again"),
+
+    %% Make the file writable again.
+
+    ?line ?PRIM_FILE_call(write_file_info, Handle, 
+			  [Name, #file_info{mode=8#600}]),
+    ?line ok = ?PRIM_FILE:write_file(Name, "hello again"),
+
+    %% And unwritable.
+    ?line ?PRIM_FILE_call(write_file_info, Handle, 
+			  [Name, #file_info{mode=8#400}]),
+    ?line {error, eacces} = ?PRIM_FILE:write_file(Name, "hello again"),
+
+    %% 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 = ?PRIM_FILE_call(write_file_info, Handle, [Name, NewInfo]),
+    ?line {ok, ActualInfo2} = 
+	?PRIM_FILE_call(read_file_info, Handle, [Name]),
+    ?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,
+
+    %% The file should still be unwritable.
+    ?line {error, eacces} = ?PRIM_FILE:write_file(Name, "hello again"),
+
+    %% Make the file writeable again, so that we can remove the
+    %% test suites ... :-)
+    ?line ?PRIM_FILE_call(write_file_info, Handle, 
+			  [Name, #file_info{mode=8#600}]),
+    ?line test_server:timetrap_cancel(Dog),
+    ok.
+
+%% Returns a directory on a file system that has correct file times.
+
+get_good_directory(Config) ->
+    ?line ?config(priv_dir, Config).
+
+truncate(suite) -> [];
+truncate(doc) -> [];
+truncate(Config) when is_list(Config) ->
+    ?line Dog = test_server:timetrap(test_server:seconds(5)),
+    ?line RootDir = ?config(priv_dir,Config),
+    ?line Name = filename:join(RootDir, 
+			       atom_to_list(?MODULE)
+			       ++"_truncate.fil"),
+
+    %% Create a file with some data.
+    ?line MyData = "0123456789abcdefghijklmnopqrstuvxyz",
+    ?line ok = ?PRIM_FILE:write_file(Name, MyData),
+
+    %% Truncate the file to 10 characters.
+    ?line {ok, Fd} = ?PRIM_FILE:open(Name, [read, write]),
+    ?line {ok, 10} = ?PRIM_FILE:position(Fd, 10),
+    ?line ok = ?PRIM_FILE:truncate(Fd),
+    ?line ok = ?PRIM_FILE:close(Fd),
+
+    %% Read back the file and check that it has been truncated.
+    ?line Expected = list_to_binary("0123456789"),
+    ?line {ok, Expected} = ?PRIM_FILE:read_file(Name),
+
+    %% Open the file read only and verify that it is not possible to
+    %% truncate it, OTP-1960
+    ?line {ok, Fd2} = ?PRIM_FILE:open(Name, [read]),
+    ?line {ok, 5} = ?PRIM_FILE:position(Fd2, 5),
+    ?line {error, _} = ?PRIM_FILE:truncate(Fd2),
+
+    ?line test_server:timetrap_cancel(Dog),
+    ok.
+
+
+sync(suite) -> [];
+sync(doc) -> "Tests that ?PRIM_FILE:sync/1 at least doesn't crash.";
+sync(Config) when is_list(Config) ->
+    ?line Dog = test_server:timetrap(test_server:seconds(5)),
+    ?line PrivDir = ?config(priv_dir, Config),
+    ?line Sync = filename:join(PrivDir, 
+			       atom_to_list(?MODULE)
+			       ++"_sync.fil"),
+
+    %% Raw open.
+    ?line {ok, Fd} = ?PRIM_FILE:open(Sync, [write]),
+    ?line ok = ?PRIM_FILE:sync(Fd),
+    ?line ok = ?PRIM_FILE:close(Fd),
+
+    ?line test_server:timetrap_cancel(Dog),
+    ok.
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+delete_a(suite) -> [];
+delete_a(doc) -> [];
+delete_a(Config) when is_list(Config) ->
+    delete(Config, [], "_a").
+
+delete_b(suite) -> [];
+delete_b(doc) -> [];
+delete_b(Config) when is_list(Config) ->
+    ?line {ok, Handle} = ?PRIM_FILE:start(),
+    Result = delete(Config, Handle, "_b"),
+    ?line ok = ?PRIM_FILE:stop(Handle),
+    Result.
+
+delete(Config, Handle, Suffix) ->
+    ?line Dog = test_server:timetrap(test_server:seconds(5)),
+    ?line RootDir = ?config(priv_dir,Config),
+    ?line Name = filename:join(RootDir, 
+			       atom_to_list(?MODULE)
+			       ++"_delete"++Suffix++".fil"),
+    ?line {ok, Fd1} = ?PRIM_FILE:open(Name, [write]),
+    ?line ?PRIM_FILE:write(Fd1,"ok.\n"),
+    ?line ok = ?PRIM_FILE:close(Fd1),
+    %% Check that the file is readable
+    ?line {ok, Fd2} = ?PRIM_FILE:open(Name, [read]),
+    ?line ok = ?PRIM_FILE:close(Fd2),
+    ?line ok = ?PRIM_FILE_call(delete, Handle, [Name]),
+    %% Check that the file is not readable anymore
+    ?line {error, _} = ?PRIM_FILE:open(Name, [read]),
+    %% Try deleting a nonexistent file
+    ?line {error, enoent} = ?PRIM_FILE_call(delete, Handle, [Name]),
+    ?line test_server:timetrap_cancel(Dog),
+    ok.
+
+rename_a(suite) ->[];
+rename_a(doc) ->[];
+rename_a(Config) when is_list(Config) ->
+    rename(Config, [], "_a").
+
+rename_b(suite) ->[];
+rename_b(doc) ->[];
+rename_b(Config) when is_list(Config) ->
+    ?line {ok, Handle} = ?PRIM_FILE:start(),
+    Result = rename(Config, Handle, "_b"),
+    ?line ok = ?PRIM_FILE:stop(Handle),
+    Result.
+
+rename(Config, Handle, Suffix) ->
+    ?line Dog = test_server:timetrap(test_server:seconds(5)),
+    ?line RootDir = ?config(priv_dir,Config),
+    ?line FileName1 = atom_to_list(?MODULE)++"_rename"++Suffix++".fil",
+    ?line FileName2 = atom_to_list(?MODULE)++"_rename"++Suffix++".ful",
+    ?line Name1 = filename:join(RootDir, FileName1),
+    ?line Name2 = filename:join(RootDir, FileName2),
+    ?line {ok,Fd1} = ?PRIM_FILE:open(Name1, [write]),
+    ?line ok = ?PRIM_FILE:close(Fd1),
+    %% Rename, and check that it really changed name
+    ?line ok = ?PRIM_FILE_call(rename, Handle, [Name1, Name2]),
+    ?line {error, _} = ?PRIM_FILE:open(Name1, [read]),
+    ?line {ok, Fd2} = ?PRIM_FILE:open(Name2, [read]),
+    ?line ok = ?PRIM_FILE:close(Fd2),
+    %% Try renaming something to itself
+    ?line ok = ?PRIM_FILE_call(rename, Handle, [Name2, Name2]),
+    %% Try renaming something that doesn't exist
+    ?line {error, enoent} = 
+	?PRIM_FILE_call(rename, Handle, [Name1, Name2]),
+    %% Try renaming to something else than a string
+    ?line {error, badarg} = 
+	?PRIM_FILE_call(rename, Handle, [Name1, foobar]),
+    
+    %% Move between directories
+    ?line DirName1 = filename:join(RootDir,
+				   atom_to_list(?MODULE)
+				   ++"_rename_dir"++Suffix),
+    ?line DirName2 = filename:join(RootDir,
+				   atom_to_list(?MODULE)
+				   ++"_second_rename_dir"++Suffix),
+    ?line Name1foo = filename:join(DirName1, "foo.fil"),
+    ?line Name2foo = filename:join(DirName2, "foo.fil"),
+    ?line Name2bar = filename:join(DirName2, "bar.dir"),
+    ?line ok = ?PRIM_FILE:make_dir(DirName1),
+    %% The name has to include the full file name, path is not enough
+    ?line expect(
+	    {error, eexist}, {error, eisdir},
+	    ?PRIM_FILE_call(rename, Handle, [Name2, DirName1])),
+    ?line ok = 
+	?PRIM_FILE_call(rename, Handle, [Name2, Name1foo]),
+    %% Now rename the directory
+    ?line ok = ?PRIM_FILE_call(rename, Handle, [DirName1, DirName2]),
+    %% And check that the file is there now
+    ?line {ok,Fd3} = ?PRIM_FILE:open(Name2foo, [read]),
+    ?line ok = ?PRIM_FILE:close(Fd3),
+    %% Try some dirty things now: move the directory into itself
+    ?line {error, Msg1} = 
+	?PRIM_FILE_call(rename, Handle, [DirName2, Name2bar]),
+    ?line io:format("Errmsg1: ~p",[Msg1]),
+    %% move dir into a file in itself
+    ?line {error, Msg2} = 
+	?PRIM_FILE_call(rename, Handle, [DirName2, Name2foo]),
+    ?line io:format("Errmsg2: ~p",[Msg2]),
+
+    ?line test_server:timetrap_cancel(Dog),
+    ok.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+errors(suite) -> [e_delete, e_rename, e_make_dir, e_del_dir].
+
+e_delete(suite) -> [];
+e_delete(doc) -> [];
+e_delete(Config) when is_list(Config) ->
+    ?line Dog = test_server:timetrap(test_server:seconds(10)),
+    ?line RootDir = ?config(priv_dir, Config),
+    ?line Base = filename:join(RootDir, 
+			       atom_to_list(?MODULE)++"_e_delete"),
+    ?line ok = ?PRIM_FILE:make_dir(Base),
+
+    %% Delete a non-existing file.
+    ?line {error, enoent} = 
+	?PRIM_FILE:delete(filename:join(Base, "non_existing")),
+
+    %% Delete a directory.
+    ?line {error, eperm} = ?PRIM_FILE:delete(Base),
+
+    %% Use a path-name with a non-directory component.
+    ?line Afile = filename:join(Base, "a_file"),
+    ?line ok = ?PRIM_FILE:write_file(Afile, "hello\n"),
+    ?line {error, E} = 
+	expect(
+	  {error, enotdir}, {error, enoent}, 
+	  ?PRIM_FILE:delete(filename:join(Afile, "another_file"))),
+    ?line io:format("Result: ~p~n", [E]),
+
+    %% No permission.
+    ?line case os:type() of
+	      {unix, _} ->
+		  ?line ?PRIM_FILE:write_file_info(
+			   Base, #file_info {mode=0}),
+		  ?line {error, eacces} = ?PRIM_FILE:delete(Afile),
+		  ?line ?PRIM_FILE:write_file_info(
+			   Base, #file_info {mode=8#600});
+	      {win32, _} ->
+		  %% Remove a character device.
+		  ?line {error, eacces} = ?PRIM_FILE:delete("nul");
+	      vxworks ->
+		  ok
+	  end,
+
+    ?line test_server:timetrap_cancel(Dog),
+    ok.
+
+%%% FreeBSD gives EEXIST when renaming a file to an empty dir, although the
+%%% manual page can be interpreted as saying that EISDIR should be given.
+%%% (What about FreeBSD? We store our nightly build results on a FreeBSD
+%%% file system, that's what.)
+
+e_rename(suite) -> [];
+e_rename(doc) -> [];
+e_rename(Config) when is_list(Config) ->
+    case os:type() of
+	vxworks ->
+	    {comment, "Windriver: dosFs must be fixed first!"};
+	_ ->
+	    ?line Dog = test_server:timetrap(test_server:seconds(10)),
+	    ?line RootDir = ?config(priv_dir, Config),
+	    ?line Base = filename:join(RootDir,
+				       atom_to_list(?MODULE)++"_e_rename"),
+	    ?line ok = ?PRIM_FILE:make_dir(Base),
+	
+	    %% Create an empty directory.
+	    ?line EmptyDir = filename:join(Base, "empty_dir"),
+	    ?line ok = ?PRIM_FILE:make_dir(EmptyDir),
+
+	    %% Create a non-empty directory.
+	    ?line NonEmptyDir = filename:join(Base, "non_empty_dir"),
+	    ?line ok = ?PRIM_FILE:make_dir(NonEmptyDir),
+	    ?line ok = ?PRIM_FILE:write_file(
+			  filename:join(NonEmptyDir, "a_file"),
+			  "hello\n"),
+
+	    %% Create another non-empty directory.
+	    ?line ADirectory = filename:join(Base, "a_directory"),
+	    ?line ok = ?PRIM_FILE:make_dir(ADirectory),
+	    ?line ok = ?PRIM_FILE:write_file(
+			  filename:join(ADirectory, "a_file"),
+			  "howdy\n\n"),
+
+	    %% Create a data file.
+	    ?line File = filename:join(Base, "just_a_file"),
+	    ?line ok = ?PRIM_FILE:write_file(File, "anything goes\n\n"),
+	
+	    %% Move an existing directory to a non-empty directory.
+	    ?line {error, eexist} = 
+		?PRIM_FILE:rename(ADirectory, NonEmptyDir),
+
+	    %% Move a root directory.
+	    ?line {error, einval} = ?PRIM_FILE:rename("/", "arne"),
+
+	    %% Move Base into Base/new_name.
+	    ?line {error, einval} = 
+		?PRIM_FILE:rename(Base, filename:join(Base, "new_name")),
+
+	    %% Overwrite a directory with a file.
+	    ?line expect({error, eexist}, % FreeBSD (?)
+			 {error, eisdir},
+			 ?PRIM_FILE:rename(File, EmptyDir)),
+	    ?line expect({error, eexist}, % FreeBSD (?)
+			 {error, eisdir},
+			 ?PRIM_FILE:rename(File, NonEmptyDir)),
+
+	    %% Move a non-existing file.
+	    ?line NonExistingFile = filename:join(
+				      Base, "non_existing_file"),
+	    ?line {error, enoent} = 
+		?PRIM_FILE:rename(NonExistingFile, NonEmptyDir),
+
+	    %% Overwrite a file with a directory.
+	    ?line expect({error, eexist}, % FreeBSD (?)
+			 {error, enotdir},
+			 ?PRIM_FILE:rename(ADirectory, File)),
+
+	    %% Move a file to another filesystem.
+	    %% XXX - This test case is bogus. We cannot be guaranteed that
+	    %%       the source and destination are on 
+	    %%       different filesystems.
+	    %%
+	    %% XXX - Gross hack!
+	    ?line Comment = 
+		case os:type() of
+		    {unix, _} ->
+			OtherFs = "/tmp",
+			?line NameOnOtherFs =
+			    filename:join(OtherFs, 
+					  filename:basename(File)),
+			?line {ok, Com} = 
+			    case ?PRIM_FILE: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,
+	    ?line test_server:timetrap_cancel(Dog),
+	    Comment
+    end.
+
+e_make_dir(suite) -> [];
+e_make_dir(doc) -> [];
+e_make_dir(Config) when is_list(Config) ->
+    ?line Dog = test_server:timetrap(test_server:seconds(10)),
+    ?line RootDir = ?config(priv_dir, Config),
+    ?line Base = filename:join(RootDir, 
+			       atom_to_list(?MODULE)++"_e_make_dir"),
+    ?line ok = ?PRIM_FILE:make_dir(Base),
+
+    %% A component of the path does not exist.
+    ?line {error, enoent} = 
+	?PRIM_FILE:make_dir(filename:join([Base, "a", "b"])),
+
+    %% Use a path-name with a non-directory component.
+    ?line Afile = filename:join(Base, "a_directory"),
+    ?line ok = ?PRIM_FILE:write_file(Afile, "hello\n"),
+    ?line case ?PRIM_FILE:make_dir(
+		  filename:join(Afile, "another_directory")) of
+	      {error, enotdir} -> io:format("Result: enotdir");
+	      {error, enoent} -> io:format("Result: enoent")
+	  end,
+
+    %% No permission (on Unix only).
+    case os:type() of
+	{unix, _} ->
+	    ?line ?PRIM_FILE:write_file_info(Base, #file_info {mode=0}),
+	    ?line {error, eacces} = 
+		?PRIM_FILE:make_dir(filename:join(Base, "xxxx")),
+	    ?line 
+		?PRIM_FILE:write_file_info(Base, #file_info {mode=8#600});
+	{win32, _} ->
+	    ok;
+	vxworks ->
+	    ok
+    end,
+    ?line test_server:timetrap_cancel(Dog),
+    ok.
+
+e_del_dir(suite) -> [];
+e_del_dir(doc) -> [];
+e_del_dir(Config) when is_list(Config) ->
+    ?line Dog = test_server:timetrap(test_server:seconds(10)),
+    ?line RootDir = ?config(priv_dir, Config),
+    ?line Base = filename:join(RootDir, 
+			       atom_to_list(?MODULE)++"_e_del_dir"),
+    ?line io:format("Base: ~p", [Base]),
+    ?line ok = ?PRIM_FILE:make_dir(Base),
+
+    %% Delete a non-existent directory.
+    ?line {error, enoent} = 
+	?PRIM_FILE:del_dir(filename:join(Base, "non_existing")),
+
+    %% Use a path-name with a non-directory component.
+    ?line Afile = filename:join(Base, "a_directory"),
+    ?line ok = ?PRIM_FILE:write_file(Afile, "hello\n"),
+    ?line {error, E1} = 
+	expect({error, enotdir}, {error, enoent},
+	       ?PRIM_FILE:del_dir(
+		  filename:join(Afile, "another_directory"))),
+    ?line io:format("Result: ~p", [E1]),
+
+    %% Delete a non-empty directory.
+    %% Delete a non-empty directory.
+    ?line {error, E2} = 
+	expect({error, enotempty}, {error, eexist}, {error, eacces},
+	       ?PRIM_FILE:del_dir(Base)),
+    ?line io:format("Result: ~p", [E2]),
+
+    %% Remove the current directory.
+    ?line {error, E3} = 
+	expect({error, einval}, 
+	       {error, eperm}, % Linux and DUX
+	       {error, eacces},
+	       {error, ebusy},
+	       ?PRIM_FILE:del_dir(".")),
+    ?line io:format("Result: ~p", [E3]),
+
+    %% No permission.
+    case os:type() of
+	{unix, _} ->
+	    ?line ADirectory = filename:join(Base, "no_perm"),
+	    ?line ok = ?PRIM_FILE:make_dir(ADirectory),
+	    ?line ?PRIM_FILE:write_file_info(Base, #file_info {mode=0}),
+	    ?line {error, eacces} = ?PRIM_FILE:del_dir(ADirectory),
+	    ?line ?PRIM_FILE:write_file_info(
+		     Base, #file_info {mode=8#600});
+	{win32, _} ->
+	    ok;
+	vxworks ->
+	    ok
+    end,
+    ?line test_server:timetrap_cancel(Dog),
+    ok.
+
+compression(suite) -> [read_compressed, read_not_really_compressed,
+		       write_compressed, compress_errors].
+
+%% Trying reading and positioning from a compressed file.
+
+read_compressed(suite) -> [];
+read_compressed(doc) -> [];
+read_compressed(Config) when is_list(Config) ->
+    ?line Data = ?config(data_dir, Config),
+    ?line Real = filename:join(Data, "realmen.html.gz"),
+    ?line {ok, Fd} = ?PRIM_FILE:open(Real, [read, compressed]),
+    ?line try_read_file(Fd).
+
+%% Trying reading and positioning from an uncompressed file,
+%% but with the compressed flag given.
+
+read_not_really_compressed(suite) -> [];
+read_not_really_compressed(doc) -> [];
+read_not_really_compressed(Config) when is_list(Config) ->
+    ?line Data = ?config(data_dir, Config),
+    ?line Priv = ?config(priv_dir, 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} = ?PRIM_FILE:read_file(Real),
+    ?line RealData = remove_crs(binary_to_list(RealDataBin), []),
+    ?line ok = ?PRIM_FILE:write_file(RealPriv, RealData),
+    ?line {ok, Fd} = ?PRIM_FILE:open(RealPriv, [read, compressed]),
+    ?line 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) ->
+    ?line Dog = test_server:timetrap(test_server:seconds(10)),
+
+    %% Seek to the current position (nothing should happen).
+
+    ?line {ok, 0} = ?PRIM_FILE:position(Fd, 0),
+    ?line {ok, 0} = ?PRIM_FILE:position(Fd, {cur, 0}),
+
+    %% Read a few lines from a compressed file.
+
+    ?line ShouldBe = "<TITLE>Real Programmers Don't Use PASCAL</TITLE>\n",
+    ?line {ok, ShouldBe} = ?PRIM_FILE:read(Fd, length(ShouldBe)),
+
+    %% Now seek forward.
+
+    ?line {ok, 381} = ?PRIM_FILE:position(Fd, 381),
+    ?line Back = "Back in the good old days -- the \"Golden Era\" " ++
+	"of computers, it was\n",
+    ?line {ok, Back} = ?PRIM_FILE:read(Fd, length(Back)),
+
+    %% Try to search forward relative to the current position.
+
+    ?line {ok, CurPos} = ?PRIM_FILE:position(Fd, {cur, 0}),
+    ?line RealPos = 4273,
+    ?line {ok, RealPos} = ?PRIM_FILE:position(Fd, {cur, RealPos-CurPos}),
+    ?line RealProg = "<LI> Real Programmers aren't afraid to use GOTOs.\n",
+    ?line {ok, RealProg} = ?PRIM_FILE:read(Fd, length(RealProg)),
+
+    %% Seek backward.
+
+    ?line AfterTitle = length("<TITLE>"),
+    ?line {ok, AfterTitle} = ?PRIM_FILE:position(Fd, AfterTitle),
+    ?line Title = "Real Programmers Don't Use PASCAL</TITLE>\n",
+    ?line {ok, Title} = ?PRIM_FILE:read(Fd, length(Title)),
+
+    %% Done.
+
+    ?line ?PRIM_FILE:close(Fd),
+    ?line test_server:timetrap_cancel(Dog),
+    ok.
+
+write_compressed(suite) -> [];
+write_compressed(doc) -> [];
+write_compressed(Config) when is_list(Config) ->
+    ?line Dog = test_server:timetrap(test_server:seconds(10)),
+    ?line Priv = ?config(priv_dir, Config),
+    ?line MyFile = filename:join(Priv, 
+				 atom_to_list(?MODULE)++"_test.gz"),
+
+    %% Write a file.
+
+    ?line {ok, Fd} = ?PRIM_FILE:open(MyFile, [write, compressed]),
+    ?line {ok, 0} = ?PRIM_FILE:position(Fd, 0),
+    ?line Prefix = "hello\n",
+    ?line End = "end\n",
+    ?line ok = ?PRIM_FILE:write(Fd, Prefix),
+    ?line {ok, 143} = ?PRIM_FILE:position(Fd, 143),
+    ?line ok = ?PRIM_FILE:write(Fd, End),
+    ?line ok = ?PRIM_FILE:close(Fd),
+
+    %% Read the file and verify the contents.
+
+    ?line {ok, Fd1} = ?PRIM_FILE:open(MyFile, [read, compressed]),
+    ?line {ok, Prefix} = ?PRIM_FILE:read(Fd1, length(Prefix)),
+    ?line Second = lists:duplicate(143-length(Prefix), 0) ++ End,
+    ?line {ok, Second} = ?PRIM_FILE:read(Fd1, length(Second)),
+    ?line 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 ->
+	    test_server:fail(file_not_compressed)
+    end,
+
+    %% Write again to ensure that the file is truncated.
+
+    ?line {ok, Fd2} = ?PRIM_FILE:open(MyFile, [write, compressed]),
+    ?line NewString = "aaaaaaaaaaa",
+    ?line ok = ?PRIM_FILE:write(Fd2, NewString),
+    ?line ok = ?PRIM_FILE:close(Fd2),
+    ?line {ok, Fd3} = ?PRIM_FILE:open(MyFile, [read, compressed]),
+    ?line {ok, NewString} = ?PRIM_FILE:read(Fd3, 1024),
+    ?line ok = ?PRIM_FILE:close(Fd3),
+
+    %% Done.
+
+    ?line test_server:timetrap_cancel(Dog),
+    ok.
+
+compress_errors(suite) -> [];
+compress_errors(doc) -> [];
+compress_errors(Config) when is_list(Config) ->
+    ?line Dog = test_server:timetrap(test_server:seconds(10)),
+    ?line Data = ?config(data_dir, Config),
+    ?line {error, enoent} = ?PRIM_FILE:open("non_existing__",
+				      [compressed, read]),
+    ?line {error, einval} = ?PRIM_FILE:open("non_existing__",
+				      [compressed, read, write]),
+
+    %% Read a corrupted .gz file.
+
+    ?line Corrupted = filename:join(Data, "corrupted.gz"),
+    ?line {ok, Fd} = ?PRIM_FILE:open(Corrupted, [read, compressed]),
+    ?line {error, eio} = ?PRIM_FILE:read(Fd, 100),
+    ?line ?PRIM_FILE:close(Fd),
+
+    ?line test_server:timetrap_cancel(Dog),
+    ok.
+
+links(doc) -> "Test the link functions.";
+links(suite) -> 
+    [make_link_a, make_link_b, 
+     read_link_info_for_non_link, 
+     symlinks_a, symlinks_b].
+
+make_link_a(doc) -> "Test creating a hard link.";
+make_link_a(suite) -> [];
+make_link_a(Config) when is_list(Config) ->
+    make_link(Config, [], "_a").
+
+make_link_b(doc) -> "Test creating a hard link.";
+make_link_b(suite) -> [];
+make_link_b(Config) when is_list(Config) ->
+    ?line {ok, Handle} = ?PRIM_FILE:start(),
+    Result = make_link(Config, Handle, "_b"),
+    ?line ok = ?PRIM_FILE:stop(Handle),
+    Result.
+
+make_link(Config, Handle, Suffix) ->
+    ?line Dog = test_server:timetrap(test_server:seconds(10)),
+    ?line RootDir = ?config(priv_dir, Config),
+    ?line NewDir = filename:join(RootDir, 
+				 atom_to_list(?MODULE)
+				 ++"_make_link"++Suffix),
+    ?line ok = ?PRIM_FILE_call(make_dir, Handle, [NewDir]),
+    
+    ?line Name = filename:join(NewDir, "a_file"),
+    ?line ok = ?PRIM_FILE:write_file(Name, "some contents\n"),
+    
+    ?line Alias = filename:join(NewDir, "an_alias"),
+    ?line Result = 
+	case ?PRIM_FILE_call(make_link, Handle, [Name, Alias]) of
+	    {error, enotsup} ->
+		{skipped, "Links not supported on this platform"};
+	    ok ->
+		%% Note: We take the opportunity to test 
+		%% ?PRIM_FILE:read_link_info/1,
+		%% which should in behave exactly as 
+		%% ?PRIM_FILE:read_file_info/1
+		%% since they are not used on symbolic links.
+		
+		?line {ok, Info} = 
+		    ?PRIM_FILE_call(read_link_info, Handle, [Name]),
+		?line {ok, Info} = 
+		    ?PRIM_FILE_call(read_link_info, Handle, [Alias]),
+		?line #file_info{links = 2, type = regular} = Info,
+		?line {error, eexist} = 
+		    ?PRIM_FILE_call(make_link, Handle, [Name, Alias]),
+		ok
+	end,
+    
+    ?line test_server:timetrap_cancel(Dog),
+    Result.
+
+read_link_info_for_non_link(doc) ->
+    "Test that reading link info for an ordinary file or directory works "
+	"(on all platforms).";
+read_link_info_for_non_link(suite) -> [];
+read_link_info_for_non_link(Config) when is_list(Config) ->
+    ?line Dog = test_server:timetrap(test_server:seconds(10)),
+
+    ?line {ok, #file_info{type=directory}} = ?PRIM_FILE:read_link_info("."),
+		  
+    ?line test_server:timetrap_cancel(Dog),
+    ok.
+    
+symlinks_a(doc) -> "Test operations on symbolic links (for Unix).";
+symlinks_a(suite) -> [];
+symlinks_a(Config) when is_list(Config) ->
+    symlinks(Config, [], "_a").
+
+symlinks_b(doc) -> "Test operations on symbolic links (for Unix).";
+symlinks_b(suite) -> [];
+symlinks_b(Config) when is_list(Config) ->
+    ?line {ok, Handle} = ?PRIM_FILE:start(),
+    Result = symlinks(Config, Handle, "_b"),
+    ?line ok = ?PRIM_FILE:stop(Handle),
+    Result.
+
+symlinks(Config, Handle, Suffix) ->
+    ?line Dog = test_server:timetrap(test_server:seconds(10)),
+    ?line RootDir = ?config(priv_dir, Config),
+    ?line NewDir = filename:join(RootDir, 
+				 atom_to_list(?MODULE)
+				 ++"_make_symlink"++Suffix),
+    ?line ok = ?PRIM_FILE_call(make_dir, Handle, [NewDir]),
+    
+    ?line Name = filename:join(NewDir, "a_plain_file"),
+    ?line ok = ?PRIM_FILE:write_file(Name, "some stupid content\n"),
+    
+    ?line Alias = filename:join(NewDir, "a_symlink_alias"),
+    ?line Result = 
+	case ?PRIM_FILE_call(make_symlink, Handle, [Name, Alias]) of
+	    {error, enotsup} ->
+		{skipped, "Links not supported on this platform"};
+	    ok ->
+		?line {ok, Info1} = 
+		    ?PRIM_FILE_call(read_file_info, Handle, [Name]),
+		?line {ok, Info1} = 
+		    ?PRIM_FILE_call(read_file_info, Handle, [Alias]),
+		?line {ok, Info1} = 
+		    ?PRIM_FILE_call(read_link_info, Handle, [Name]),
+		?line #file_info{links = 1, type = regular} = Info1,
+		
+		?line {ok, Info2} = 
+		    ?PRIM_FILE_call(read_link_info, Handle, [Alias]),
+		?line #file_info{links=1, type=symlink} = Info2,
+		?line {ok, Name} = 
+		    ?PRIM_FILE_call(read_link, Handle, [Alias]),
+		ok
+	end,
+    
+    ?line test_server:timetrap_cancel(Dog),
+    Result.
+
+%% Creates as many files as possible during a certain time, 
+%% periodically calls list_dir/2 to check if it works,
+%% then deletes all files.
+
+list_dir_limit(doc) ->
+    "Tests if large directories can be read";
+list_dir_limit(suite) ->
+    [];
+list_dir_limit(Config) when is_list(Config) ->
+    ?line MaxTime = 120, 
+    ?line MaxNumber = 20000, 
+    ?line Dog = test_server:timetrap(
+		  test_server:seconds(2*MaxTime + MaxTime)),
+    ?line RootDir = ?config(priv_dir, Config),
+    ?line NewDir = filename:join(RootDir,
+				 atom_to_list(?MODULE)++"_list_dir_limit"),
+    ?line {ok, Handle1} = ?PRIM_FILE:start(),
+    ?line ok = ?PRIM_FILE_call(make_dir, Handle1, [NewDir]),
+    Ref = erlang:start_timer(MaxTime*1000, self(), []),
+    ?line Result = list_dir_limit_loop(NewDir, Handle1, Ref, MaxNumber, 0),
+    ?line Time = case erlang:cancel_timer(Ref) of
+		     false -> MaxTime;
+		     T -> MaxTime - (T div 1000)
+		 end,
+    ?line Number = case Result of
+		       {ok, N} -> N;
+		       {error, _Reason, N} -> N;
+		       _ -> 0
+		   end,
+    ?line {ok, Handle2} = ?PRIM_FILE:start(),
+    ?line list_dir_limit_cleanup(NewDir, Handle2, Number, 0),
+    ?line ok = ?PRIM_FILE:stop(Handle1),
+    ?line ok = ?PRIM_FILE:stop(Handle2),
+    ?line {ok, Number} = Result,
+    ?line test_server:timetrap_cancel(Dog),
+    {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) ->
+    receive 
+	{timeout, Ref, []} -> 
+	    list_dir_check(Dir, Handle, Cnt)
+    after 0 ->
+	    Name = integer_to_list(Cnt),
+	    case ?PRIM_FILE:write_file(filename:join(Dir, Name), Name) of
+		ok ->
+		    Next = Cnt + 1,
+		    case Cnt rem 100 of
+			0 ->
+			    case list_dir_check(Dir, Handle, Next) of
+				{ok, Next} ->
+				    list_dir_limit_loop(
+				      Dir, Handle, Ref, N, Next);
+				Other ->
+				    Other
+			    end;
+			_ ->
+			    list_dir_limit_loop(Dir, Handle, 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
+	{ok, ListDir} ->
+	    case length(ListDir) of
+		Cnt ->
+		    {ok, Cnt};
+		X ->
+		    {error, 
+		     {wrong_nof_files, X, ?LINE},
+		     Cnt}
+	    end;
+	{error, Reason} ->
+	    {error, Reason, Cnt}
+    end.
+
+%% 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 ->
+    Name = integer_to_list(Cnt),
+    case ?PRIM_FILE:delete(Handle, filename:join(Dir, Name)) of
+	ok ->
+	    list_dir_limit_cleanup(Dir, Handle, N, Cnt+1);
+	_ ->
+	    ok
+    end;
+list_dir_limit_cleanup(Dir, Handle, N, Cnt) ->
+    Name = integer_to_list(Cnt),
+    ?PRIM_FILE:delete(Handle, filename:join(Dir, Name)),
+    list_dir_limit_cleanup(Dir, Handle, N, Cnt+1).
+