aboutsummaryrefslogtreecommitdiffstats
path: root/lib/kernel/test/file_SUITE.erl
diff options
context:
space:
mode:
Diffstat (limited to 'lib/kernel/test/file_SUITE.erl')
-rw-r--r--lib/kernel/test/file_SUITE.erl3926
1 files changed, 1821 insertions, 2105 deletions
diff --git a/lib/kernel/test/file_SUITE.erl b/lib/kernel/test/file_SUITE.erl
index 09d9a45197..74db2970af 100644
--- a/lib/kernel/test/file_SUITE.erl
+++ b/lib/kernel/test/file_SUITE.erl
@@ -51,20 +51,20 @@
pos1/1, pos2/1, pos3/1]).
-export([close/1, consult1/1, path_consult/1, delete/1]).
-export([ eval1/1, path_eval/1, script1/1, path_script/1,
- open1/1,
- old_modes/1, new_modes/1, path_open/1, open_errors/1]).
+ open1/1,
+ old_modes/1, new_modes/1, path_open/1, open_errors/1]).
-export([ file_info_basic_file/1, file_info_basic_directory/1,
- file_info_bad/1, file_info_times/1, file_write_file_info/1]).
+ file_info_bad/1, file_info_times/1, file_write_file_info/1]).
-export([rename/1, access/1, truncate/1, datasync/1, sync/1,
read_write/1, pread_write/1, append/1, exclusive/1]).
-export([ e_delete/1, e_rename/1, e_make_dir/1, e_del_dir/1]).
-export([otp_5814/1, otp_10852/1]).
-export([ read_not_really_compressed/1,
- read_compressed_cooked/1, read_compressed_cooked_binary/1,
- read_cooked_tar_problem/1,
- write_compressed/1, compress_errors/1, catenated_gzips/1,
- compress_async_crash/1]).
+ read_compressed_cooked/1, read_compressed_cooked_binary/1,
+ read_cooked_tar_problem/1,
+ write_compressed/1, compress_errors/1, catenated_gzips/1,
+ compress_async_crash/1]).
-export([ make_link/1, read_link_info_for_non_link/1, symlinks/1]).
@@ -83,7 +83,7 @@
-export([unicode/1]).
-export([altname/1]).
--export([large_file/1, large_write/1]).
+-export([large_file/0, large_file/1, large_write/1]).
-export([read_line_1/1, read_line_2/1, read_line_3/1,read_line_4/1]).
@@ -106,13 +106,15 @@
%% System probe functions that might be handy to check from the shell
-export([disc_free/1, memsize/0]).
--include_lib("test_server/include/test_server.hrl").
+-include_lib("common_test/include/ct.hrl").
-include_lib("kernel/include/file.hrl").
-define(THROW_ERROR(RES), throw({fail, ?LINE, RES})).
-suite() -> [{ct_hooks,[ts_install_cth]}].
+suite() ->
+ [{ct_hooks,[ts_install_cth]},
+ {timetrap,{minutes,1}}].
all() ->
[unicode, altname, read_write_file, {group, dirs},
@@ -168,16 +170,11 @@ init_per_suite(Config) when is_list(Config) ->
ok ->
[{sasl,started}]
end,
- ok = case os:type() of
- {ose,_} ->
- ok;
- _ ->
- application:start(os_mon)
- end,
+ application:start(os_mon),
case os:type() of
{win32, _} ->
- Priv = ?config(priv_dir, Config),
+ Priv = proplists:get_value(priv_dir, Config),
HasAccessTime =
case ?FILE_MODULE:read_file_info(Priv) of
{ok, #file_info{atime={_, {0, 0, 0}}}} ->
@@ -199,12 +196,7 @@ end_per_suite(Config) when is_list(Config) ->
ok
end,
- case os:type() of
- {ose,_} ->
- ok;
- _ ->
- application:stop(os_mon)
- end,
+ application:stop(os_mon),
case proplists:get_value(sasl, Config) of
started ->
application:stop(sasl);
@@ -271,73 +263,66 @@ mini_server(Parent) ->
mini_server(Parent)
end.
-standard_io(suite) ->
- [];
-standard_io(doc) ->
- ["Test that standard i/o-servers work with file module"];
+%% Test that standard i/o-servers work with file module.
standard_io(Config) when is_list(Config) ->
%% Really just a smoke test
- ?line Pid = spawn(?MODULE,mini_server,[self()]),
- ?line register(mini_server,Pid),
- ?line ok = file:write(mini_server,<<"hej\n">>),
- ?line receive
- {io_request,_,_,{put_chars,<<"hej\n">>}} ->
- ok
- after 1000 ->
- exit(noreply)
- end,
- ?line {ok,"aaaaa"} = file:read(mini_server,5),
- ?line receive
- {io_request,_,_,{get_chars,'',5}} ->
- ok
- after 1000 ->
- exit(noreply)
- end,
- ?line {ok,"hej\n"} = file:read_line(mini_server),
- ?line receive
- {io_request,_,_,{get_line,''}} ->
- ok
- after 1000 ->
- exit(noreply)
- end,
- ?line OldGL = group_leader(),
- ?line group_leader(Pid,self()),
- ?line ok = file:write(standard_io,<<"hej\n">>),
- ?line group_leader(OldGL,self()),
- ?line receive
- {io_request,_,_,{put_chars,<<"hej\n">>}} ->
- ok
- after 1000 ->
- exit(noreply)
- end,
- ?line group_leader(Pid,self()),
- ?line {ok,"aaaaa"} = file:read(standard_io,5),
- ?line group_leader(OldGL,self()),
- ?line receive
- {io_request,_,_,{get_chars,'',5}} ->
- ok
- after 1000 ->
- exit(noreply)
- end,
- ?line group_leader(Pid,self()),
- ?line {ok,"hej\n"} = file:read_line(standard_io),
- ?line group_leader(OldGL,self()),
- ?line receive
- {io_request,_,_,{get_line,''}} ->
- ok
- after 1000 ->
- exit(noreply)
- end,
+ Pid = spawn(?MODULE,mini_server,[self()]),
+ register(mini_server,Pid),
+ ok = file:write(mini_server,<<"hej\n">>),
+ receive
+ {io_request,_,_,{put_chars,<<"hej\n">>}} ->
+ ok
+ after 1000 ->
+ exit(noreply)
+ end,
+ {ok,"aaaaa"} = file:read(mini_server,5),
+ receive
+ {io_request,_,_,{get_chars,'',5}} ->
+ ok
+ after 1000 ->
+ exit(noreply)
+ end,
+ {ok,"hej\n"} = file:read_line(mini_server),
+ receive
+ {io_request,_,_,{get_line,''}} ->
+ ok
+ after 1000 ->
+ exit(noreply)
+ end,
+ OldGL = group_leader(),
+ group_leader(Pid,self()),
+ ok = file:write(standard_io,<<"hej\n">>),
+ group_leader(OldGL,self()),
+ receive
+ {io_request,_,_,{put_chars,<<"hej\n">>}} ->
+ ok
+ after 1000 ->
+ exit(noreply)
+ end,
+ group_leader(Pid,self()),
+ {ok,"aaaaa"} = file:read(standard_io,5),
+ group_leader(OldGL,self()),
+ receive
+ {io_request,_,_,{get_chars,'',5}} ->
+ ok
+ after 1000 ->
+ exit(noreply)
+ end,
+ group_leader(Pid,self()),
+ {ok,"hej\n"} = file:read_line(standard_io),
+ group_leader(OldGL,self()),
+ receive
+ {io_request,_,_,{get_line,''}} ->
+ ok
+ after 1000 ->
+ exit(noreply)
+ end,
Pid ! die,
receive after 1000 -> ok end.
-old_io_protocol(suite) ->
- [];
-old_io_protocol(doc) ->
- ["Test that the old file IO protocol =< R16B still works"];
+%% Test that the old file IO protocol =< R16B still works.
old_io_protocol(Config) when is_list(Config) ->
- Dog = test_server:timetrap(test_server:seconds(5)),
- RootDir = ?config(priv_dir,Config),
+ RootDir = proplists:get_value(priv_dir,Config),
Name = filename:join(RootDir,
atom_to_list(?MODULE)
++"old_io_protocol.fil"),
@@ -350,14 +335,11 @@ old_io_protocol(Config) when is_list(Config) ->
end,
ok = ?FILE_MODULE:close(Fd),
{ok, <<>>} = ?FILE_MODULE:read_file(Name),
- test_server:timetrap_cancel(Dog),
[] = flush(),
ok.
-unicode_mode(suite) -> [];
-unicode_mode(doc) -> [""];
unicode_mode(Config) ->
- Dir = {dir, ?config(priv_dir,Config)},
+ Dir = {dir, proplists:get_value(priv_dir,Config)},
OptVariants = [[Dir],
[Dir, {encoding, utf8}],
[Dir, binary],
@@ -503,105 +485,98 @@ um_filename(Str = [_|_], Dir, Options) ->
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-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"),
+ RootDir = proplists:get_value(priv_dir,Config),
+ Name = filename:join(RootDir,
+ atom_to_list(?MODULE)
+ ++"_read_write_file"),
%% Try writing and reading back some term
- ?line SomeTerm = {"This term",{will,be},[written,$t,$o],1,file,[]},
- ?line ok = ?FILE_MODULE:write_file(Name,term_to_binary(SomeTerm)),
- ?line {ok,Bin1} = ?FILE_MODULE:read_file(Name),
- ?line SomeTerm = binary_to_term(Bin1),
-
+ SomeTerm = {"This term",{will,be},[written,$t,$o],1,file,[]},
+ ok = ?FILE_MODULE:write_file(Name,term_to_binary(SomeTerm)),
+ {ok,Bin1} = ?FILE_MODULE:read_file(Name),
+ SomeTerm = binary_to_term(Bin1),
+
%% Try a "null" term
- ?line NullTerm = [],
- ?line ok = ?FILE_MODULE:write_file(Name,term_to_binary(NullTerm)),
- ?line {ok,Bin2} = ?FILE_MODULE:read_file(Name),
- ?line NullTerm = binary_to_term(Bin2),
+ NullTerm = [],
+ ok = ?FILE_MODULE:write_file(Name,term_to_binary(NullTerm)),
+ {ok,Bin2} = ?FILE_MODULE:read_file(Name),
+ NullTerm = binary_to_term(Bin2),
%% Try some "complicated" types
- ?line BigNum = 123456789012345678901234567890,
- ?line ComplTerm = {self(),make_ref(),BigNum,3.14159},
- ?line ok = ?FILE_MODULE:write_file(Name,term_to_binary(ComplTerm)),
- ?line {ok,Bin3} = ?FILE_MODULE:read_file(Name),
- ?line ComplTerm = binary_to_term(Bin3),
+ BigNum = 123456789012345678901234567890,
+ ComplTerm = {self(),make_ref(),BigNum,3.14159},
+ ok = ?FILE_MODULE:write_file(Name,term_to_binary(ComplTerm)),
+ {ok,Bin3} = ?FILE_MODULE:read_file(Name),
+ ComplTerm = binary_to_term(Bin3),
%% Try reading a nonexistent file
- ?line Name2 = filename:join(RootDir,
- atom_to_list(?MODULE)
- ++"_nonexistent_file"),
- ?line {error, enoent} = ?FILE_MODULE:read_file(Name2),
- ?line {error, enoent} = ?FILE_MODULE:read_file(""),
- ?line {error, enoent} = ?FILE_MODULE:read_file(''),
-
- % Try writing to a bad filename
- ?line {error, enoent} =
+ Name2 = filename:join(RootDir,
+ atom_to_list(?MODULE)
+ ++"_nonexistent_file"),
+ {error, enoent} = ?FILE_MODULE:read_file(Name2),
+ {error, enoent} = ?FILE_MODULE:read_file(""),
+ {error, enoent} = ?FILE_MODULE:read_file(''),
+
+ %% Try writing to a bad filename
+ {error, enoent} =
?FILE_MODULE:write_file("",term_to_binary(NullTerm)),
- % Try writing something else than a binary
- ?line {error, badarg} = ?FILE_MODULE:write_file(Name,{1,2,3}),
- ?line {error, badarg} = ?FILE_MODULE:write_file(Name,self()),
+ %% Try writing something else than a binary
+ {error, badarg} = ?FILE_MODULE:write_file(Name,{1,2,3}),
+ {error, badarg} = ?FILE_MODULE:write_file(Name,self()),
%% Some non-term binaries
- ?line ok = ?FILE_MODULE:write_file(Name,[]),
- ?line {ok,Bin4} = ?FILE_MODULE:read_file(Name),
- ?line 0 = byte_size(Bin4),
+ ok = ?FILE_MODULE:write_file(Name,[]),
+ {ok,Bin4} = ?FILE_MODULE:read_file(Name),
+ 0 = byte_size(Bin4),
- ?line ok = ?FILE_MODULE:write_file(Name,[Bin1,[],[[Bin2]]]),
- ?line {ok,Bin5} = ?FILE_MODULE:read_file(Name),
- ?line {Bin1,Bin2} = split_binary(Bin5,byte_size(Bin1)),
+ ok = ?FILE_MODULE:write_file(Name,[Bin1,[],[[Bin2]]]),
+ {ok,Bin5} = ?FILE_MODULE:read_file(Name),
+ {Bin1,Bin2} = split_binary(Bin5,byte_size(Bin1)),
- ?line [] = flush(),
- ?line test_server:timetrap_cancel(Dog),
+ [] = flush(),
ok.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-make_del_dir(suite) -> [];
-make_del_dir(doc) -> [];
make_del_dir(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)
- ++"_mk-dir"),
- ?line ok = ?FILE_MODULE:make_dir(NewDir),
- ?line {error, eexist} = ?FILE_MODULE:make_dir(NewDir),
- ?line ok = ?FILE_MODULE:del_dir(NewDir),
- ?line {error, enoent} = ?FILE_MODULE:del_dir(NewDir),
- % Make sure we are not in a directory directly under test_server
- % as that would result in eacces errors when trying to delete '..',
- % because there are processes having that directory as current.
- ?line ok = ?FILE_MODULE:make_dir(NewDir),
- ?line {ok,CurrentDir} = file:get_cwd(),
+ RootDir = proplists:get_value(priv_dir,Config),
+ NewDir = filename:join(RootDir,
+ atom_to_list(?MODULE)
+ ++"_mk-dir"),
+ ok = ?FILE_MODULE:make_dir(NewDir),
+ {error, eexist} = ?FILE_MODULE:make_dir(NewDir),
+ ok = ?FILE_MODULE:del_dir(NewDir),
+ {error, enoent} = ?FILE_MODULE:del_dir(NewDir),
+ %% Make sure we are not in a directory directly under test_server
+ %% as that would result in eacces errors when trying to delete '..',
+ %% because there are processes having that directory as current.
+ ok = ?FILE_MODULE:make_dir(NewDir),
+ {ok,CurrentDir} = file:get_cwd(),
case {os:type(), length(NewDir) >= 260 } of
{{win32,_}, true} ->
io:format("Skip set_cwd for windows path longer than 260 (MAX_PATH)\n", []),
io:format("\nNewDir = ~p\n", [NewDir]);
_ ->
- ?line ok = ?FILE_MODULE:set_cwd(NewDir)
+ ok = ?FILE_MODULE:set_cwd(NewDir)
end,
try
%% Check that we get an error when trying to create...
%% a deep directory
- ?line NewDir2 = filename:join(RootDir,
- atom_to_list(?MODULE)
- ++"_mk-dir-noexist/foo"),
- ?line {error, enoent} = ?FILE_MODULE:make_dir(NewDir2),
+ NewDir2 = filename:join(RootDir,
+ atom_to_list(?MODULE)
+ ++"_mk-dir-noexist/foo"),
+ {error, enoent} = ?FILE_MODULE:make_dir(NewDir2),
%% a nameless directory
- ?line {error, enoent} = ?FILE_MODULE:make_dir(""),
+ {error, enoent} = ?FILE_MODULE:make_dir(""),
%% a directory with illegal name
- ?line {error, badarg} = ?FILE_MODULE:make_dir({1,2,3}),
-
+ {error, badarg} = ?FILE_MODULE:make_dir({1,2,3}),
+
%% a directory with illegal name, even if it's a (bad) list
- ?line {error, badarg} = ?FILE_MODULE:make_dir([1,2,3,{}]),
-
+ {error, badarg} = ?FILE_MODULE:make_dir([1,2,3,{}]),
+
%% Maybe this isn't an error, exactly, but worth mentioning anyway:
%% ok = ?FILE_MODULE:make_dir([$f,$o,$o,0,$b,$a,$r])),
%% The above line works, and created a directory "./foo"
@@ -609,40 +584,36 @@ make_del_dir(Config) when is_list(Config) ->
%% a directory, but with a name that incorporates the "bar" part of
%% the list, so that [$f,$o,$o,0,$f,$o,$o] wouldn't refer to the same
%% dir. But this would slow it down.
-
+
%% Try deleting some bad directories
%% Deleting the parent directory to the current, sounds dangerous, huh?
%% Don't worry ;-) the parent directory should never be empty, right?
- ?line case ?FILE_MODULE:del_dir('..') of
- {error, eexist} -> ok;
- {error, eacces} -> ok; %OpenBSD
- {error, einval} -> ok %FreeBSD
- end,
- ?line {error, enoent} = ?FILE_MODULE:del_dir(""),
- ?line {error, badarg} = ?FILE_MODULE:del_dir([3,2,1,{}]),
-
- ?line [] = flush(),
- ?line test_server:timetrap_cancel(Dog)
+ case ?FILE_MODULE:del_dir('..') of
+ {error, eexist} -> ok;
+ {error, eacces} -> ok; %OpenBSD
+ {error, einval} -> ok %FreeBSD
+ end,
+ {error, enoent} = ?FILE_MODULE:del_dir(""),
+ {error, badarg} = ?FILE_MODULE:del_dir([3,2,1,{}]),
+
+ [] = flush()
after
- ?FILE_MODULE:set_cwd(CurrentDir)
+ ?FILE_MODULE:set_cwd(CurrentDir)
end,
ok.
-cur_dir_0(suite) -> [];
-cur_dir_0(doc) -> [];
cur_dir_0(Config) when is_list(Config) ->
- ?line Dog = test_server:timetrap(test_server:seconds(5)),
%% Find out the current dir, and cd to it ;-)
- ?line {ok,BaseDir} = ?FILE_MODULE:get_cwd(),
- ?line Dir1 = BaseDir ++ "", %% Check that it's a string
- ?line ok = ?FILE_MODULE:set_cwd(Dir1),
+ {ok,BaseDir} = ?FILE_MODULE:get_cwd(),
+ Dir1 = BaseDir ++ "", %% Check that it's a string
+ ok = ?FILE_MODULE:set_cwd(Dir1),
%% Make a new dir, and cd to that
- ?line RootDir = ?config(priv_dir,Config),
- ?line NewDir = filename:join(RootDir,
- atom_to_list(?MODULE)
- ++"_curdir"),
- ?line ok = ?FILE_MODULE:make_dir(NewDir),
+ RootDir = proplists:get_value(priv_dir,Config),
+ NewDir = filename:join(RootDir,
+ atom_to_list(?MODULE)
+ ++"_curdir"),
+ ok = ?FILE_MODULE:make_dir(NewDir),
case {os:type(), length(NewDir) >= 260} of
{{win32,_}, true} ->
io:format("Skip set_cwd for windows path longer than 260 (MAX_PATH):\n"),
@@ -675,50 +646,44 @@ cur_dir_0(Config) when is_list(Config) ->
{ok,OldDirFiles} = ?FILE_MODULE:list_dir("."),
false = lists:member(UncommonName,OldDirFiles)
end,
-
+
%% Try doing some bad things
- ?line {error, badarg} = ?FILE_MODULE:set_cwd({foo,bar}),
- ?line {error, enoent} = ?FILE_MODULE:set_cwd(""),
- ?line {error, enoent} = ?FILE_MODULE:set_cwd(".......a......"),
- ?line {ok,BaseDir} = ?FILE_MODULE:get_cwd(), %% Still there?
+ {error, badarg} = ?FILE_MODULE:set_cwd({foo,bar}),
+ {error, enoent} = ?FILE_MODULE:set_cwd(""),
+ {error, enoent} = ?FILE_MODULE:set_cwd(".......a......"),
+ {ok,BaseDir} = ?FILE_MODULE:get_cwd(), %% Still there?
%% On Windows, there should only be slashes, no backslashes,
%% in the return value of get_cwd().
%% (The test is harmless on Unix, because filenames usually
%% don't contain backslashes.)
- ?line {ok, BaseDir} = ?FILE_MODULE:get_cwd(),
- ?line false = lists:member($\\, BaseDir),
+ {ok, BaseDir} = ?FILE_MODULE:get_cwd(),
+ false = lists:member($\\, BaseDir),
- ?line [] = flush(),
- ?line test_server:timetrap_cancel(Dog),
+ [] = flush(),
ok.
%% Tests ?FILE_MODULE:get_cwd/1.
-cur_dir_1(suite) -> [];
-cur_dir_1(doc) -> [];
cur_dir_1(Config) when is_list(Config) ->
- ?line Dog = test_server:timetrap(test_server:seconds(5)),
-
- ?line case os:type() of
- {win32, _} ->
- win_cur_dir_1(Config);
- _ ->
- ?line {error, enotsup} = ?FILE_MODULE:get_cwd("d:")
- end,
- ?line [] = flush(),
- ?line test_server:timetrap_cancel(Dog),
+ case os:type() of
+ {win32, _} ->
+ win_cur_dir_1(Config);
+ _ ->
+ {error, enotsup} = ?FILE_MODULE:get_cwd("d:")
+ end,
+ [] = flush(),
ok.
-
+
win_cur_dir_1(_Config) ->
- ?line {ok,BaseDir} = ?FILE_MODULE:get_cwd(),
+ {ok,BaseDir} = ?FILE_MODULE:get_cwd(),
%% Get the drive letter from the current directory,
%% and try to get current directory for that drive.
- ?line [Drive,$:|_] = BaseDir,
- ?line {ok,BaseDir} = ?FILE_MODULE:get_cwd([Drive,$:]),
+ [Drive,$:|_] = BaseDir,
+ {ok,BaseDir} = ?FILE_MODULE:get_cwd([Drive,$:]),
io:format("BaseDir = ~s\n", [BaseDir]),
%% Unfortunately, there is no way to move away from the
@@ -733,7 +698,7 @@ win_cur_dir_1(_Config) ->
%%%
list_dir_error(Config) ->
- Priv = ?config(priv_dir, Config),
+ Priv = proplists:get_value(priv_dir, Config),
NonExisting = filename:join(Priv, "non-existing-dir"),
{error,enoent} = ?FILE_MODULE:list_dir(NonExisting),
ok.
@@ -743,7 +708,7 @@ list_dir_error(Config) ->
%%%
list_dir(Config) ->
- RootDir = ?config(priv_dir, Config),
+ RootDir = proplists:get_value(priv_dir, Config),
TestDir = filename:join(RootDir, ?MODULE_STRING++"_list_dir"),
?FILE_MODULE:make_dir(TestDir),
list_dir_1(TestDir, 42, []).
@@ -773,7 +738,7 @@ untranslatable_names(Config) ->
untranslatable_names_1(Config) ->
{ok,OldCwd} = file:get_cwd(),
- PrivDir = ?config(priv_dir, Config),
+ PrivDir = proplists:get_value(priv_dir, Config),
Dir = filename:join(PrivDir, "untranslatable_names"),
ok = file:make_dir(Dir),
Node = start_node(untranslatable_names, "+fnu"),
@@ -814,7 +779,7 @@ untranslatable_names_error(Config) ->
untranslatable_names_error_1(Config) ->
{ok,OldCwd} = file:get_cwd(),
- PrivDir = ?config(priv_dir, Config),
+ PrivDir = proplists:get_value(priv_dir, Config),
Dir = filename:join(PrivDir, "untranslatable_names_error"),
ok = file:make_dir(Dir),
Node = start_node(untranslatable_names, "+fnue"),
@@ -862,7 +827,7 @@ start_node(Name, Args) ->
ct:log("Trying to start ~w@~s~n", [Name,Host]),
case test_server:start_node(Name, peer, [{args,Args}]) of
{error,Reason} ->
- test_server:fail(Reason);
+ ct:fail(Reason);
{ok,Node} ->
ct:log("Node ~p started~n", [Node]),
Node
@@ -873,568 +838,504 @@ start_node(Name, Args) ->
-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 = ?FILE_MODULE:make_dir(NewDir),
- ?line Name = filename:join(NewDir, "foo1.fil"),
- ?line {ok,Fd1} = ?FILE_MODULE:open(Name,read_write),
- ?line {ok,Fd2} = ?FILE_MODULE:open(Name,read),
- ?line Str = "{a,tuple}.\n",
- ?line io:format(Fd1,Str,[]),
- ?line {ok,0} = ?FILE_MODULE:position(Fd1,bof),
- ?line Str = io:get_line(Fd1,''),
- ?line case io:get_line(Fd2,'') of
- Str -> Str;
- eof -> Str
- end,
- ?line ok = ?FILE_MODULE:close(Fd2),
- ?line {ok,0} = ?FILE_MODULE:position(Fd1,bof),
- ?line ok = ?FILE_MODULE:truncate(Fd1),
- ?line eof = io:get_line(Fd1,''),
- ?line ok = ?FILE_MODULE:close(Fd1),
- ?line {ok,Fd3} = ?FILE_MODULE:open(Name,read),
- ?line eof = io:get_line(Fd3,''),
- ?line ok = ?FILE_MODULE:close(Fd3),
- ?line [] = flush(),
- ?line test_server:timetrap_cancel(Dog),
+ RootDir = proplists:get_value(priv_dir,Config),
+ NewDir = filename:join(RootDir,
+ atom_to_list(?MODULE)
+ ++"_files"),
+ ok = ?FILE_MODULE:make_dir(NewDir),
+ Name = filename:join(NewDir, "foo1.fil"),
+ {ok,Fd1} = ?FILE_MODULE:open(Name,read_write),
+ {ok,Fd2} = ?FILE_MODULE:open(Name,read),
+ Str = "{a,tuple}.\n",
+ io:format(Fd1,Str,[]),
+ {ok,0} = ?FILE_MODULE:position(Fd1,bof),
+ Str = io:get_line(Fd1,''),
+ Str = io:get_line(Fd2,''),
+ ok = ?FILE_MODULE:close(Fd2),
+ {ok,0} = ?FILE_MODULE:position(Fd1,bof),
+ ok = ?FILE_MODULE:truncate(Fd1),
+ eof = io:get_line(Fd1,''),
+ ok = ?FILE_MODULE:close(Fd1),
+ {ok,Fd3} = ?FILE_MODULE:open(Name,read),
+ eof = io:get_line(Fd3,''),
+ ok = ?FILE_MODULE:close(Fd3),
+ [] = flush(),
ok.
%% Tests all open modes.
-old_modes(suite) -> [];
-old_modes(doc) -> [];
old_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)
- ++"_old_open_modes"),
- ?line ok = ?FILE_MODULE:make_dir(NewDir),
- ?line Name1 = filename:join(NewDir, "foo1.fil"),
- ?line Marker = "hello, world",
+ RootDir = proplists:get_value(priv_dir, Config),
+ NewDir = filename:join(RootDir,
+ atom_to_list(?MODULE)
+ ++"_old_open_modes"),
+ ok = ?FILE_MODULE:make_dir(NewDir),
+ Name1 = filename:join(NewDir, "foo1.fil"),
+ Marker = "hello, world",
%% write
- ?line {ok, Fd1} = ?FILE_MODULE:open(Name1, write),
- ?line ok = io:write(Fd1, Marker),
- ?line ok = io:put_chars(Fd1, ".\n"),
- ?line ok = ?FILE_MODULE:close(Fd1),
+ {ok, Fd1} = ?FILE_MODULE:open(Name1, write),
+ ok = io:write(Fd1, Marker),
+ ok = io:put_chars(Fd1, ".\n"),
+ ok = ?FILE_MODULE:close(Fd1),
%% read
- ?line {ok, Fd2} = ?FILE_MODULE:open(Name1, read),
- ?line {ok, Marker} = io:read(Fd2, prompt),
- ?line ok = ?FILE_MODULE:close(Fd2),
+ {ok, Fd2} = ?FILE_MODULE:open(Name1, read),
+ {ok, Marker} = io:read(Fd2, prompt),
+ ok = ?FILE_MODULE:close(Fd2),
%% read_write
- ?line {ok, Fd3} = ?FILE_MODULE:open(Name1, read_write),
- ?line {ok, Marker} = io:read(Fd3, prompt),
- ?line ok = io:write(Fd3, Marker),
- ?line ok = ?FILE_MODULE:close(Fd3),
+ {ok, Fd3} = ?FILE_MODULE:open(Name1, read_write),
+ {ok, Marker} = io:read(Fd3, prompt),
+ ok = io:write(Fd3, Marker),
+ ok = ?FILE_MODULE:close(Fd3),
- ?line [] = flush(),
- ?line test_server:timetrap_cancel(Dog),
+ [] = flush(),
ok.
-new_modes(suite) -> [];
-new_modes(doc) -> [];
new_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)
- ++"_new_open_modes"),
- ?line ok = ?FILE_MODULE:make_dir(NewDir),
- ?line Name1 = filename:join(NewDir, "foo1.fil"),
- ?line Marker = "hello, world",
+ RootDir = proplists:get_value(priv_dir, Config),
+ NewDir = filename:join(RootDir,
+ atom_to_list(?MODULE)
+ ++"_new_open_modes"),
+ ok = ?FILE_MODULE:make_dir(NewDir),
+ Name1 = filename:join(NewDir, "foo1.fil"),
+ Marker = "hello, world",
%% write
- ?line {ok, Fd1} = ?FILE_MODULE:open(Name1, [write]),
- ?line ok = io:write(Fd1, Marker),
- ?line ok = io:put_chars(Fd1, ".\n"),
- ?line ok = ?FILE_MODULE:close(Fd1),
+ {ok, Fd1} = ?FILE_MODULE:open(Name1, [write]),
+ ok = io:write(Fd1, Marker),
+ ok = io:put_chars(Fd1, ".\n"),
+ ok = ?FILE_MODULE:close(Fd1),
%% read
- ?line {ok, Fd2} = ?FILE_MODULE:open(Name1, [read]),
- ?line {ok, Marker} = io:read(Fd2, prompt),
- ?line ok = ?FILE_MODULE:close(Fd2),
+ {ok, Fd2} = ?FILE_MODULE:open(Name1, [read]),
+ {ok, Marker} = io:read(Fd2, prompt),
+ ok = ?FILE_MODULE:close(Fd2),
%% read and write
- ?line {ok, Fd3} = ?FILE_MODULE:open(Name1, [read, write]),
- ?line {ok, Marker} = io:read(Fd3, prompt),
- ?line ok = io:write(Fd3, Marker),
- ?line ok = ?FILE_MODULE:close(Fd3),
+ {ok, Fd3} = ?FILE_MODULE:open(Name1, [read, write]),
+ {ok, Marker} = io:read(Fd3, prompt),
+ ok = io:write(Fd3, Marker),
+ ok = ?FILE_MODULE:close(Fd3),
%% read by default
- ?line {ok, Fd4} = ?FILE_MODULE:open(Name1, []),
- ?line {ok, Marker} = io:read(Fd4, prompt),
- ?line ok = ?FILE_MODULE:close(Fd4),
+ {ok, Fd4} = ?FILE_MODULE:open(Name1, []),
+ {ok, Marker} = io:read(Fd4, prompt),
+ ok = ?FILE_MODULE:close(Fd4),
%% read and binary
- ?line {ok, Fd5} = ?FILE_MODULE:open(Name1, [read, binary]),
- ?line {ok, Marker} = io:read(Fd5, prompt),
- ?line ok = ?FILE_MODULE:close(Fd5),
+ {ok, Fd5} = ?FILE_MODULE:open(Name1, [read, binary]),
+ {ok, Marker} = io:read(Fd5, prompt),
+ ok = ?FILE_MODULE:close(Fd5),
%% read, raw
- ?line {ok, Fd6} = ?FILE_MODULE:open(Name1, [read, raw]),
- ?line {ok, [$\[]} = ?FILE_MODULE:read(Fd6, 1),
- ?line ok = ?FILE_MODULE:close(Fd6),
-
- %% write and sync
- case ?FILE_MODULE:open(Name1, [write, sync]) of
- {ok, Fd7} ->
- ok = io:write(Fd7, Marker),
- ok = io:put_chars(Fd7, ".\n"),
- ok = ?FILE_MODULE:close(Fd7),
- {ok, Fd8} = ?FILE_MODULE:open(Name1, [read]),
- {ok, Marker} = io:read(Fd8, prompt),
- ok = ?FILE_MODULE:close(Fd8);
- {error, enotsup} ->
- %% for platforms that don't support the sync option
- ok
- end,
-
- ?line [] = flush(),
- ?line test_server:timetrap_cancel(Dog),
- ok.
+ {ok, Fd6} = ?FILE_MODULE:open(Name1, [read, raw]),
+ {ok, [$\[]} = ?FILE_MODULE:read(Fd6, 1),
+ ok = ?FILE_MODULE:close(Fd6),
+
+ %% write and sync
+ case ?FILE_MODULE:open(Name1, [write, sync]) of
+ {ok, Fd7} ->
+ ok = io:write(Fd7, Marker),
+ ok = io:put_chars(Fd7, ".\n"),
+ ok = ?FILE_MODULE:close(Fd7),
+ {ok, Fd8} = ?FILE_MODULE:open(Name1, [read]),
+ {ok, Marker} = io:read(Fd8, prompt),
+ ok = ?FILE_MODULE:close(Fd8);
+ {error, enotsup} ->
+ %% for platforms that don't support the sync option
+ ok
+ end,
+
+ [] = flush(),
+ ok.
-path_open(suite) -> [];
-path_open(doc) -> [];
path_open(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)
- ++"_path_open"),
- ?line ok = ?FILE_MODULE:make_dir(NewDir),
- ?line FileName = "path_open.fil",
- ?line Name = filename:join(RootDir, FileName),
- ?line {ok,Fd1,_FullName1} =
+ RootDir = proplists:get_value(priv_dir,Config),
+ NewDir = filename:join(RootDir,
+ atom_to_list(?MODULE)
+ ++"_path_open"),
+ ok = ?FILE_MODULE:make_dir(NewDir),
+ FileName = "path_open.fil",
+ Name = filename:join(RootDir, FileName),
+ {ok,Fd1,_FullName1} =
?FILE_MODULE:path_open(
- [RootDir,
- "nosuch1",
- NewDir],FileName,write),
- ?line io:format(Fd1,"ABCDEFGH",[]),
- ?line ok = ?FILE_MODULE:close(Fd1),
+ [RootDir,
+ "nosuch1",
+ NewDir],FileName,write),
+ io:format(Fd1,"ABCDEFGH",[]),
+ ok = ?FILE_MODULE:close(Fd1),
%% locate it in the last dir
- ?line {ok,Fd2,_FullName2} =
+ {ok,Fd2,_FullName2} =
?FILE_MODULE:path_open(
- ["nosuch1",
- NewDir,
- RootDir],FileName,read),
- ?line {ok,2} =
+ ["nosuch1",
+ NewDir,
+ RootDir],FileName,read),
+ {ok,2} =
?FILE_MODULE:position(Fd2,2), "C" = io:get_chars(Fd2,'',1),
- ?line ok = ?FILE_MODULE:close(Fd2),
+ ok = ?FILE_MODULE:close(Fd2),
%% Try a failing path
- ?line {error, enoent} = ?FILE_MODULE:path_open(
- ["nosuch1",
- NewDir],FileName,read),
+ {error, enoent} = ?FILE_MODULE:path_open(
+ ["nosuch1",
+ NewDir],FileName,read),
%% Check that it's found regardless of path, if an absolute name given
- ?line {ok,Fd3,_FullPath3} =
+ {ok,Fd3,_FullPath3} =
?FILE_MODULE:path_open(
- ["nosuch1",
- NewDir],Name,read),
- ?line {ok,2} =
+ ["nosuch1",
+ NewDir],Name,read),
+ {ok,2} =
?FILE_MODULE:position(Fd3,2), "C" = io:get_chars(Fd3,'',1),
- ?line ok = ?FILE_MODULE:close(Fd3),
+ ok = ?FILE_MODULE:close(Fd3),
- ?line [] = flush(),
- ?line test_server:timetrap_cancel(Dog),
+ [] = flush(),
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} = ?FILE_MODULE:open(Name,read_write),
+ RootDir = proplists:get_value(priv_dir,Config),
+ Name = filename:join(RootDir,
+ atom_to_list(?MODULE)
+ ++"_close.fil"),
+ {ok,Fd1} = ?FILE_MODULE:open(Name,read_write),
%% Just closing it is no fun, we did that a million times already
%% This is a common error, for code written before Erlang 4.3
%% bacause then ?FILE_MODULE:open just returned a Pid, and not everyone
%% really checked what they got.
- ?line {'EXIT',_Msg} = (catch ok = ?FILE_MODULE:close({ok,Fd1})),
- ?line ok = ?FILE_MODULE:close(Fd1),
+ {'EXIT',_Msg} = (catch ok = ?FILE_MODULE:close({ok,Fd1})),
+ ok = ?FILE_MODULE:close(Fd1),
%% Try closing one more time
- ?line Val = ?FILE_MODULE:close(Fd1),
- ?line io:format("Second close gave: ~p",[Val]),
+ Val = ?FILE_MODULE:close(Fd1),
+ io:format("Second close gave: ~p",[Val]),
- ?line [] = flush(),
- ?line test_server:timetrap_cancel(Dog),
+ [] = flush(),
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} = ?FILE_MODULE:open(Name,write),
- ?line io:format(Fd1,Str,[]),
- ?line ok = ?FILE_MODULE:close(Fd1),
+ RootDir = proplists:get_value(priv_dir,Config),
+ Name = filename:join(RootDir,
+ atom_to_list(?MODULE)
+ ++"_access.fil"),
+ Str = "ABCDEFGH",
+ {ok,Fd1} = ?FILE_MODULE:open(Name,write),
+ io:format(Fd1,Str,[]),
+ ok = ?FILE_MODULE:close(Fd1),
%% Check that we can't write when in read only mode
- ?line {ok,Fd2} = ?FILE_MODULE:open(Name,read),
- ?line case catch io:format(Fd2,"XXXX",[]) of
- ok ->
- test_server:fail({format,write});
- _ ->
- ok
- end,
- ?line ok = ?FILE_MODULE:close(Fd2),
- ?line {ok,Fd3} = ?FILE_MODULE:open(Name,read),
- ?line Str = io:get_line(Fd3,''),
- ?line ok = ?FILE_MODULE:close(Fd3),
+ {ok,Fd2} = ?FILE_MODULE:open(Name,read),
+ case catch io:format(Fd2,"XXXX",[]) of
+ ok ->
+ ct:fail({format,write});
+ _ ->
+ ok
+ end,
+ ok = ?FILE_MODULE:close(Fd2),
+ {ok,Fd3} = ?FILE_MODULE:open(Name,read),
+ Str = io:get_line(Fd3,''),
+ ok = ?FILE_MODULE:close(Fd3),
- ?line [] = flush(),
- ?line test_server:timetrap_cancel(Dog),
+ [] = flush(),
ok.
%% Tests ?FILE_MODULE:read/2 and ?FILE_MODULE: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 = ?FILE_MODULE:make_dir(NewDir),
- ?line Marker = "hello, world",
- ?line MarkerB = list_to_binary(Marker),
+ RootDir = proplists:get_value(priv_dir, Config),
+ NewDir = filename:join(RootDir,
+ atom_to_list(?MODULE)
+ ++"_read_write"),
+ ok = ?FILE_MODULE:make_dir(NewDir),
+ Marker = "hello, world",
+ MarkerB = list_to_binary(Marker),
%% Plain file.
- ?line Name1 = filename:join(NewDir, "plain.fil"),
- ?line {ok, Fd1} = ?FILE_MODULE:open(Name1, [read, write]),
- ?line read_write_test(Fd1, Marker, []),
+ Name1 = filename:join(NewDir, "plain.fil"),
+ {ok, Fd1} = ?FILE_MODULE:open(Name1, [read, write]),
+ read_write_test(Fd1, Marker, []),
%% Raw file.
- ?line Name2 = filename:join(NewDir, "raw.fil"),
- ?line {ok, Fd2} = ?FILE_MODULE:open(Name2, [read, write, raw]),
- ?line read_write_test(Fd2, Marker, []),
+ Name2 = filename:join(NewDir, "raw.fil"),
+ {ok, Fd2} = ?FILE_MODULE:open(Name2, [read, write, raw]),
+ read_write_test(Fd2, Marker, []),
%% Plain binary file.
- ?line Name3 = filename:join(NewDir, "plain-b.fil"),
- ?line {ok, Fd3} = ?FILE_MODULE:open(Name3, [read, write, binary]),
- ?line read_write_test(Fd3, MarkerB, <<>>),
+ Name3 = filename:join(NewDir, "plain-b.fil"),
+ {ok, Fd3} = ?FILE_MODULE:open(Name3, [read, write, binary]),
+ read_write_test(Fd3, MarkerB, <<>>),
%% Raw binary file.
- ?line Name4 = filename:join(NewDir, "raw-b.fil"),
- ?line {ok, Fd4} = ?FILE_MODULE:open(Name4, [read, write, raw, binary]),
- ?line read_write_test(Fd4, MarkerB, <<>>),
+ Name4 = filename:join(NewDir, "raw-b.fil"),
+ {ok, Fd4} = ?FILE_MODULE:open(Name4, [read, write, raw, binary]),
+ read_write_test(Fd4, MarkerB, <<>>),
- ?line test_server:timetrap_cancel(Dog),
ok.
read_write_test(File, Marker, Empty) ->
- ?line ok = ?FILE_MODULE:write(File, Marker),
- ?line {ok, 0} = ?FILE_MODULE:position(File, 0),
- ?line {ok, Empty} = ?FILE_MODULE:read(File, 0),
- ?line {ok, Marker} = ?FILE_MODULE:read(File, 100),
- ?line eof = ?FILE_MODULE:read(File, 100),
- ?line {ok, Empty} = ?FILE_MODULE:read(File, 0),
- ?line ok = ?FILE_MODULE:close(File),
- ?line [] = flush(),
+ ok = ?FILE_MODULE:write(File, Marker),
+ {ok, 0} = ?FILE_MODULE:position(File, 0),
+ {ok, Empty} = ?FILE_MODULE:read(File, 0),
+ {ok, Marker} = ?FILE_MODULE:read(File, 100),
+ eof = ?FILE_MODULE:read(File, 100),
+ {ok, Empty} = ?FILE_MODULE:read(File, 0),
+ ok = ?FILE_MODULE:close(File),
+ [] = flush(),
ok.
%% Tests ?FILE_MODULE:pread/2 and ?FILE_MODULE: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 = ?FILE_MODULE:make_dir(NewDir),
- ?line List = "hello, world",
- ?line Bin = list_to_binary(List),
+ RootDir = proplists:get_value(priv_dir, Config),
+ NewDir = filename:join(RootDir,
+ atom_to_list(?MODULE)
+ ++"_pread_write"),
+ ok = ?FILE_MODULE:make_dir(NewDir),
+ List = "hello, world",
+ Bin = list_to_binary(List),
%% Plain file.
- ?line Name1 = filename:join(NewDir, "plain.fil"),
- ?line {ok, Fd1} = ?FILE_MODULE:open(Name1, [read, write]),
- ?line pread_write_test(Fd1, List),
+ Name1 = filename:join(NewDir, "plain.fil"),
+ {ok, Fd1} = ?FILE_MODULE:open(Name1, [read, write]),
+ pread_write_test(Fd1, List),
%% Raw file.
- ?line Name2 = filename:join(NewDir, "raw.fil"),
- ?line {ok, Fd2} = ?FILE_MODULE:open(Name2, [read, write, raw]),
- ?line pread_write_test(Fd2, List),
+ Name2 = filename:join(NewDir, "raw.fil"),
+ {ok, Fd2} = ?FILE_MODULE:open(Name2, [read, write, raw]),
+ pread_write_test(Fd2, List),
%% Plain file. Binary mode.
- ?line Name3 = filename:join(NewDir, "plain-binary.fil"),
- ?line {ok, Fd3} = ?FILE_MODULE:open(Name3, [binary, read, write]),
- ?line pread_write_test(Fd3, Bin),
+ Name3 = filename:join(NewDir, "plain-binary.fil"),
+ {ok, Fd3} = ?FILE_MODULE:open(Name3, [binary, read, write]),
+ pread_write_test(Fd3, Bin),
%% Raw file. Binary mode.
- ?line Name4 = filename:join(NewDir, "raw-binary.fil"),
- ?line {ok, Fd4} = ?FILE_MODULE:open(Name4, [binary, read, write, raw]),
- ?line pread_write_test(Fd4, Bin),
+ Name4 = filename:join(NewDir, "raw-binary.fil"),
+ {ok, Fd4} = ?FILE_MODULE:open(Name4, [binary, read, write, raw]),
+ pread_write_test(Fd4, Bin),
- ?line test_server:timetrap_cancel(Dog),
ok.
pread_write_test(File, Data) ->
- ?line io:format("~p:pread_write_test(~p,~p)~n", [?MODULE, File, Data]),
- ?line Size = if is_binary(Data) -> byte_size(Data);
- is_list(Data) -> length(Data)
- end,
- ?line I = Size + 17,
- ?line ok = ?FILE_MODULE:pwrite(File, 0, Data),
+ io:format("~p:pread_write_test(~p,~p)~n", [?MODULE, File, Data]),
+ Size = if is_binary(Data) -> byte_size(Data);
+ is_list(Data) -> length(Data)
+ end,
+ I = Size + 17,
+ ok = ?FILE_MODULE:pwrite(File, 0, Data),
Res = ?FILE_MODULE:pread(File, 0, I),
- ?line {ok, Data} = Res,
- ?line eof = ?FILE_MODULE:pread(File, I, 1),
- ?line ok = ?FILE_MODULE:pwrite(File, [{0, Data}, {I, Data}]),
- ?line {ok, [Data, eof, Data]} =
+ {ok, Data} = Res,
+ eof = ?FILE_MODULE:pread(File, I, 1),
+ ok = ?FILE_MODULE:pwrite(File, [{0, Data}, {I, Data}]),
+ {ok, [Data, eof, Data]} =
?FILE_MODULE:pread(File, [{0, Size}, {2*I, 1}, {I, Size}]),
- ?line Plist = lists:seq(21*I, 0, -I),
- ?line Pwrite = lists:map(fun(P)->{P,Data}end, Plist),
- ?line Pread = [{22*I,Size} | lists:map(fun(P)->{P,Size}end, Plist)],
- ?line Presult = [eof | lists:map(fun(_)->Data end, Plist)],
- ?line ok = ?FILE_MODULE:pwrite(File, Pwrite),
- ?line {ok, Presult} = ?FILE_MODULE:pread(File, Pread),
- ?line ok = ?FILE_MODULE:close(File),
- ?line [] = flush(),
+ Plist = lists:seq(21*I, 0, -I),
+ Pwrite = lists:map(fun(P)->{P,Data}end, Plist),
+ Pread = [{22*I,Size} | lists:map(fun(P)->{P,Size}end, Plist)],
+ Presult = [eof | lists:map(fun(_)->Data end, Plist)],
+ ok = ?FILE_MODULE:pwrite(File, Pwrite),
+ {ok, Presult} = ?FILE_MODULE:pread(File, Pread),
+ ok = ?FILE_MODULE:close(File),
+ [] = flush(),
ok.
-append(doc) -> "Test appending to a file.";
-append(suite) -> [];
+%% Test appending to a file.
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 = ?FILE_MODULE:make_dir(NewDir),
+ RootDir = proplists:get_value(priv_dir, Config),
+ NewDir = filename:join(RootDir,
+ atom_to_list(?MODULE)
+ ++"_append"),
+ ok = ?FILE_MODULE:make_dir(NewDir),
- ?line First = "First line\n",
- ?line Second = "Seond lines comes here\n",
- ?line Third = "And here is the third line\n",
+ First = "First line\n",
+ Second = "Seond lines comes here\n",
+ Third = "And here is the third line\n",
%% Write a small text file.
- ?line Name1 = filename:join(NewDir, "a_file.txt"),
- ?line {ok, Fd1} = ?FILE_MODULE:open(Name1, [write]),
- ?line ok = io:format(Fd1, First, []),
- ?line ok = io:format(Fd1, Second, []),
- ?line ok = ?FILE_MODULE:close(Fd1),
+ Name1 = filename:join(NewDir, "a_file.txt"),
+ {ok, Fd1} = ?FILE_MODULE:open(Name1, [write]),
+ ok = io:format(Fd1, First, []),
+ ok = io:format(Fd1, Second, []),
+ ok = ?FILE_MODULE:close(Fd1),
%% Open it a again and a append a line to it.
- ?line {ok, Fd2} = ?FILE_MODULE:open(Name1, [append]),
- ?line ok = io:format(Fd2, Third, []),
- ?line ok = ?FILE_MODULE:close(Fd2),
+ {ok, Fd2} = ?FILE_MODULE:open(Name1, [append]),
+ ok = io:format(Fd2, Third, []),
+ ok = ?FILE_MODULE:close(Fd2),
%% Read it back and verify.
- ?line Expected = list_to_binary([First, Second, Third]),
- ?line {ok, Expected} = ?FILE_MODULE:read_file(Name1),
+ Expected = list_to_binary([First, Second, Third]),
+ {ok, Expected} = ?FILE_MODULE:read_file(Name1),
- ?line [] = flush(),
- ?line test_server:timetrap_cancel(Dog),
+ [] = flush(),
ok.
-open_errors(suite) -> [];
-open_errors(doc) -> [];
open_errors(Config) when is_list(Config) ->
- ?line Dog = test_server:timetrap(test_server:seconds(5)),
- ?line DataDir =
+ DataDir =
filename:dirname(
- filename:join(?config(data_dir, Config), "x")),
- ?line DataDirSlash = DataDir++"/",
- ?line {error, E1} = ?FILE_MODULE:open(DataDir, [read]),
- ?line {error, E2} = ?FILE_MODULE:open(DataDirSlash, [read]),
- ?line {error, E3} = ?FILE_MODULE:open(DataDir, [write]),
- ?line {error, E4} = ?FILE_MODULE:open(DataDirSlash, [write]),
- ?line {eisdir,eisdir,eisdir,eisdir} = {E1,E2,E3,E4},
-
- ?line [] = flush(),
- ?line test_server:timetrap_cancel(Dog),
+ filename:join(proplists:get_value(data_dir, Config), "x")),
+ DataDirSlash = DataDir++"/",
+ {error, E1} = ?FILE_MODULE:open(DataDir, [read]),
+ {error, E2} = ?FILE_MODULE:open(DataDirSlash, [read]),
+ {error, E3} = ?FILE_MODULE:open(DataDir, [write]),
+ {error, E4} = ?FILE_MODULE:open(DataDirSlash, [write]),
+ {eisdir,eisdir,eisdir,eisdir} = {E1,E2,E3,E4},
+
+ [] = flush(),
ok.
-exclusive(suite) -> [];
-exclusive(doc) -> "Test exclusive access to a file.";
+%% Test exclusive access to a file.
exclusive(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)
- ++"_exclusive"),
- ?line ok = ?FILE_MODULE:make_dir(NewDir),
- ?line Name = filename:join(NewDir, "ex_file.txt"),
- ?line {ok, Fd} = ?FILE_MODULE:open(Name, [write, exclusive]),
- ?line {error, eexist} = ?FILE_MODULE:open(Name, [write, exclusive]),
- ?line ok = ?FILE_MODULE:close(Fd),
- ?line test_server:timetrap_cancel(Dog),
+ RootDir = proplists:get_value(priv_dir,Config),
+ NewDir = filename:join(RootDir,
+ atom_to_list(?MODULE)
+ ++"_exclusive"),
+ ok = ?FILE_MODULE:make_dir(NewDir),
+ Name = filename:join(NewDir, "ex_file.txt"),
+ {ok, Fd} = ?FILE_MODULE:open(Name, [write, exclusive]),
+ {error, eexist} = ?FILE_MODULE:open(Name, [write, exclusive]),
+ ok = ?FILE_MODULE:close(Fd),
ok.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-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} = ?FILE_MODULE:open(Name,write),
- ?line io:format(Fd1,"ABCDEFGH",[]),
- ?line ok = ?FILE_MODULE:close(Fd1),
- ?line {ok,Fd2} = ?FILE_MODULE:open(Name,read),
+ RootDir = proplists:get_value(priv_dir,Config),
+ Name = filename:join(RootDir,
+ atom_to_list(?MODULE)
+ ++"_pos1.fil"),
+ {ok,Fd1} = ?FILE_MODULE:open(Name,write),
+ io:format(Fd1,"ABCDEFGH",[]),
+ ok = ?FILE_MODULE:close(Fd1),
+ {ok,Fd2} = ?FILE_MODULE:open(Name,read),
%% Start pos is first char
- ?line io:format("Relative positions"),
- ?line "A" = io:get_chars(Fd2,'',1),
- ?line {ok,2} = ?FILE_MODULE:position(Fd2,{cur,1}),
- ?line "C" = io:get_chars(Fd2,'',1),
- ?line {ok,0} = ?FILE_MODULE:position(Fd2,{cur,-3}),
- ?line "A" = io:get_chars(Fd2,'',1),
+ io:format("Relative positions"),
+ "A" = io:get_chars(Fd2,'',1),
+ {ok,2} = ?FILE_MODULE:position(Fd2,{cur,1}),
+ "C" = io:get_chars(Fd2,'',1),
+ {ok,0} = ?FILE_MODULE:position(Fd2,{cur,-3}),
+ "A" = io:get_chars(Fd2,'',1),
%% Backwards from first char should be an error
- ?line {ok,0} = ?FILE_MODULE:position(Fd2,{cur,-1}),
- ?line {error, einval} = ?FILE_MODULE:position(Fd2,{cur,-1}),
+ {ok,0} = ?FILE_MODULE:position(Fd2,{cur,-1}),
+ {error, einval} = ?FILE_MODULE:position(Fd2,{cur,-1}),
%% Reset position and move again
- ?line {ok,0} = ?FILE_MODULE:position(Fd2,0),
- ?line {ok,2} = ?FILE_MODULE:position(Fd2,{cur,2}),
- ?line "C" = io:get_chars(Fd2,'',1),
+ {ok,0} = ?FILE_MODULE:position(Fd2,0),
+ {ok,2} = ?FILE_MODULE:position(Fd2,{cur,2}),
+ "C" = io:get_chars(Fd2,'',1),
%% Go a lot forwards
- ?line {ok,13} = ?FILE_MODULE:position(Fd2,{cur,10}),
- ?line eof = io:get_chars(Fd2,'',1),
+ {ok,13} = ?FILE_MODULE:position(Fd2,{cur,10}),
+ eof = io:get_chars(Fd2,'',1),
%% Try some fixed positions
- ?line io:format("Fixed positions"),
- ?line {ok,8} =
+ io:format("Fixed positions"),
+ {ok,8} =
?FILE_MODULE:position(Fd2,8), eof = io:get_chars(Fd2,'',1),
- ?line {ok,8} =
+ {ok,8} =
?FILE_MODULE:position(Fd2,cur), eof = io:get_chars(Fd2,'',1),
- ?line {ok,7} =
+ {ok,7} =
?FILE_MODULE:position(Fd2,7), "H" = io:get_chars(Fd2,'',1),
- ?line {ok,0} =
+ {ok,0} =
?FILE_MODULE:position(Fd2,0), "A" = io:get_chars(Fd2,'',1),
- ?line {ok,3} =
+ {ok,3} =
?FILE_MODULE:position(Fd2,3), "D" = io:get_chars(Fd2,'',1),
- ?line {ok,12} =
+ {ok,12} =
?FILE_MODULE:position(Fd2,12), eof = io:get_chars(Fd2,'',1),
- ?line {ok,3} =
+ {ok,3} =
?FILE_MODULE:position(Fd2,3), "D" = io:get_chars(Fd2,'',1),
%% Try the {bof,X} notation
- ?line {ok,3} = ?FILE_MODULE:position(Fd2,{bof,3}),
- ?line "D" = io:get_chars(Fd2,'',1),
+ {ok,3} = ?FILE_MODULE:position(Fd2,{bof,3}),
+ "D" = io:get_chars(Fd2,'',1),
%% Try eof positions
- ?line io:format("EOF positions"),
- ?line {ok,8} =
+ io:format("EOF positions"),
+ {ok,8} =
?FILE_MODULE:position(Fd2,{eof,0}), eof=io:get_chars(Fd2,'',1),
- ?line {ok,7} =
+ {ok,7} =
?FILE_MODULE:position(Fd2,{eof,-1}),
- ?line "H" = io:get_chars(Fd2,'',1),
- ?line {ok,0} =
+ "H" = io:get_chars(Fd2,'',1),
+ {ok,0} =
?FILE_MODULE:position(Fd2,{eof,-8}), "A"=io:get_chars(Fd2,'',1),
- ?line {error, einval} = ?FILE_MODULE:position(Fd2,{eof,-9}),
+ {error, einval} = ?FILE_MODULE:position(Fd2,{eof,-9}),
- ?line [] = flush(),
- ?line test_server:timetrap_cancel(Dog),
+ [] = flush(),
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} = ?FILE_MODULE:open(Name,write),
- ?line io:format(Fd1,"ABCDEFGH",[]),
- ?line ok = ?FILE_MODULE:close(Fd1),
- ?line {ok,Fd2} = ?FILE_MODULE:open(Name,read),
- ?line {error, einval} = ?FILE_MODULE:position(Fd2,-1),
+ RootDir = proplists:get_value(priv_dir,Config),
+ Name = filename:join(RootDir,
+ atom_to_list(?MODULE)
+ ++"_pos2.fil"),
+ {ok,Fd1} = ?FILE_MODULE:open(Name,write),
+ io:format(Fd1,"ABCDEFGH",[]),
+ ok = ?FILE_MODULE:close(Fd1),
+ {ok,Fd2} = ?FILE_MODULE:open(Name,read),
+ {error, einval} = ?FILE_MODULE:position(Fd2,-1),
%% Make sure that we still can search after an error.
- ?line {ok,0} = ?FILE_MODULE:position(Fd2, 0),
- ?line {ok,3} = ?FILE_MODULE:position(Fd2, {bof,3}),
- ?line "D" = io:get_chars(Fd2,'',1),
+ {ok,0} = ?FILE_MODULE:position(Fd2, 0),
+ {ok,3} = ?FILE_MODULE:position(Fd2, {bof,3}),
+ "D" = io:get_chars(Fd2,'',1),
- ?line [] = flush(),
- ?line io:format("DONE"),
- ?line test_server:timetrap_cancel(Dog),
+ [] = flush(),
+ io:format("DONE"),
ok.
-pos3(suite) -> [];
-pos3(doc) -> ["When it does not use raw mode, file:position had a bug."];
+%% When it does not use raw mode, file:position had a bug.
pos3(Config) when is_list(Config) ->
- ?line Dog = test_server:timetrap(test_server:seconds(5)),
- ?line RootDir = ?config(data_dir, Config),
- ?line Name = filename:join(RootDir, "realmen.html.gz"),
+ RootDir = proplists:get_value(data_dir, Config),
+ Name = filename:join(RootDir, "realmen.html.gz"),
- ?line {ok, Fd} = ?FILE_MODULE:open(Name, [read, binary]),
- ?line {ok, _} = ?FILE_MODULE:read(Fd, 5),
- ?line {error, einval} = ?FILE_MODULE:position(Fd, {bof, -1}),
+ {ok, Fd} = ?FILE_MODULE:open(Name, [read, binary]),
+ {ok, _} = ?FILE_MODULE:read(Fd, 5),
+ {error, einval} = ?FILE_MODULE:position(Fd, {bof, -1}),
%% Here ok had returned =(
- ?line {error, einval} = ?FILE_MODULE:position(Fd, {cur, -10}),
+ {error, einval} = ?FILE_MODULE:position(Fd, {cur, -10}),
%% That test is actually questionable since file:position/2
%% is documented to leave the file position undefined after
%% it has returned an error. But on Posix systems the position
%% is guaranteed to be unchanged after an error return. On e.g
%% Windows there is nothing stated about this in the documentation.
- ?line test_server:timetrap_cancel(Dog),
ok.
-file_info_basic_file(suite) -> [];
-file_info_basic_file(doc) -> [];
file_info_basic_file(Config) when is_list(Config) ->
- ?line Dog = test_server:timetrap(test_server:seconds(5)),
- ?line RootDir = ?config(priv_dir, Config),
+ RootDir = proplists:get_value(priv_dir, Config),
%% Create a short file.
- ?line Name = filename:join(RootDir,
- atom_to_list(?MODULE)
- ++"_basic_test.fil"),
- ?line {ok,Fd1} = ?FILE_MODULE:open(Name, write),
- ?line io:put_chars(Fd1, "foo bar"),
- ?line ok = ?FILE_MODULE:close(Fd1),
+ Name = filename:join(RootDir,
+ atom_to_list(?MODULE)
+ ++"_basic_test.fil"),
+ {ok,Fd1} = ?FILE_MODULE:open(Name, write),
+ io:put_chars(Fd1, "foo bar"),
+ ok = ?FILE_MODULE:close(Fd1),
%% Test that the file has the expected attributes.
%% The times are tricky, so we will save them to a separate test case.
{ok,FileInfo} = ?FILE_MODULE:read_file_info(Name),
{ok,FileInfo} = ?FILE_MODULE:read_file_info(Name, [raw]),
#file_info{size=Size,type=Type,access=Access,
- atime=AccessTime,mtime=ModifyTime} = FileInfo,
- ?line io:format("Access ~p, Modify ~p", [AccessTime, ModifyTime]),
- ?line Size = 7,
- ?line Type = regular,
- ?line read_write = Access,
- ?line true = abs(time_dist(filter_atime(AccessTime, Config),
- filter_atime(ModifyTime,
- Config))) < 2,
- ?line all_integers(tuple_to_list(AccessTime) ++ tuple_to_list(ModifyTime)),
-
- ?line [] = flush(),
- ?line test_server:timetrap_cancel(Dog),
+ atime=AccessTime,mtime=ModifyTime} = FileInfo,
+ io:format("Access ~p, Modify ~p", [AccessTime, ModifyTime]),
+ Size = 7,
+ Type = regular,
+ read_write = Access,
+ true = abs(time_dist(filter_atime(AccessTime, Config),
+ filter_atime(ModifyTime,
+ Config))) < 2,
+ all_integers(tuple_to_list(AccessTime) ++ tuple_to_list(ModifyTime)),
+
+ [] = flush(),
ok.
-file_info_basic_directory(suite) -> [];
-file_info_basic_directory(doc) -> [];
file_info_basic_directory(Config) when is_list(Config) ->
- Dog = test_server:timetrap(test_server:seconds(5)),
-
%% Note: filename:join/1 removes any trailing slash,
%% which is essential for ?FILE_MODULE:file_info/1 to work on
%% platforms such as Windows95.
- RootDir = filename:join([?config(priv_dir, Config)]),
+ RootDir = filename:join([proplists:get_value(priv_dir, Config)]),
%% Test that the RootDir directory has the expected attributes.
test_directory(RootDir, read_write),
@@ -1445,65 +1346,57 @@ file_info_basic_directory(Config) when is_list(Config) ->
%% directories.
case os:type() of
{win32, _} ->
- ?line test_directory("/", read_write),
- ?line test_directory("c:/", read_write),
- ?line test_directory("c:\\", read_write);
+ test_directory("/", read_write),
+ test_directory("c:/", read_write),
+ test_directory("c:\\", read_write);
_ ->
- ?line test_directory("/", read)
+ test_directory("/", read)
end,
- test_server:timetrap_cancel(Dog).
+ ok.
test_directory(Name, ExpectedAccess) ->
{ok,FileInfo} = ?FILE_MODULE:read_file_info(Name),
{ok,FileInfo} = ?FILE_MODULE:read_file_info(Name, [raw]),
#file_info{size=Size,type=Type,access=Access,
atime=AccessTime,mtime=ModifyTime} = FileInfo,
- ?line io:format("Testing directory ~s", [Name]),
- ?line io:format("Directory size is ~p", [Size]),
- ?line io:format("Access ~p", [Access]),
- ?line io:format("Access time ~p; Modify time~p",
- [AccessTime, ModifyTime]),
- ?line Type = directory,
- ?line Access = ExpectedAccess,
- ?line all_integers(tuple_to_list(AccessTime) ++ tuple_to_list(ModifyTime)),
- ?line [] = flush(),
+ io:format("Testing directory ~s", [Name]),
+ io:format("Directory size is ~p", [Size]),
+ io:format("Access ~p", [Access]),
+ io:format("Access time ~p; Modify time~p",
+ [AccessTime, ModifyTime]),
+ Type = directory,
+ Access = ExpectedAccess,
+ all_integers(tuple_to_list(AccessTime) ++ tuple_to_list(ModifyTime)),
+ [] = flush(),
ok.
all_integers([{A,B,C}|T]) ->
all_integers([A,B,C|T]);
all_integers([Int|Rest]) when is_integer(Int) ->
- ?line all_integers(Rest);
+ all_integers(Rest);
all_integers([]) -> ok.
%% Try something nonexistent.
-file_info_bad(suite) -> [];
-file_info_bad(doc) -> [];
file_info_bad(Config) when is_list(Config) ->
- ?line Dog = test_server:timetrap(test_server:seconds(5)),
- ?line RootDir = filename:join([?config(priv_dir, Config)]),
+ RootDir = filename:join([proplists:get_value(priv_dir, Config)]),
FileName = filename:join(RootDir, atom_to_list(?MODULE) ++ "_nonexistent"),
{error,enoent} = ?FILE_MODULE:read_file_info(FileName),
{error,enoent} = ?FILE_MODULE:read_file_info(FileName, [raw]),
- ?line {error, enoent} = ?FILE_MODULE:read_file_info(""),
+ {error, enoent} = ?FILE_MODULE:read_file_info(""),
{error, enoent} = ?FILE_MODULE:read_file_info("", [raw]),
- ?line [] = flush(),
- ?line test_server:timetrap_cancel(Dog),
+ [] = flush(),
ok.
%% Test that the file times behave as they should.
-file_info_times(suite) -> [];
-file_info_times(doc) -> [];
file_info_times(Config) when is_list(Config) ->
- ?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) end),
- ?line test_server:timetrap_cancel(Dog),
+ test_server:m_out_of_n(
+ 1,2,
+ fun() -> file_info_int(Config) end),
ok.
file_info_int(Config) ->
@@ -1511,14 +1404,14 @@ file_info_int(Config) ->
%% which is essential for ?FILE_MODULE: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]),
+ RootDir = filename:join([proplists:get_value(priv_dir, Config)]),
+ io:format("RootDir = ~p", [RootDir]),
- ?line Name = filename:join(RootDir,
- atom_to_list(?MODULE)
- ++"_file_info.fil"),
- ?line {ok,Fd1} = ?FILE_MODULE:open(Name,write),
- ?line io:put_chars(Fd1,"foo"),
+ Name = filename:join(RootDir,
+ atom_to_list(?MODULE)
+ ++"_file_info.fil"),
+ {ok,Fd1} = ?FILE_MODULE:open(Name,write),
+ io:put_chars(Fd1,"foo"),
%% check that the file got a modify date max a few seconds away from now
{ok,FileInfo1} = ?FILE_MODULE:read_file_info(Name),
@@ -1531,31 +1424,31 @@ file_info_int(Config) ->
#file_info{type=regular,atime=AccTime1,mtime=ModTime1} = FileInfo1,
- ?line Now = erlang:localtime(), %???
- ?line io:format("Now ~p",[Now]),
- ?line io:format("Open file Acc ~p Mod ~p",[AccTime1,ModTime1]),
- ?line true = abs(time_dist(filter_atime(Now, Config),
- filter_atime(AccTime1,
- Config))) < 8,
- ?line true = abs(time_dist(Now,ModTime1)) < 8,
+ Now = erlang:localtime(), %???
+ io:format("Now ~p",[Now]),
+ io:format("Open file Acc ~p Mod ~p",[AccTime1,ModTime1]),
+ true = abs(time_dist(filter_atime(Now, Config),
+ filter_atime(AccTime1,
+ Config))) < 8,
+ true = abs(time_dist(Now,ModTime1)) < 8,
%% Sleep until we can be sure the seconds value has changed.
%% Note: FAT-based filesystem (like on Windows 95) have
%% a resolution of 2 seconds.
- ?line test_server:sleep(test_server:seconds(2.2)),
+ timer:sleep(2200),
%% close the file, and watch the modify date change
- ?line ok = ?FILE_MODULE:close(Fd1),
+ ok = ?FILE_MODULE:close(Fd1),
{ok,FileInfo2} = ?FILE_MODULE:read_file_info(Name),
{ok,FileInfo2} = ?FILE_MODULE:read_file_info(Name, [raw]),
#file_info{size=Size,type=regular,access=Access,
atime=AccTime2,mtime=ModTime2} = FileInfo2,
- ?line io:format("Closed file Acc ~p Mod ~p",[AccTime2,ModTime2]),
- ?line true = time_dist(ModTime1,ModTime2) >= 0,
+ io:format("Closed file Acc ~p Mod ~p",[AccTime2,ModTime2]),
+ true = time_dist(ModTime1,ModTime2) >= 0,
%% this file is supposed to be binary, so it'd better keep it's size
- ?line Size = 3,
- ?line Access = read_write,
+ Size = 3,
+ Access = read_write,
%% Do some directory checking
{ok,FileInfo3} = ?FILE_MODULE:read_file_info(RootDir),
@@ -1563,12 +1456,12 @@ file_info_int(Config) ->
#file_info{size=DSize,type=directory,access=DAccess,
atime=AccTime3,mtime=ModTime3} = FileInfo3,
%% this dir was modified only a few secs ago
- ?line io:format("Dir Acc ~p; Mod ~p; Now ~p", [AccTime3, ModTime3, Now]),
- ?line true = abs(time_dist(Now,ModTime3)) < 5,
- ?line DAccess = read_write,
- ?line io:format("Dir size is ~p",[DSize]),
+ io:format("Dir Acc ~p; Mod ~p; Now ~p", [AccTime3, ModTime3, Now]),
+ true = abs(time_dist(Now,ModTime3)) < 5,
+ DAccess = read_write,
+ io:format("Dir size is ~p",[DSize]),
- ?line [] = flush(),
+ [] = flush(),
ok.
%% Filter access times, to copy with a deficiency of FAT file systems
@@ -1579,9 +1472,9 @@ filter_atime(Atime, Config) ->
true ->
case Atime of
{Date, _} ->
- {Date, {0, 0, 0}};
+ {Date, {0, 0, 0}};
{Y, M, D, _, _, _} ->
- {Y, M, D, 0, 0, 0}
+ {Y, M, D, 0, 0, 0}
end;
false ->
Atime
@@ -1589,50 +1482,47 @@ filter_atime(Atime, Config) ->
%% Test the write_file_info/2 function.
-file_write_file_info(suite) -> [];
-file_write_file_info(doc) -> [];
file_write_file_info(Config) when is_list(Config) ->
- ?line Dog = test_server:timetrap(test_server:seconds(10)),
- ?line RootDir = get_good_directory(Config),
- ?line test_server:format("RootDir = ~p", [RootDir]),
+ RootDir = get_good_directory(Config),
+ io:format("RootDir = ~p", [RootDir]),
%% Set the file to read only AND update the file times at the same time.
%% (This used to fail on Windows NT/95 for a local filesystem.)
%% Note: Seconds must be even; see note in file_info_times/1.
- ?line Name1 = filename:join(RootDir,
- atom_to_list(?MODULE)
- ++"_write_file_info_ro"),
- ?line ok = ?FILE_MODULE:write_file(Name1, "hello"),
- ?line Time = {{1997, 01, 02}, {12, 35, 42}},
- ?line Info = #file_info{mode=8#400, atime=Time, mtime=Time, ctime=Time},
- ?line ok = ?FILE_MODULE:write_file_info(Name1, Info),
+ Name1 = filename:join(RootDir,
+ atom_to_list(?MODULE)
+ ++"_write_file_info_ro"),
+ ok = ?FILE_MODULE:write_file(Name1, "hello"),
+ Time = {{1997, 01, 02}, {12, 35, 42}},
+ Info = #file_info{mode=8#400, atime=Time, mtime=Time, ctime=Time},
+ ok = ?FILE_MODULE:write_file_info(Name1, Info),
%% Read back the times.
- ?line {ok, ActualInfo} = ?FILE_MODULE:read_file_info(Name1),
- ?line #file_info{mode=_Mode, atime=ActAtime, mtime=Time,
- ctime=ActCtime} = ActualInfo,
- ?line FilteredAtime = filter_atime(Time, Config),
- ?line FilteredAtime = filter_atime(ActAtime, Config),
- ?line case os:type() of
- {win32, _} ->
- %% On Windows, "ctime" means creation time and it can
- %% be set.
- ActCtime = Time;
- _ ->
- ok
- end,
- ?line {error, eacces} = ?FILE_MODULE:write_file(Name1, "hello again"),
+ {ok, ActualInfo} = ?FILE_MODULE:read_file_info(Name1),
+ #file_info{mode=_Mode, atime=ActAtime, mtime=Time,
+ ctime=ActCtime} = ActualInfo,
+ FilteredAtime = filter_atime(Time, Config),
+ FilteredAtime = filter_atime(ActAtime, Config),
+ case os:type() of
+ {win32, _} ->
+ %% On Windows, "ctime" means creation time and it can
+ %% be set.
+ ActCtime = Time;
+ _ ->
+ ok
+ end,
+ {error, eacces} = ?FILE_MODULE:write_file(Name1, "hello again"),
%% Make the file writable again.
- ?line ?FILE_MODULE:write_file_info(Name1, #file_info{mode=8#600}),
- ?line ok = ?FILE_MODULE:write_file(Name1, "hello again"),
+ ?FILE_MODULE:write_file_info(Name1, #file_info{mode=8#600}),
+ ok = ?FILE_MODULE:write_file(Name1, "hello again"),
%% And unwritable.
- ?line ?FILE_MODULE:write_file_info(Name1, #file_info{mode=8#400}),
- ?line {error, eacces} = ?FILE_MODULE:write_file(Name1, "hello again"),
+ ?FILE_MODULE:write_file_info(Name1, #file_info{mode=8#400}),
+ {error, eacces} = ?FILE_MODULE:write_file(Name1, "hello again"),
%% Same with raw.
?FILE_MODULE:write_file_info(Name1, #file_info{mode=8#600}, [raw]),
@@ -1643,634 +1533,577 @@ file_write_file_info(Config) when is_list(Config) ->
%% Write the times again.
%% Note: Seconds must be even; see note in file_info_times/1.
- ?line NewTime = {{1997, 02, 15}, {13, 18, 20}},
- ?line NewInfo = #file_info{atime=NewTime, mtime=NewTime, ctime=NewTime},
- ?line ok = ?FILE_MODULE:write_file_info(Name1, NewInfo),
- ?line {ok, ActualInfo2} = ?FILE_MODULE:read_file_info(Name1),
- ?line #file_info{atime=NewActAtime, mtime=NewTime,
- ctime=NewActCtime} = ActualInfo2,
- ?line NewFilteredAtime = filter_atime(NewTime, Config),
- ?line NewFilteredAtime = filter_atime(NewActAtime, Config),
- ?line case os:type() of
- {win32, _} -> NewActCtime = NewTime;
- _ -> ok
- end,
+ NewTime = {{1997, 02, 15}, {13, 18, 20}},
+ NewInfo = #file_info{atime=NewTime, mtime=NewTime, ctime=NewTime},
+ ok = ?FILE_MODULE:write_file_info(Name1, NewInfo),
+ {ok, ActualInfo2} = ?FILE_MODULE:read_file_info(Name1),
+ #file_info{atime=NewActAtime, mtime=NewTime,
+ ctime=NewActCtime} = ActualInfo2,
+ NewFilteredAtime = filter_atime(NewTime, Config),
+ NewFilteredAtime = filter_atime(NewActAtime, Config),
+ case os:type() of
+ {win32, _} -> NewActCtime = NewTime;
+ _ -> ok
+ end,
%% The file should still be unwritable.
- ?line {error, eacces} = ?FILE_MODULE:write_file(Name1, "hello again"),
+ {error, eacces} = ?FILE_MODULE:write_file(Name1, "hello again"),
%% Make the file writeable again, so that we can remove the
%% test suites ... :-)
- ?line ?FILE_MODULE:write_file_info(Name1, #file_info{mode=8#600}),
+ ?FILE_MODULE:write_file_info(Name1, #file_info{mode=8#600}),
- ?line [] = flush(),
- ?line test_server:timetrap_cancel(Dog),
+ [] = flush(),
ok.
%% Returns a directory on a file system that has correct file times.
get_good_directory(Config) ->
- ?line ?config(priv_dir, Config).
+ proplists:get_value(priv_dir, Config).
-consult1(suite) -> [];
-consult1(doc) -> [];
consult1(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)
- ++"_consult.fil"),
- ?line {ok,Fd1} = ?FILE_MODULE:open(Name,write),
+ RootDir = proplists:get_value(priv_dir,Config),
+ Name = filename:join(RootDir,
+ atom_to_list(?MODULE)
+ ++"_consult.fil"),
+ {ok,Fd1} = ?FILE_MODULE:open(Name,write),
%% note that there is no final \n (only a space)
- ?line io:format(Fd1,
- "{this,[is,1.0],'journey'}.\n\"into\". (sound). ",
- []),
- ?line ok = ?FILE_MODULE:close(Fd1),
- ?line {ok,[{this,[is,1.0],journey},"into",sound]} =
+ io:format(Fd1,
+ "{this,[is,1.0],'journey'}.\n\"into\". (sound). ",
+ []),
+ ok = ?FILE_MODULE:close(Fd1),
+ {ok,[{this,[is,1.0],journey},"into",sound]} =
?FILE_MODULE:consult(Name),
- ?line {ok,Fd2} = ?FILE_MODULE:open(Name,write),
+ {ok,Fd2} = ?FILE_MODULE:open(Name,write),
%% note the missing double quote
- ?line io:format(
- Fd2,"{this,[is,1.0],'journey'}.\n \"into. (sound). ",[]),
- ?line ok = ?FILE_MODULE:close(Fd2),
- ?line {error, {_, _, _} = Msg} = ?FILE_MODULE:consult(Name),
- ?line io:format("Errmsg: ~p",[Msg]),
+ io:format(
+ Fd2,"{this,[is,1.0],'journey'}.\n \"into. (sound). ",[]),
+ ok = ?FILE_MODULE:close(Fd2),
+ {error, {_, _, _} = Msg} = ?FILE_MODULE:consult(Name),
+ io:format("Errmsg: ~p",[Msg]),
- ?line {error, enoent} = ?FILE_MODULE:consult(Name ++ ".nonexistent"),
+ {error, enoent} = ?FILE_MODULE:consult(Name ++ ".nonexistent"),
- ?line [] = flush(),
- ?line test_server:timetrap_cancel(Dog),
+ [] = flush(),
ok.
-path_consult(suite) -> [];
-path_consult(doc) -> [];
path_consult(Config) when is_list(Config) ->
- ?line Dog = test_server:timetrap(test_server:seconds(5)),
- ?line RootDir = ?config(priv_dir,Config),
- ?line FileName = atom_to_list(?MODULE)++"_path_consult.fil",
- ?line Name = filename:join(RootDir, FileName),
- ?line {ok,Fd1} = ?FILE_MODULE:open(Name,write),
- ?line io:format(Fd1,"{this,is,a,journey,into,sound}.\n",[]),
- ?line ok = ?FILE_MODULE:close(Fd1),
+ RootDir = proplists:get_value(priv_dir,Config),
+ FileName = atom_to_list(?MODULE)++"_path_consult.fil",
+ Name = filename:join(RootDir, FileName),
+ {ok,Fd1} = ?FILE_MODULE:open(Name,write),
+ io:format(Fd1,"{this,is,a,journey,into,sound}.\n",[]),
+ ok = ?FILE_MODULE:close(Fd1),
%% File last in path
- ?line {ok,[{this,is,a,journey,into,sound}],Dir} =
+ {ok,[{this,is,a,journey,into,sound}],Dir} =
?FILE_MODULE:path_consult(
- [filename:join(RootDir, "dir1"),
- filename:join(RootDir, ".."),
- filename:join(RootDir, "dir2"),
- RootDir], FileName),
- ?line true = lists:prefix(RootDir,Dir),
+ [filename:join(RootDir, "dir1"),
+ filename:join(RootDir, ".."),
+ filename:join(RootDir, "dir2"),
+ RootDir], FileName),
+ true = lists:prefix(RootDir,Dir),
%% While maybe not an error, it may be worth noting that
%% when the full path to a file is given, it's always found
%% regardless of the contents of the path
- ?line {ok,_,_} = ?FILE_MODULE:path_consult(["nosuch1","nosuch2"],Name),
+ {ok,_,_} = ?FILE_MODULE:path_consult(["nosuch1","nosuch2"],Name),
- ?line [] = flush(),
- ?line test_server:timetrap_cancel(Dog),
+ [] = flush(),
ok.
-eval1(suite) -> [];
-eval1(doc) -> [];
eval1(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)++"_eval.fil"),
- ?line {ok,Fd1} = ?FILE_MODULE:open(Name,write),
+ RootDir = proplists:get_value(priv_dir,Config),
+ Name = filename:join(RootDir,
+ atom_to_list(?MODULE)++"_eval.fil"),
+ {ok,Fd1} = ?FILE_MODULE:open(Name,write),
%% note that there is no final \n (only a space)
- ?line io:format(Fd1,"put(evaluated_ok,\ntrue). ",[]),
- ?line ok = ?FILE_MODULE:close(Fd1),
- ?line ok = ?FILE_MODULE:eval(Name),
- ?line true = get(evaluated_ok),
-
- ?line {ok,Fd2} = ?FILE_MODULE:open(Name,write),
+ io:format(Fd1,"put(evaluated_ok,\ntrue). ",[]),
+ ok = ?FILE_MODULE:close(Fd1),
+ ok = ?FILE_MODULE:eval(Name),
+ true = get(evaluated_ok),
+
+ {ok,Fd2} = ?FILE_MODULE:open(Name,write),
%% note that there is no final \n (only a space)
- ?line io:format(Fd2,"put(evaluated_ok,\nR). ",[]),
- ?line ok = ?FILE_MODULE:close(Fd2),
- ?line ok = ?FILE_MODULE:eval(
- Name,
- erl_eval:add_binding('R', true, erl_eval:new_bindings())),
- ?line true = get(evaluated_ok),
-
- ?line {ok,Fd3} = ?FILE_MODULE:open(Name,write),
+ io:format(Fd2,"put(evaluated_ok,\nR). ",[]),
+ ok = ?FILE_MODULE:close(Fd2),
+ ok = ?FILE_MODULE:eval(
+ Name,
+ erl_eval:add_binding('R', true, erl_eval:new_bindings())),
+ true = get(evaluated_ok),
+
+ {ok,Fd3} = ?FILE_MODULE:open(Name,write),
%% garbled
- ?line io:format(Fd3,"puGARBLED-GARBLED\ntrue). ",[]),
- ?line ok = ?FILE_MODULE:close(Fd3),
- ?line {error, {_, _, _} = Msg} = ?FILE_MODULE:eval(Name),
- ?line io:format("Errmsg1: ~p",[Msg]),
-
- ?line {error, enoent} = ?FILE_MODULE:eval(Name ++ ".nonexistent"),
-
- ?line [] = flush(),
- ?line test_server:timetrap_cancel(Dog),
+ io:format(Fd3,"puGARBLED-GARBLED\ntrue). ",[]),
+ ok = ?FILE_MODULE:close(Fd3),
+ {error, {_, _, _} = Msg} = ?FILE_MODULE:eval(Name),
+ io:format("Errmsg1: ~p",[Msg]),
+
+ {error, enoent} = ?FILE_MODULE:eval(Name ++ ".nonexistent"),
+
+ [] = flush(),
ok.
-path_eval(suite) -> [];
-path_eval(doc) -> [];
path_eval(Config) when is_list(Config) ->
- ?line Dog = test_server:timetrap(test_server:seconds(5)),
- ?line RootDir = ?config(priv_dir,Config),
- ?line FileName = atom_to_list(?MODULE)++"_path_eval.fil",
- ?line Name = filename:join(RootDir, FileName),
- ?line {ok,Fd1} = ?FILE_MODULE:open(Name,write),
- ?line io:format(Fd1,"put(evaluated_ok,true).\n",[]),
- ?line ok = ?FILE_MODULE:close(Fd1),
+ RootDir = proplists:get_value(priv_dir,Config),
+ FileName = atom_to_list(?MODULE)++"_path_eval.fil",
+ Name = filename:join(RootDir, FileName),
+ {ok,Fd1} = ?FILE_MODULE:open(Name,write),
+ io:format(Fd1,"put(evaluated_ok,true).\n",[]),
+ ok = ?FILE_MODULE:close(Fd1),
%% File last in path
- ?line {ok,Dir} =
+ {ok,Dir} =
?FILE_MODULE:path_eval(
- [filename:join(RootDir, "dir1"),
- filename:join(RootDir, ".."),
- filename:join(RootDir, "dir2"),
- RootDir],FileName),
- ?line true = get(evaluated_ok),
- ?line true = lists:prefix(RootDir,Dir),
-
+ [filename:join(RootDir, "dir1"),
+ filename:join(RootDir, ".."),
+ filename:join(RootDir, "dir2"),
+ RootDir],FileName),
+ true = get(evaluated_ok),
+ true = lists:prefix(RootDir,Dir),
+
%% While maybe not an error, it may be worth noting that
%% when the full path to a file is given, it's always found
%% regardless of the contents of the path
- ?line {ok,Fd2} = ?FILE_MODULE:open(Name,write),
- ?line io:format(Fd2,"put(evaluated_ok,R).\n",[]),
- ?line ok = ?FILE_MODULE:close(Fd2),
- ?line {ok,_} = ?FILE_MODULE:path_eval(
- ["nosuch1","nosuch2"],
- Name,
- erl_eval:add_binding('R', true, erl_eval:new_bindings())),
-
- ?line [] = flush(),
- ?line test_server:timetrap_cancel(Dog),
+ {ok,Fd2} = ?FILE_MODULE:open(Name,write),
+ io:format(Fd2,"put(evaluated_ok,R).\n",[]),
+ ok = ?FILE_MODULE:close(Fd2),
+ {ok,_} = ?FILE_MODULE:path_eval(
+ ["nosuch1","nosuch2"],
+ Name,
+ erl_eval:add_binding('R', true, erl_eval:new_bindings())),
+
+ [] = flush(),
ok.
-script1(suite) -> [];
-script1(doc) -> "";
script1(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)++"_script.fil"),
- ?line {ok,Fd1} = ?FILE_MODULE:open(Name,write),
+ RootDir = proplists:get_value(priv_dir,Config),
+ Name = filename:join(RootDir,
+ atom_to_list(?MODULE)++"_script.fil"),
+ {ok,Fd1} = ?FILE_MODULE:open(Name,write),
%% note that there is no final \n (only a space)
- ?line io:format(Fd1,"A = 11,\nB = 6,\nA+B. ",[]),
- ?line ok = ?FILE_MODULE:close(Fd1),
- ?line {ok,17} = ?FILE_MODULE:script(Name),
-
- ?line {ok,Fd2} = ?FILE_MODULE:open(Name,write),
+ io:format(Fd1,"A = 11,\nB = 6,\nA+B. ",[]),
+ ok = ?FILE_MODULE:close(Fd1),
+ {ok,17} = ?FILE_MODULE:script(Name),
+
+ {ok,Fd2} = ?FILE_MODULE:open(Name,write),
%% note that there is no final \n (only a space)
- ?line io:format(Fd2,"A = 11,\nA+B. ",[]),
- ?line ok = ?FILE_MODULE:close(Fd2),
- ?line {ok,17} = ?FILE_MODULE:script(
- Name,
- erl_eval:add_binding('B', 6, erl_eval:new_bindings())),
-
- ?line {ok,Fd3} = ?FILE_MODULE:open(Name,write),
- ?line io:format(Fd3,"A = 11,\nB = six,\nA+B. ",[]),
- ?line ok = ?FILE_MODULE:close(Fd3),
- ?line {error, {_, _, _} = Msg} = ?FILE_MODULE:script(Name),
- ?line io:format("Errmsg1: ~p",[Msg]),
-
- ?line {error, enoent} = ?FILE_MODULE:script(Name ++ ".nonexistent"),
-
- ?line [] = flush(),
- ?line test_server:timetrap_cancel(Dog),
+ io:format(Fd2,"A = 11,\nA+B. ",[]),
+ ok = ?FILE_MODULE:close(Fd2),
+ {ok,17} = ?FILE_MODULE:script(
+ Name,
+ erl_eval:add_binding('B', 6, erl_eval:new_bindings())),
+
+ {ok,Fd3} = ?FILE_MODULE:open(Name,write),
+ io:format(Fd3,"A = 11,\nB = six,\nA+B. ",[]),
+ ok = ?FILE_MODULE:close(Fd3),
+ {error, {_, _, _} = Msg} = ?FILE_MODULE:script(Name),
+ io:format("Errmsg1: ~p",[Msg]),
+
+ {error, enoent} = ?FILE_MODULE:script(Name ++ ".nonexistent"),
+
+ [] = flush(),
ok.
-
-path_script(suite) -> [];
-path_script(doc) -> [];
+
path_script(Config) when is_list(Config) ->
- ?line Dog = test_server:timetrap(test_server:seconds(5)),
- ?line RootDir = ?config(priv_dir,Config),
- ?line FileName = atom_to_list(?MODULE)++"_path_script.fil",
- ?line Name = filename:join(RootDir, FileName),
- ?line {ok,Fd1} = ?FILE_MODULE:open(Name,write),
- ?line io:format(Fd1,"A = 11,\nB = 6,\nA+B.\n",[]),
- ?line ok = ?FILE_MODULE:close(Fd1),
+ RootDir = proplists:get_value(priv_dir,Config),
+ FileName = atom_to_list(?MODULE)++"_path_script.fil",
+ Name = filename:join(RootDir, FileName),
+ {ok,Fd1} = ?FILE_MODULE:open(Name,write),
+ io:format(Fd1,"A = 11,\nB = 6,\nA+B.\n",[]),
+ ok = ?FILE_MODULE:close(Fd1),
%% File last in path
- ?line {ok, 17, Dir} =
+ {ok, 17, Dir} =
?FILE_MODULE:path_script(
[filename:join(RootDir, "dir1"),
filename:join(RootDir, ".."),
filename:join(RootDir, "dir2"),
RootDir],FileName),
- ?line true = lists:prefix(RootDir,Dir),
-
+ true = lists:prefix(RootDir,Dir),
+
%% While maybe not an error, it may be worth noting that
%% when the full path to a file is given, it's always found
%% regardless of the contents of the path
- ?line {ok,Fd2} = ?FILE_MODULE:open(Name,write),
- ?line io:format(Fd2,"A = 11,\nA+B.",[]),
- ?line ok = ?FILE_MODULE:close(Fd2),
- ?line {ok, 17, Dir} =
+ {ok,Fd2} = ?FILE_MODULE:open(Name,write),
+ io:format(Fd2,"A = 11,\nA+B.",[]),
+ ok = ?FILE_MODULE:close(Fd2),
+ {ok, 17, Dir} =
?FILE_MODULE:path_script(
["nosuch1","nosuch2"],
Name,
erl_eval:add_binding('B', 6, erl_eval:new_bindings())),
-
- ?line [] = flush(),
- ?line test_server:timetrap_cancel(Dog),
+
+ [] = flush(),
ok.
-
-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"),
+ RootDir = proplists:get_value(priv_dir,Config),
+ Name = filename:join(RootDir,
+ atom_to_list(?MODULE)
+ ++"_truncate.fil"),
%% Create a file with some data.
- ?line MyData = "0123456789abcdefghijklmnopqrstuvxyz",
- ?line ok = ?FILE_MODULE:write_file(Name, MyData),
+ MyData = "0123456789abcdefghijklmnopqrstuvxyz",
+ ok = ?FILE_MODULE:write_file(Name, MyData),
%% Truncate the file to 10 characters.
- ?line {ok, Fd} = ?FILE_MODULE:open(Name, read_write),
- ?line {ok, 10} = ?FILE_MODULE:position(Fd, 10),
- ?line ok = ?FILE_MODULE:truncate(Fd),
- ?line ok = ?FILE_MODULE:close(Fd),
+ {ok, Fd} = ?FILE_MODULE:open(Name, read_write),
+ {ok, 10} = ?FILE_MODULE:position(Fd, 10),
+ ok = ?FILE_MODULE:truncate(Fd),
+ ok = ?FILE_MODULE:close(Fd),
%% Read back the file and check that it has been truncated.
- ?line Expected = list_to_binary("0123456789"),
- ?line {ok, Expected} = ?FILE_MODULE:read_file(Name),
+ Expected = list_to_binary("0123456789"),
+ {ok, Expected} = ?FILE_MODULE:read_file(Name),
%% Open the file read only and verify that it is not possible to
%% truncate it, OTP-1960
- ?line {ok, Fd2} = ?FILE_MODULE:open(Name, read),
- ?line {ok, 5} = ?FILE_MODULE:position(Fd2, 5),
- ?line {error, _} = ?FILE_MODULE:truncate(Fd2),
+ {ok, Fd2} = ?FILE_MODULE:open(Name, read),
+ {ok, 5} = ?FILE_MODULE:position(Fd2, 5),
+ {error, _} = ?FILE_MODULE:truncate(Fd2),
- ?line [] = flush(),
- ?line test_server:timetrap_cancel(Dog),
+ [] = flush(),
ok.
-datasync(suite) -> [];
-datasync(doc) -> "Tests that ?FILE_MODULE:datasync/1 at least doesn't crash.";
+%% Tests that ?FILE_MODULE:datasync/1 at least doesn't crash.
datasync(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"),
+ PrivDir = proplists:get_value(priv_dir, Config),
+ Sync = filename:join(PrivDir,
+ atom_to_list(?MODULE)
+ ++"_sync.fil"),
%% Raw open.
- ?line {ok, Fd} = ?FILE_MODULE:open(Sync, [write, raw]),
- ?line ok = ?FILE_MODULE:datasync(Fd),
- ?line ok = ?FILE_MODULE:close(Fd),
+ {ok, Fd} = ?FILE_MODULE:open(Sync, [write, raw]),
+ ok = ?FILE_MODULE:datasync(Fd),
+ ok = ?FILE_MODULE:close(Fd),
%% Ordinary open.
- ?line {ok, Fd2} = ?FILE_MODULE:open(Sync, [write]),
- ?line ok = ?FILE_MODULE:datasync(Fd2),
- ?line ok = ?FILE_MODULE:close(Fd2),
+ {ok, Fd2} = ?FILE_MODULE:open(Sync, [write]),
+ ok = ?FILE_MODULE:datasync(Fd2),
+ ok = ?FILE_MODULE:close(Fd2),
- ?line [] = flush(),
- ?line test_server:timetrap_cancel(Dog),
+ [] = flush(),
ok.
-sync(suite) -> [];
-sync(doc) -> "Tests that ?FILE_MODULE:sync/1 at least doesn't crash.";
+%% Tests that ?FILE_MODULE: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"),
+ PrivDir = proplists:get_value(priv_dir, Config),
+ Sync = filename:join(PrivDir,
+ atom_to_list(?MODULE)
+ ++"_sync.fil"),
%% Raw open.
- ?line {ok, Fd} = ?FILE_MODULE:open(Sync, [write, raw]),
- ?line ok = ?FILE_MODULE:sync(Fd),
- ?line ok = ?FILE_MODULE:close(Fd),
+ {ok, Fd} = ?FILE_MODULE:open(Sync, [write, raw]),
+ ok = ?FILE_MODULE:sync(Fd),
+ ok = ?FILE_MODULE:close(Fd),
%% Ordinary open.
- ?line {ok, Fd2} = ?FILE_MODULE:open(Sync, [write]),
- ?line ok = ?FILE_MODULE:sync(Fd2),
- ?line ok = ?FILE_MODULE:close(Fd2),
+ {ok, Fd2} = ?FILE_MODULE:open(Sync, [write]),
+ ok = ?FILE_MODULE:sync(Fd2),
+ ok = ?FILE_MODULE:close(Fd2),
- ?line [] = flush(),
- ?line test_server:timetrap_cancel(Dog),
+ [] = flush(),
ok.
-advise(suite) -> [];
-advise(doc) -> "Tests that ?FILE_MODULE:advise/4 at least doesn't crash.";
+%% Tests that ?FILE_MODULE:advise/4 at least doesn't crash.
advise(Config) when is_list(Config) ->
- ?line Dog = test_server:timetrap(test_server:seconds(5)),
- ?line PrivDir = ?config(priv_dir, Config),
- ?line Advise = filename:join(PrivDir,
- atom_to_list(?MODULE)
- ++"_advise.fil"),
+ PrivDir = proplists:get_value(priv_dir, Config),
+ Advise = filename:join(PrivDir,
+ atom_to_list(?MODULE)
+ ++"_advise.fil"),
Line1 = "Hello\n",
Line2 = "World!\n",
- ?line {ok, Fd} = ?FILE_MODULE:open(Advise, [write]),
- ?line ok = ?FILE_MODULE:advise(Fd, 0, 0, normal),
- ?line ok = io:format(Fd, "~s", [Line1]),
- ?line ok = io:format(Fd, "~s", [Line2]),
- ?line ok = ?FILE_MODULE:close(Fd),
-
- ?line {ok, Fd2} = ?FILE_MODULE:open(Advise, [write]),
- ?line ok = ?FILE_MODULE:advise(Fd2, 0, 0, random),
- ?line ok = io:format(Fd2, "~s", [Line1]),
- ?line ok = io:format(Fd2, "~s", [Line2]),
- ?line ok = ?FILE_MODULE:close(Fd2),
-
- ?line {ok, Fd3} = ?FILE_MODULE:open(Advise, [write]),
- ?line ok = ?FILE_MODULE:advise(Fd3, 0, 0, sequential),
- ?line ok = io:format(Fd3, "~s", [Line1]),
- ?line ok = io:format(Fd3, "~s", [Line2]),
- ?line ok = ?FILE_MODULE:close(Fd3),
-
- ?line {ok, Fd4} = ?FILE_MODULE:open(Advise, [write]),
- ?line ok = ?FILE_MODULE:advise(Fd4, 0, 0, will_need),
- ?line ok = io:format(Fd4, "~s", [Line1]),
- ?line ok = io:format(Fd4, "~s", [Line2]),
- ?line ok = ?FILE_MODULE:close(Fd4),
-
- ?line {ok, Fd5} = ?FILE_MODULE:open(Advise, [write]),
- ?line ok = ?FILE_MODULE:advise(Fd5, 0, 0, dont_need),
- ?line ok = io:format(Fd5, "~s", [Line1]),
- ?line ok = io:format(Fd5, "~s", [Line2]),
- ?line ok = ?FILE_MODULE:close(Fd5),
-
- ?line {ok, Fd6} = ?FILE_MODULE:open(Advise, [write]),
- ?line ok = ?FILE_MODULE:advise(Fd6, 0, 0, no_reuse),
- ?line ok = io:format(Fd6, "~s", [Line1]),
- ?line ok = io:format(Fd6, "~s", [Line2]),
- ?line ok = ?FILE_MODULE:close(Fd6),
-
- ?line {ok, Fd7} = ?FILE_MODULE:open(Advise, [write]),
- ?line {error, einval} = ?FILE_MODULE:advise(Fd7, 0, 0, bad_advise),
- ?line ok = ?FILE_MODULE:close(Fd7),
+ {ok, Fd} = ?FILE_MODULE:open(Advise, [write]),
+ ok = ?FILE_MODULE:advise(Fd, 0, 0, normal),
+ ok = io:format(Fd, "~s", [Line1]),
+ ok = io:format(Fd, "~s", [Line2]),
+ ok = ?FILE_MODULE:close(Fd),
+
+ {ok, Fd2} = ?FILE_MODULE:open(Advise, [write]),
+ ok = ?FILE_MODULE:advise(Fd2, 0, 0, random),
+ ok = io:format(Fd2, "~s", [Line1]),
+ ok = io:format(Fd2, "~s", [Line2]),
+ ok = ?FILE_MODULE:close(Fd2),
+
+ {ok, Fd3} = ?FILE_MODULE:open(Advise, [write]),
+ ok = ?FILE_MODULE:advise(Fd3, 0, 0, sequential),
+ ok = io:format(Fd3, "~s", [Line1]),
+ ok = io:format(Fd3, "~s", [Line2]),
+ ok = ?FILE_MODULE:close(Fd3),
+
+ {ok, Fd4} = ?FILE_MODULE:open(Advise, [write]),
+ ok = ?FILE_MODULE:advise(Fd4, 0, 0, will_need),
+ ok = io:format(Fd4, "~s", [Line1]),
+ ok = io:format(Fd4, "~s", [Line2]),
+ ok = ?FILE_MODULE:close(Fd4),
+
+ {ok, Fd5} = ?FILE_MODULE:open(Advise, [write]),
+ ok = ?FILE_MODULE:advise(Fd5, 0, 0, dont_need),
+ ok = io:format(Fd5, "~s", [Line1]),
+ ok = io:format(Fd5, "~s", [Line2]),
+ ok = ?FILE_MODULE:close(Fd5),
+
+ {ok, Fd6} = ?FILE_MODULE:open(Advise, [write]),
+ ok = ?FILE_MODULE:advise(Fd6, 0, 0, no_reuse),
+ ok = io:format(Fd6, "~s", [Line1]),
+ ok = io:format(Fd6, "~s", [Line2]),
+ ok = ?FILE_MODULE:close(Fd6),
+
+ {ok, Fd7} = ?FILE_MODULE:open(Advise, [write]),
+ {error, einval} = ?FILE_MODULE:advise(Fd7, 0, 0, bad_advise),
+ ok = ?FILE_MODULE:close(Fd7),
%% test write without advise, then a read after an advise
- ?line {ok, Fd8} = ?FILE_MODULE:open(Advise, [write]),
- ?line ok = io:format(Fd8, "~s", [Line1]),
- ?line ok = io:format(Fd8, "~s", [Line2]),
- ?line ok = ?FILE_MODULE:close(Fd8),
- ?line {ok, Fd9} = ?FILE_MODULE:open(Advise, [read]),
+ {ok, Fd8} = ?FILE_MODULE:open(Advise, [write]),
+ ok = io:format(Fd8, "~s", [Line1]),
+ ok = io:format(Fd8, "~s", [Line2]),
+ ok = ?FILE_MODULE:close(Fd8),
+ {ok, Fd9} = ?FILE_MODULE:open(Advise, [read]),
Offset = 0,
%% same as a 0 length in some implementations
Length = length(Line1) + length(Line2),
- ?line ok = ?FILE_MODULE:advise(Fd9, Offset, Length, sequential),
- ?line {ok, Line1} = ?FILE_MODULE:read_line(Fd9),
- ?line {ok, Line2} = ?FILE_MODULE:read_line(Fd9),
- ?line eof = ?FILE_MODULE:read_line(Fd9),
- ?line ok = ?FILE_MODULE:close(Fd9),
-
- ?line [] = flush(),
- ?line test_server:timetrap_cancel(Dog),
+ ok = ?FILE_MODULE:advise(Fd9, Offset, Length, sequential),
+ {ok, Line1} = ?FILE_MODULE:read_line(Fd9),
+ {ok, Line2} = ?FILE_MODULE:read_line(Fd9),
+ eof = ?FILE_MODULE:read_line(Fd9),
+ ok = ?FILE_MODULE:close(Fd9),
+
+ [] = flush(),
ok.
-allocate(suite) -> [];
-allocate(doc) -> "Tests that ?FILE_MODULE:allocate/3 at least doesn't crash.";
+%% Tests that ?FILE_MODULE:allocate/3 at least doesn't crash.
allocate(Config) when is_list(Config) ->
- ?line Dog = test_server:timetrap(test_server:seconds(5)),
- ?line PrivDir = ?config(priv_dir, Config),
- ?line Allocate = filename:join(PrivDir,
- atom_to_list(?MODULE)
- ++"_allocate.fil"),
+ PrivDir = proplists:get_value(priv_dir, Config),
+ Allocate = filename:join(PrivDir,
+ atom_to_list(?MODULE)
+ ++"_allocate.fil"),
Line1 = "Hello\n",
Line2 = "World!\n",
- ?line {ok, Fd} = ?FILE_MODULE:open(Allocate, [write, binary]),
+ {ok, Fd} = ?FILE_MODULE:open(Allocate, [write, binary]),
allocate_and_assert(Fd, 1, iolist_size([Line1, Line2])),
- ?line ok = io:format(Fd, "~s", [Line1]),
- ?line ok = io:format(Fd, "~s", [Line2]),
- ?line ok = ?FILE_MODULE:close(Fd),
+ ok = io:format(Fd, "~s", [Line1]),
+ ok = io:format(Fd, "~s", [Line2]),
+ ok = ?FILE_MODULE:close(Fd),
- ?line {ok, Fd2} = ?FILE_MODULE:open(Allocate, [write, binary]),
+ {ok, Fd2} = ?FILE_MODULE:open(Allocate, [write, binary]),
allocate_and_assert(Fd2, 1, iolist_size(Line1)),
- ?line ok = io:format(Fd2, "~s", [Line1]),
- ?line ok = io:format(Fd2, "~s", [Line2]),
- ?line ok = ?FILE_MODULE:close(Fd2),
+ ok = io:format(Fd2, "~s", [Line1]),
+ ok = io:format(Fd2, "~s", [Line2]),
+ ok = ?FILE_MODULE:close(Fd2),
- ?line {ok, Fd3} = ?FILE_MODULE:open(Allocate, [write, binary]),
+ {ok, Fd3} = ?FILE_MODULE:open(Allocate, [write, binary]),
allocate_and_assert(Fd3, 1, iolist_size(Line1) + 1),
- ?line ok = io:format(Fd3, "~s", [Line1]),
- ?line ok = io:format(Fd3, "~s", [Line2]),
- ?line ok = ?FILE_MODULE:close(Fd3),
+ ok = io:format(Fd3, "~s", [Line1]),
+ ok = io:format(Fd3, "~s", [Line2]),
+ ok = ?FILE_MODULE:close(Fd3),
- ?line {ok, Fd4} = ?FILE_MODULE:open(Allocate, [write, binary]),
+ {ok, Fd4} = ?FILE_MODULE:open(Allocate, [write, binary]),
allocate_and_assert(Fd4, 1, 4 * iolist_size([Line1, Line2])),
- ?line ok = io:format(Fd4, "~s", [Line1]),
- ?line ok = io:format(Fd4, "~s", [Line2]),
- ?line ok = ?FILE_MODULE:close(Fd4),
+ ok = io:format(Fd4, "~s", [Line1]),
+ ok = io:format(Fd4, "~s", [Line2]),
+ ok = ?FILE_MODULE:close(Fd4),
- ?line [] = flush(),
- ?line test_server:timetrap_cancel(Dog),
+ [] = flush(),
ok.
allocate_and_assert(Fd, Offset, Length) ->
- % Just verify that calls to ?PRIM_FILE:allocate/3 don't crash or have
- % any other negative side effect. We can't really asssert against a
- % specific return value, because support for file space pre-allocation
- % depends on the OS, OS version and underlying filesystem.
- %
- % The Linux kernel added support for fallocate() in version 2.6.23,
- % which currently works only for the ext4, ocfs2, xfs and btrfs file
- % systems. posix_fallocate() is available in glibc as of version
- % 2.1.94, but it was buggy until glibc version 2.7.
- %
- % Mac OS X, as of version 10.3, supports the fcntl operation F_PREALLOCATE.
- %
- % Solaris supports posix_fallocate() but only for the UFS file system
- % apparently (not supported for ZFS).
- %
- % FreeBSD 9.0 is the first FreeBSD release supporting posix_fallocate().
- %
- % For Windows there's apparently no way to pre-allocate file space, at
- % least with same semantics as posix_fallocate(), fallocate() and
- % fcntl F_PREALLOCATE.
+ %% Just verify that calls to ?PRIM_FILE:allocate/3 don't crash or have
+ %% any other negative side effect. We can't really asssert against a
+ %% specific return value, because support for file space pre-allocation
+ %% depends on the OS, OS version and underlying filesystem.
+ %%
+ %% The Linux kernel added support for fallocate() in version 2.6.23,
+ %% which currently works only for the ext4, ocfs2, xfs and btrfs file
+ %% systems. posix_fallocate() is available in glibc as of version
+ %% 2.1.94, but it was buggy until glibc version 2.7.
+ %%
+ %% Mac OS X, as of version 10.3, supports the fcntl operation F_PREALLOCATE.
+ %%
+ %% Solaris supports posix_fallocate() but only for the UFS file system
+ %% apparently (not supported for ZFS).
+ %%
+ %% FreeBSD 9.0 is the first FreeBSD release supporting posix_fallocate().
+ %%
+ %% For Windows there's apparently no way to pre-allocate file space, at
+ %% least with same semantics as posix_fallocate(), fallocate() and
+ %% fcntl F_PREALLOCATE.
Result = ?FILE_MODULE:allocate(Fd, Offset, Length),
case os:type() of
{win32, _} ->
- ?line {error, enotsup} = Result;
+ {error, enotsup} = Result;
_ ->
- ?line _ = Result
+ _ = Result
end.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-delete(suite) -> [];
-delete(doc) -> [];
delete(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)
- ++"_delete.fil"),
- ?line {ok, Fd1} = ?FILE_MODULE:open(Name, write),
- ?line io:format(Fd1,"ok.\n",[]),
- ?line ok = ?FILE_MODULE:close(Fd1),
+ RootDir = proplists:get_value(priv_dir,Config),
+ Name = filename:join(RootDir,
+ atom_to_list(?MODULE)
+ ++"_delete.fil"),
+ {ok, Fd1} = ?FILE_MODULE:open(Name, write),
+ io:format(Fd1,"ok.\n",[]),
+ ok = ?FILE_MODULE:close(Fd1),
%% Check that the file is readable
- ?line {ok, Fd2} = ?FILE_MODULE:open(Name, read),
- ?line ok = ?FILE_MODULE:close(Fd2),
- ?line ok = ?FILE_MODULE:delete(Name),
+ {ok, Fd2} = ?FILE_MODULE:open(Name, read),
+ ok = ?FILE_MODULE:close(Fd2),
+ ok = ?FILE_MODULE:delete(Name),
%% Check that the file is not readable anymore
- ?line {error, _} = ?FILE_MODULE:open(Name, read),
+ {error, _} = ?FILE_MODULE:open(Name, read),
%% Try deleting a nonexistent file
- ?line {error, enoent} = ?FILE_MODULE:delete(Name),
- ?line [] = flush(),
- ?line test_server:timetrap_cancel(Dog),
+ {error, enoent} = ?FILE_MODULE:delete(Name),
+ [] = flush(),
ok.
-rename(suite) ->[];
-rename(doc) ->[];
rename(Config) when is_list(Config) ->
- ?line Dog = test_server:timetrap(test_server:seconds(5)),
- ?line RootDir = ?config(priv_dir,Config),
- ?line FileName1 = atom_to_list(?MODULE)++"_rename.fil",
- ?line FileName2 = atom_to_list(?MODULE)++"_rename.ful",
- ?line Name1 = filename:join(RootDir, FileName1),
- ?line Name2 = filename:join(RootDir, FileName2),
- ?line {ok,Fd1} = ?FILE_MODULE:open(Name1,write),
- ?line ok = ?FILE_MODULE:close(Fd1),
+ RootDir = proplists:get_value(priv_dir,Config),
+ FileName1 = atom_to_list(?MODULE)++"_rename.fil",
+ FileName2 = atom_to_list(?MODULE)++"_rename.ful",
+ Name1 = filename:join(RootDir, FileName1),
+ Name2 = filename:join(RootDir, FileName2),
+ {ok,Fd1} = ?FILE_MODULE:open(Name1,write),
+ ok = ?FILE_MODULE:close(Fd1),
%% Rename, and check that id really changed name
- ?line ok = ?FILE_MODULE:rename(Name1,Name2),
- ?line {error, _} = ?FILE_MODULE:open(Name1,read),
- ?line {ok,Fd2} = ?FILE_MODULE:open(Name2,read),
- ?line ok = ?FILE_MODULE:close(Fd2),
+ ok = ?FILE_MODULE:rename(Name1,Name2),
+ {error, _} = ?FILE_MODULE:open(Name1,read),
+ {ok,Fd2} = ?FILE_MODULE:open(Name2,read),
+ ok = ?FILE_MODULE:close(Fd2),
%% Try renaming something to itself
- ?line ok = ?FILE_MODULE:rename(Name2,Name2),
+ ok = ?FILE_MODULE:rename(Name2,Name2),
%% Try renaming something that doesn't exist
- ?line {error, enoent} = ?FILE_MODULE:rename(Name1,Name2),
+ {error, enoent} = ?FILE_MODULE:rename(Name1,Name2),
%% Try renaming to something else than a string
- ?line {error, badarg} = ?FILE_MODULE:rename(Name1,{foo,bar}),
-
+ {error, badarg} = ?FILE_MODULE:rename(Name1,{foo,bar}),
+
%% Move between directories
- ?line DirName1 = filename:join(RootDir,
- atom_to_list(?MODULE)
- ++"_rename_dir"),
- ?line DirName2 = filename:join(RootDir,
- atom_to_list(?MODULE)
- ++"_second_rename_dir"),
- ?line Name1foo = filename:join(DirName1, "foo.fil"),
- ?line Name2foo = filename:join(DirName2, "foo.fil"),
- ?line Name2bar = filename:join(DirName2, "bar.dir"),
- ?line ok = ?FILE_MODULE:make_dir(DirName1),
+ DirName1 = filename:join(RootDir,
+ atom_to_list(?MODULE)
+ ++"_rename_dir"),
+ DirName2 = filename:join(RootDir,
+ atom_to_list(?MODULE)
+ ++"_second_rename_dir"),
+ Name1foo = filename:join(DirName1, "foo.fil"),
+ Name2foo = filename:join(DirName2, "foo.fil"),
+ Name2bar = filename:join(DirName2, "bar.dir"),
+ ok = ?FILE_MODULE:make_dir(DirName1),
%% The name has to include the full file name, path in not enough
- ?line expect({error, eisdir}, {error, eexist},
- ?FILE_MODULE:rename(Name2,DirName1)),
- ?line ok = ?FILE_MODULE:rename(Name2, Name1foo),
+ expect({error, eisdir}, {error, eexist},
+ ?FILE_MODULE:rename(Name2,DirName1)),
+ ok = ?FILE_MODULE:rename(Name2, Name1foo),
%% Now rename the directory
- ?line ok = ?FILE_MODULE:rename(DirName1,DirName2),
+ ok = ?FILE_MODULE:rename(DirName1,DirName2),
%% And check that the file is there now
- ?line {ok,Fd3} = ?FILE_MODULE:open(Name2foo, read),
- ?line ok = ?FILE_MODULE:close(Fd3),
+ {ok,Fd3} = ?FILE_MODULE:open(Name2foo, read),
+ ok = ?FILE_MODULE:close(Fd3),
%% Try some dirty things now: move the directory into itself
- ?line {error, Msg1} = ?FILE_MODULE:rename(DirName2, Name2bar),
- ?line io:format("Errmsg1: ~p",[Msg1]),
+ {error, Msg1} = ?FILE_MODULE:rename(DirName2, Name2bar),
+ io:format("Errmsg1: ~p",[Msg1]),
%% move dir into a file in itself
- ?line {error, Msg2} = ?FILE_MODULE:rename(DirName2, Name2foo),
- ?line io:format("Errmsg2: ~p",[Msg2]),
+ {error, Msg2} = ?FILE_MODULE:rename(DirName2, Name2foo),
+ io:format("Errmsg2: ~p",[Msg2]),
- ?line [] = flush(),
- ?line test_server:timetrap_cancel(Dog),
+ [] = flush(),
ok.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-names(suite) -> [];
-names(doc) -> [];
names(Config) when is_list(Config) ->
- ?line Dog = test_server:timetrap(test_server:seconds(5)),
- ?line RootDir = ?config(priv_dir,Config),
- ?line FileName = "foo1.fil",
- ?line Name1 = filename:join(RootDir, FileName),
- ?line Name2 = [RootDir,"/","foo1",".","fil"],
- ?line Name3 = [RootDir,"/",foo,$1,[[[],[],'.']],"f",il],
- ?line {ok,Fd0} = ?FILE_MODULE:open(Name1,write),
- ?line ok = ?FILE_MODULE:close(Fd0),
+ RootDir = proplists:get_value(priv_dir,Config),
+ FileName = "foo1.fil",
+ Name1 = filename:join(RootDir, FileName),
+ Name2 = [RootDir,"/","foo1",".","fil"],
+ Name3 = [RootDir,"/",foo,$1,[[[],[],'.']],"f",il],
+ {ok,Fd0} = ?FILE_MODULE:open(Name1,write),
+ ok = ?FILE_MODULE:close(Fd0),
%% Try some file names
- ?line {ok,Fd1} = ?FILE_MODULE:open(Name1,read),
- ?line ok = ?FILE_MODULE:close(Fd1),
- ?line {ok,Fd2f} = ?FILE_MODULE:open(lists:flatten(Name2),read),
- ?line ok = ?FILE_MODULE:close(Fd2f),
- ?line {ok,Fd2} = ?FILE_MODULE:open(Name2,read),
- ?line ok = ?FILE_MODULE:close(Fd2),
- ?line {ok,Fd3} = ?FILE_MODULE:open(Name3,read),
- ?line ok = ?FILE_MODULE:close(Fd3),
- case length(Name1) > 255 of
- true ->
- io:format("Path too long for an atom:\n\n~p\n", [Name1]);
- false ->
- Name4 = list_to_atom(Name1),
- {ok,Fd4} = ?FILE_MODULE:open(Name4,read),
- ok = ?FILE_MODULE:close(Fd4)
- end,
+ {ok,Fd1} = ?FILE_MODULE:open(Name1,read),
+ ok = ?FILE_MODULE:close(Fd1),
+ {ok,Fd2f} = ?FILE_MODULE:open(lists:flatten(Name2),read),
+ ok = ?FILE_MODULE:close(Fd2f),
+ {ok,Fd2} = ?FILE_MODULE:open(Name2,read),
+ ok = ?FILE_MODULE:close(Fd2),
+ {ok,Fd3} = ?FILE_MODULE:open(Name3,read),
+ ok = ?FILE_MODULE:close(Fd3),
+ case length(Name1) > 255 of
+ true ->
+ io:format("Path too long for an atom:\n\n~p\n", [Name1]);
+ false ->
+ Name4 = list_to_atom(Name1),
+ {ok,Fd4} = ?FILE_MODULE:open(Name4,read),
+ ok = ?FILE_MODULE:close(Fd4)
+ end,
%% Try some path names
- ?line Path1 = RootDir,
- ?line Path2 = [RootDir],
- ?line Path3 = ['',[],[RootDir,[[]]]],
- ?line {ok,Fd11,_} = ?FILE_MODULE:path_open([Path1],FileName,read),
- ?line ok = ?FILE_MODULE:close(Fd11),
- ?line {ok,Fd12,_} = ?FILE_MODULE:path_open([Path2],FileName,read),
- ?line ok = ?FILE_MODULE:close(Fd12),
- ?line {ok,Fd13,_} = ?FILE_MODULE:path_open([Path3],FileName,read),
- ?line ok = ?FILE_MODULE:close(Fd13),
- case length(Path1) > 255 of
- true->
- io:format("Path too long for an atom:\n\n~p\n", [Path1]);
- false ->
- Path4 = list_to_atom(Path1),
- {ok,Fd14,_} = ?FILE_MODULE:path_open([Path4],FileName,read),
- ok = ?FILE_MODULE:close(Fd14)
- end,
- ?line [] = flush(),
- ?line test_server:timetrap_cancel(Dog),
+ Path1 = RootDir,
+ Path2 = [RootDir],
+ Path3 = ['',[],[RootDir,[[]]]],
+ {ok,Fd11,_} = ?FILE_MODULE:path_open([Path1],FileName,read),
+ ok = ?FILE_MODULE:close(Fd11),
+ {ok,Fd12,_} = ?FILE_MODULE:path_open([Path2],FileName,read),
+ ok = ?FILE_MODULE:close(Fd12),
+ {ok,Fd13,_} = ?FILE_MODULE:path_open([Path3],FileName,read),
+ ok = ?FILE_MODULE:close(Fd13),
+ case length(Path1) > 255 of
+ true->
+ io:format("Path too long for an atom:\n\n~p\n", [Path1]);
+ false ->
+ Path4 = list_to_atom(Path1),
+ {ok,Fd14,_} = ?FILE_MODULE:path_open([Path4],FileName,read),
+ ok = ?FILE_MODULE:close(Fd14)
+ end,
+ [] = flush(),
ok.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-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 = ?FILE_MODULE:make_dir(Base),
+ RootDir = proplists:get_value(priv_dir, Config),
+ Base = filename:join(RootDir,
+ atom_to_list(?MODULE)++"_e_delete"),
+ ok = ?FILE_MODULE:make_dir(Base),
%% Delete a non-existing file.
- ?line {error, enoent} =
+ {error, enoent} =
?FILE_MODULE:delete(filename:join(Base, "non_existing")),
%% Delete a directory.
- ?line {error, eperm} = ?FILE_MODULE:delete(Base),
+ {error, eperm} = ?FILE_MODULE:delete(Base),
%% Use a path-name with a non-directory component.
- ?line Afile = filename:join(Base, "a_file"),
- ?line ok = ?FILE_MODULE:write_file(Afile, "hello\n"),
- ?line {error, E} =
+ Afile = filename:join(Base, "a_file"),
+ ok = ?FILE_MODULE:write_file(Afile, "hello\n"),
+ {error, E} =
expect({error, enotdir}, {error, enoent},
?FILE_MODULE:delete(filename:join(Afile, "another_file"))),
- ?line io:format("Result: ~p~n", [E]),
+ io:format("Result: ~p~n", [E]),
%% No permission.
- ?line case os:type() of
- {win32, _} ->
- %% Remove a character device.
- ?line {error, eacces} = ?FILE_MODULE:delete("nul");
- _ ->
- ?line ?FILE_MODULE:write_file_info(
- Base, #file_info {mode=0}),
- ?line {error, eacces} = ?FILE_MODULE:delete(Afile),
- ?line ?FILE_MODULE:write_file_info(
- Base, #file_info {mode=8#600})
- end,
+ case os:type() of
+ {win32, _} ->
+ %% Remove a character device.
+ {error, eacces} = ?FILE_MODULE:delete("nul");
+ _ ->
+ ?FILE_MODULE:write_file_info(
+ Base, #file_info {mode=0}),
+ {error, eacces} = ?FILE_MODULE:delete(Afile),
+ ?FILE_MODULE:write_file_info(
+ Base, #file_info {mode=8#600})
+ end,
- ?line [] = flush(),
- ?line test_server:timetrap_cancel(Dog),
+ [] = flush(),
ok.
%%% FreeBSD gives EEXIST when renaming a file to an empty dir, although the
@@ -2278,13 +2111,10 @@ e_delete(Config) when is_list(Config) ->
%%% (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) ->
- Dog = test_server:timetrap(test_server:seconds(10)),
- RootDir = ?config(priv_dir, Config),
+ RootDir = proplists:get_value(priv_dir, Config),
Base = filename:join(RootDir,
- atom_to_list(?MODULE)++"_e_rename"),
+ atom_to_list(?MODULE)++"_e_rename"),
ok = ?FILE_MODULE:make_dir(Base),
%% Create an empty directory.
@@ -2295,15 +2125,15 @@ e_rename(Config) when is_list(Config) ->
NonEmptyDir = filename:join(Base, "non_empty_dir"),
ok = ?FILE_MODULE:make_dir(NonEmptyDir),
ok = ?FILE_MODULE:write_file(
- filename:join(NonEmptyDir, "a_file"),
- "hello\n"),
+ filename:join(NonEmptyDir, "a_file"),
+ "hello\n"),
%% Create another non-empty directory.
ADirectory = filename:join(Base, "a_directory"),
ok = ?FILE_MODULE:make_dir(ADirectory),
ok = ?FILE_MODULE:write_file(
- filename:join(ADirectory, "a_file"),
- "howdy\n\n"),
+ filename:join(ADirectory, "a_file"),
+ "howdy\n\n"),
%% Create a data file.
File = filename:join(Base, "just_a_file"),
@@ -2317,15 +2147,15 @@ e_rename(Config) when is_list(Config) ->
%% Move Base into Base/new_name.
{error, einval} =
- ?FILE_MODULE:rename(Base, filename:join(Base, "new_name")),
+ ?FILE_MODULE:rename(Base, filename:join(Base, "new_name")),
%% Overwrite a directory with a file.
expect({error, eexist}, %FreeBSD (?)
- {error, eisdir},
- ?FILE_MODULE:rename(File, EmptyDir)),
+ {error, eisdir},
+ ?FILE_MODULE:rename(File, EmptyDir)),
expect({error, eexist}, %FreeBSD (?)
- {error, eisdir},
- ?FILE_MODULE:rename(File, NonEmptyDir)),
+ {error, eisdir},
+ ?FILE_MODULE:rename(File, NonEmptyDir)),
%% Move a non-existing file.
NonExistingFile = filename:join(Base, "non_existing_file"),
@@ -2333,8 +2163,8 @@ e_rename(Config) when is_list(Config) ->
%% Overwrite a file with a directory.
expect({error, eexist}, %FreeBSD (?)
- {error, enotdir},
- ?FILE_MODULE:rename(ADirectory, File)),
+ {error, enotdir},
+ ?FILE_MODULE:rename(ADirectory, File)),
%% Move a file to another filesystem.
%% XXX - This test case is bogus. We cannot be guaranteed that
@@ -2343,49 +2173,42 @@ e_rename(Config) when is_list(Config) ->
%%
%% XXX - Gross hack!
Comment = case os:type() of
- {unix, _} ->
- OtherFs = "/tmp",
- NameOnOtherFs = filename:join(OtherFs, filename:basename(File)),
- {ok, Com} = case ?FILE_MODULE:rename(File, NameOnOtherFs) of
- {error, exdev} ->
- %% The file could be in
- %% the same filesystem!
- {ok, ok};
- ok ->
- {ok, {comment,
- "Moving between filesystems "
- "suceeded, files are probably "
- "in the same filesystem!"}};
- {error, eperm} ->
- {ok, {comment, "SBS! You don't "
- "have the permission to do "
- "this test!"}};
- Else ->
- Else
- end,
- Com;
- {win32, _} ->
- %% At least Windows NT can
- %% successfully move a file to
- %% another drive.
- ok;
- {ose, _} ->
- %% disabled for now
- ok
- end,
+ {unix, _} ->
+ OtherFs = "/tmp",
+ NameOnOtherFs = filename:join(OtherFs, filename:basename(File)),
+ {ok, Com} = case ?FILE_MODULE:rename(File, NameOnOtherFs) of
+ {error, exdev} ->
+ %% The file could be in
+ %% the same filesystem!
+ {ok, ok};
+ ok ->
+ {ok, {comment,
+ "Moving between filesystems "
+ "suceeded, files are probably "
+ "in the same filesystem!"}};
+ {error, eperm} ->
+ {ok, {comment, "SBS! You don't "
+ "have the permission to do "
+ "this test!"}};
+ Else ->
+ Else
+ end,
+ Com;
+ {win32, _} ->
+ %% At least Windows NT can
+ %% successfully move a file to
+ %% another drive.
+ ok
+ end,
[] = flush(),
- test_server:timetrap_cancel(Dog),
Comment.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-e_make_dir(suite) -> [];
-e_make_dir(doc) -> [];
e_make_dir(Config) when is_list(Config) ->
- Dog = test_server:timetrap(test_server:seconds(10)),
- RootDir = ?config(priv_dir, Config),
+ RootDir = proplists:get_value(priv_dir, Config),
Base = filename:join(RootDir,
- atom_to_list(?MODULE)++"_e_make_dir"),
+ atom_to_list(?MODULE)++"_e_make_dir"),
ok = ?FILE_MODULE:make_dir(Base),
%% A component of the path does not exist.
@@ -2408,18 +2231,14 @@ e_make_dir(Config) when is_list(Config) ->
?FILE_MODULE:write_file_info(Base, #file_info {mode=0}),
{error, eacces} = ?FILE_MODULE:make_dir(filename:join(Base, "xxxx")),
?FILE_MODULE:write_file_info(
- Base, #file_info {mode=8#600})
+ Base, #file_info {mode=8#600})
end,
- test_server:timetrap_cancel(Dog),
ok.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-e_del_dir(suite) -> [];
-e_del_dir(doc) -> [];
e_del_dir(Config) when is_list(Config) ->
- Dog = test_server:timetrap(test_server:seconds(10)),
- RootDir = ?config(priv_dir, Config),
+ RootDir = proplists:get_value(priv_dir, Config),
Base = test_server:temp_name(filename:join(RootDir, "e_del_dir")),
io:format("Base: ~p", [Base]),
ok = ?FILE_MODULE:make_dir(Base),
@@ -2432,21 +2251,21 @@ e_del_dir(Config) when is_list(Config) ->
Afile = filename:join(Base, "a_directory"),
ok = ?FILE_MODULE:write_file(Afile, "hello\n"),
{error, E1} = expect({error, enotdir}, {error, enoent},
- ?FILE_MODULE:del_dir(
- filename:join(Afile, "another_directory"))),
+ ?FILE_MODULE:del_dir(
+ filename:join(Afile, "another_directory"))),
io:format("Result: ~p", [E1]),
%% Delete a non-empty directory.
{error, E2} = expect({error, enotempty}, {error, eexist}, {error, eacces},
- ?FILE_MODULE:del_dir(Base)),
+ ?FILE_MODULE:del_dir(Base)),
io:format("Result: ~p", [E2]),
%% Remove the current directory.
{error, E3} = expect({error, einval},
- {error, eperm}, % Linux and DUX
- {error, eacces},
- {error, ebusy},
- ?FILE_MODULE:del_dir(".")),
+ {error, eperm}, % Linux and DUX
+ {error, eacces},
+ {error, ebusy},
+ ?FILE_MODULE:del_dir(".")),
io:format("Result: ~p", [E3]),
%% No permission.
@@ -2461,7 +2280,6 @@ e_del_dir(Config) when is_list(Config) ->
?FILE_MODULE:write_file_info( Base, #file_info {mode=8#600})
end,
[] = flush(),
- test_server:timetrap_cancel(Dog),
ok.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
@@ -2470,35 +2288,35 @@ e_del_dir(Config) when is_list(Config) ->
%% Trying reading and positioning from a compressed file.
read_compressed_cooked(Config) when is_list(Config) ->
- ?line Data = ?config(data_dir, Config),
- ?line Real = filename:join(Data, "realmen.html.gz"),
- ?line {ok, Fd} = ?FILE_MODULE:open(Real, [read,compressed]),
- ?line try_read_file_list(Fd).
+ Data = proplists:get_value(data_dir, Config),
+ Real = filename:join(Data, "realmen.html.gz"),
+ {ok, Fd} = ?FILE_MODULE:open(Real, [read,compressed]),
+ try_read_file_list(Fd).
read_compressed_cooked_binary(Config) when is_list(Config) ->
- ?line Data = ?config(data_dir, Config),
- ?line Real = filename:join(Data, "realmen.html.gz"),
- ?line {ok, Fd} = ?FILE_MODULE:open(Real, [read,compressed,binary]),
- ?line try_read_file_binary(Fd).
+ Data = proplists:get_value(data_dir, Config),
+ Real = filename:join(Data, "realmen.html.gz"),
+ {ok, Fd} = ?FILE_MODULE:open(Real, [read,compressed,binary]),
+ try_read_file_binary(Fd).
%% Trying reading and positioning from an uncompressed file,
%% but with the compressed flag given.
read_not_really_compressed(Config) when is_list(Config) ->
- ?line Data = ?config(data_dir, Config),
- ?line Priv = ?config(priv_dir, 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.
- ?line Real = filename:join(Data, "realmen.html"),
- ?line RealPriv = filename:join(Priv,
- atom_to_list(?MODULE)++"_realmen.html"),
- ?line {ok, RealDataBin} = ?FILE_MODULE:read_file(Real),
- ?line RealData = remove_crs(binary_to_list(RealDataBin), []),
- ?line ok = ?FILE_MODULE:write_file(RealPriv, RealData),
- ?line {ok, Fd} = ?FILE_MODULE:open(RealPriv, [read, compressed]),
- ?line try_read_file_list(Fd).
+ Real = filename:join(Data, "realmen.html"),
+ RealPriv = filename:join(Priv,
+ atom_to_list(?MODULE)++"_realmen.html"),
+ {ok, RealDataBin} = ?FILE_MODULE:read_file(Real),
+ RealData = remove_crs(binary_to_list(RealDataBin), []),
+ ok = ?FILE_MODULE:write_file(RealPriv, RealData),
+ {ok, Fd} = ?FILE_MODULE:open(RealPriv, [read, compressed]),
+ try_read_file_list(Fd).
remove_crs([$\r|Rest], Result) ->
remove_crs(Rest, Result);
@@ -2508,146 +2326,134 @@ remove_crs([], Result) ->
lists:reverse(Result).
try_read_file_list(Fd) ->
- ?line Dog = test_server:timetrap(test_server:seconds(10)),
-
%% Seek to the current position (nothing should happen).
- ?line {ok, 0} = ?FILE_MODULE:position(Fd, 0),
- ?line {ok, 0} = ?FILE_MODULE:position(Fd, {cur, 0}),
+ {ok, 0} = ?FILE_MODULE:position(Fd, 0),
+ {ok, 0} = ?FILE_MODULE:position(Fd, {cur, 0}),
%% Read a few lines from a compressed file.
- ?line ShouldBe = "<TITLE>Real Programmers Don't Use PASCAL</TITLE>\n",
- ?line ShouldBe = io:get_line(Fd, ''),
+ ShouldBe = "<TITLE>Real Programmers Don't Use PASCAL</TITLE>\n",
+ ShouldBe = io:get_line(Fd, ''),
%% Now seek forward.
- ?line {ok, 381} = ?FILE_MODULE:position(Fd, 381),
- ?line Back = "Back in the good old days -- the \"Golden Era\" " ++
+ {ok, 381} = ?FILE_MODULE:position(Fd, 381),
+ Back = "Back in the good old days -- the \"Golden Era\" " ++
"of computers, it was\n",
- ?line Back = io:get_line(Fd, ''),
+ Back = io:get_line(Fd, ''),
%% Try to search forward relative to the current position.
- ?line {ok, CurPos} = ?FILE_MODULE:position(Fd, {cur, 0}),
- ?line RealPos = 4273,
- ?line {ok, RealPos} = ?FILE_MODULE:position(Fd, {cur, RealPos-CurPos}),
- ?line RealProg = "<LI> Real Programmers aren't afraid to use GOTOs.\n",
- ?line RealProg = io:get_line(Fd, ''),
+ {ok, CurPos} = ?FILE_MODULE:position(Fd, {cur, 0}),
+ RealPos = 4273,
+ {ok, RealPos} = ?FILE_MODULE:position(Fd, {cur, RealPos-CurPos}),
+ RealProg = "<LI> Real Programmers aren't afraid to use GOTOs.\n",
+ RealProg = io:get_line(Fd, ''),
%% Seek backward.
- ?line AfterTitle = length("<TITLE>"),
- ?line {ok, AfterTitle} = ?FILE_MODULE:position(Fd, AfterTitle),
- ?line Title = "Real Programmers Don't Use PASCAL</TITLE>\n",
- ?line Title = io:get_line(Fd, ''),
+ AfterTitle = length("<TITLE>"),
+ {ok, AfterTitle} = ?FILE_MODULE:position(Fd, AfterTitle),
+ Title = "Real Programmers Don't Use PASCAL</TITLE>\n",
+ Title = io:get_line(Fd, ''),
%% Seek past the end of the file.
- ?line {ok, _} = ?FILE_MODULE:position(Fd, 25000),
+ {ok, _} = ?FILE_MODULE:position(Fd, 25000),
%% Done.
- ?line ?FILE_MODULE:close(Fd),
- ?line [] = flush(),
- ?line test_server:timetrap_cancel(Dog),
+ ?FILE_MODULE:close(Fd),
+ [] = flush(),
ok.
try_read_file_binary(Fd) ->
- ?line Dog = test_server:timetrap(test_server:seconds(10)),
-
%% Seek to the current position (nothing should happen).
- ?line {ok, 0} = ?FILE_MODULE:position(Fd, 0),
- ?line {ok, 0} = ?FILE_MODULE:position(Fd, {cur, 0}),
+ {ok, 0} = ?FILE_MODULE:position(Fd, 0),
+ {ok, 0} = ?FILE_MODULE:position(Fd, {cur, 0}),
%% Read a few lines from a compressed file.
- ?line ShouldBe = <<"<TITLE>Real Programmers Don't Use PASCAL</TITLE>\n">>,
- ?line ShouldBe = io:get_line(Fd, ''),
+ ShouldBe = <<"<TITLE>Real Programmers Don't Use PASCAL</TITLE>\n">>,
+ ShouldBe = io:get_line(Fd, ''),
%% Now seek forward.
- ?line {ok, 381} = ?FILE_MODULE:position(Fd, 381),
- ?line Back = <<"Back in the good old days -- the \"Golden Era\" "
- "of computers, it was\n">>,
- ?line Back = io:get_line(Fd, ''),
+ {ok, 381} = ?FILE_MODULE:position(Fd, 381),
+ Back = <<"Back in the good old days -- the \"Golden Era\" "
+ "of computers, it was\n">>,
+ Back = io:get_line(Fd, ''),
%% Try to search forward relative to the current position.
- ?line {ok, CurPos} = ?FILE_MODULE:position(Fd, {cur, 0}),
- ?line RealPos = 4273,
- ?line {ok, RealPos} = ?FILE_MODULE:position(Fd, {cur, RealPos-CurPos}),
- ?line RealProg = <<"<LI> Real Programmers aren't afraid to use GOTOs.\n">>,
- ?line RealProg = io:get_line(Fd, ''),
+ {ok, CurPos} = ?FILE_MODULE:position(Fd, {cur, 0}),
+ RealPos = 4273,
+ {ok, RealPos} = ?FILE_MODULE:position(Fd, {cur, RealPos-CurPos}),
+ RealProg = <<"<LI> Real Programmers aren't afraid to use GOTOs.\n">>,
+ RealProg = io:get_line(Fd, ''),
%% Seek backward.
- ?line AfterTitle = length("<TITLE>"),
- ?line {ok, AfterTitle} = ?FILE_MODULE:position(Fd, AfterTitle),
- ?line Title = <<"Real Programmers Don't Use PASCAL</TITLE>\n">>,
- ?line Title = io:get_line(Fd, ''),
+ AfterTitle = length("<TITLE>"),
+ {ok, AfterTitle} = ?FILE_MODULE:position(Fd, AfterTitle),
+ Title = <<"Real Programmers Don't Use PASCAL</TITLE>\n">>,
+ Title = io:get_line(Fd, ''),
%% Done.
- ?line ?FILE_MODULE:close(Fd),
- ?line [] = flush(),
- ?line test_server:timetrap_cancel(Dog),
+ ?FILE_MODULE:close(Fd),
+ [] = flush(),
ok.
read_cooked_tar_problem(Config) when is_list(Config) ->
- ?line Dog = test_server:timetrap(test_server:seconds(10)),
+ Data = proplists:get_value(data_dir, Config),
+ ProblemFile = filename:join(Data, "cooked_tar_problem.tar.gz"),
+ {ok,Fd} = ?FILE_MODULE:open(ProblemFile, [read,compressed,binary]),
- ?line Data = ?config(data_dir, Config),
- ?line ProblemFile = filename:join(Data, "cooked_tar_problem.tar.gz"),
- ?line {ok,Fd} = ?FILE_MODULE:open(ProblemFile, [read,compressed,binary]),
+ {ok,34304} = file:position(Fd, 34304),
+ {ok,Bin} = file:read(Fd, 512),
+ 512 = byte_size(Bin),
- ?line {ok,34304} = file:position(Fd, 34304),
- ?line {ok,Bin} = file:read(Fd, 512),
- ?line 512 = byte_size(Bin),
-
- ?line {ok,34304+512+1024} = file:position(Fd, {cur,1024}),
-
- ?line ok = file:close(Fd),
+ {ok,34304+512+1024} = file:position(Fd, {cur,1024}),
+
+ ok = 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"),
+ Priv = proplists:get_value(priv_dir, Config),
+ MyFile = filename:join(Priv,
+ atom_to_list(?MODULE)++"_test.gz"),
%% Write a file.
- ?line {ok, Fd} = ?FILE_MODULE:open(MyFile, [write, compressed]),
- ?line {ok, 0} = ?FILE_MODULE:position(Fd, 0),
- ?line Prefix = "hello\n",
- ?line End = "end\n",
- ?line ok = io:put_chars(Fd, Prefix),
- ?line {ok, 143} = ?FILE_MODULE:position(Fd, 143),
- ?line ok = io:put_chars(Fd, End),
- ?line ok = ?FILE_MODULE:close(Fd),
+ {ok, Fd} = ?FILE_MODULE:open(MyFile, [write, compressed]),
+ {ok, 0} = ?FILE_MODULE:position(Fd, 0),
+ Prefix = "hello\n",
+ End = "end\n",
+ ok = io:put_chars(Fd, Prefix),
+ {ok, 143} = ?FILE_MODULE:position(Fd, 143),
+ ok = io:put_chars(Fd, End),
+ ok = ?FILE_MODULE:close(Fd),
%% Read the file and verify the contents.
- ?line {ok, Fd1} = ?FILE_MODULE:open(MyFile, [read, compressed]),
- ?line Prefix = io:get_line(Fd1, ''),
- ?line Second = lists:duplicate(143-length(Prefix), 0) ++ End,
- ?line Second = io:get_line(Fd1, ''),
- ?line ok = ?FILE_MODULE:close(Fd1),
+ {ok, Fd1} = ?FILE_MODULE:open(MyFile, [read, compressed]),
+ Prefix = io:get_line(Fd1, ''),
+ Second = lists:duplicate(143-length(Prefix), 0) ++ End,
+ Second = io:get_line(Fd1, ''),
+ ok = ?FILE_MODULE:close(Fd1),
%% Verify successful compression by uncompressing the file
%% using zlib:gunzip/1.
- ?line {ok,Contents} = file:read_file(MyFile),
- ?line <<"hello\n",0:137/unit:8,"end\n">> = zlib:gunzip(Contents),
+ {ok,Contents} = file:read_file(MyFile),
+ <<"hello\n",0:137/unit:8,"end\n">> = zlib:gunzip(Contents),
%% Ensure that the file is compressed.
@@ -2656,99 +2462,92 @@ write_compressed(Config) when is_list(Config) ->
{ok, #file_info{size=Size}} when Size < TotalSize ->
ok;
{ok, #file_info{size=Size}} when Size == TotalSize ->
- test_server:fail(file_not_compressed)
+ ct:fail(file_not_compressed)
end,
%% Write again to ensure that the file is truncated.
- ?line {ok, Fd2} = ?FILE_MODULE:open(MyFile, [write, compressed]),
- ?line NewString = "aaaaaaaaaaa",
- ?line ok = io:put_chars(Fd2, NewString),
- ?line ok = ?FILE_MODULE:close(Fd2),
- ?line {ok, Fd3} = ?FILE_MODULE:open(MyFile, [read, compressed]),
- ?line {ok, NewString} = ?FILE_MODULE:read(Fd3, 1024),
- ?line ok = ?FILE_MODULE:close(Fd3),
+ {ok, Fd2} = ?FILE_MODULE:open(MyFile, [write, compressed]),
+ NewString = "aaaaaaaaaaa",
+ ok = io:put_chars(Fd2, NewString),
+ ok = ?FILE_MODULE:close(Fd2),
+ {ok, Fd3} = ?FILE_MODULE:open(MyFile, [read, compressed]),
+ {ok, NewString} = ?FILE_MODULE:read(Fd3, 1024),
+ ok = ?FILE_MODULE:close(Fd3),
%% Done.
- ?line [] = flush(),
- ?line test_server:timetrap_cancel(Dog),
+ [] = flush(),
ok.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
catenated_gzips(Config) when is_list(Config) ->
- ?line Priv = ?config(priv_dir, Config),
- ?line MyFile = filename:join(Priv, ?MODULE_STRING++"_test.gz"),
+ Priv = proplists:get_value(priv_dir, Config),
+ MyFile = filename:join(Priv, ?MODULE_STRING++"_test.gz"),
First = "Hello, all good men going to search parties. ",
Second = "Now I really need your help.",
All = iolist_to_binary([First|Second]),
- ?line Cat = [zlib:gzip(First),zlib:gzip(Second)],
-
- ?line ok = file:write_file(MyFile, Cat),
+ Cat = [zlib:gzip(First),zlib:gzip(Second)],
+
+ ok = file:write_file(MyFile, Cat),
- ?line {ok,Fd} = file:open(MyFile, [read,compressed,binary]),
- ?line {ok,All} = file:read(Fd, 100000),
- ?line ok = file:close(Fd),
+ {ok,Fd} = file:open(MyFile, [read,compressed,binary]),
+ {ok,All} = file:read(Fd, 100000),
+ ok = file:close(Fd),
ok.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-compress_errors(suite) -> [];
-compress_errors(doc) -> [];
compress_errors(Config) when is_list(Config) ->
- ?line Dog = test_server:timetrap(test_server:seconds(10)),
- ?line DataDir =
+ DataDir =
filename:dirname(
- filename:join(?config(data_dir, Config), "x")),
- ?line DataDirSlash = DataDir++"/",
- ?line {error, enoent} = ?FILE_MODULE:open("non_existing__",
- [compressed, read]),
- ?line {error, einval} = ?FILE_MODULE:open("non_existing__",
- [compressed, read, write]),
- ?line {error, einval} = ?FILE_MODULE:open("non_existing__",
- [compressed, read, append]),
- ?line {error, einval} = ?FILE_MODULE:open("non_existing__",
- [compressed, write, append]),
- ?line {error, E1} = ?FILE_MODULE:open(DataDir, [compressed, read]),
- ?line {error, E2} = ?FILE_MODULE:open(DataDirSlash, [compressed, read]),
- ?line {error, E3} = ?FILE_MODULE:open(DataDir, [compressed, write]),
- ?line {error, E4} = ?FILE_MODULE:open(DataDirSlash, [compressed, write]),
- ?line {eisdir,eisdir,eisdir,eisdir} = {E1,E2,E3,E4},
+ filename:join(proplists:get_value(data_dir, Config), "x")),
+ DataDirSlash = DataDir++"/",
+ {error, enoent} = ?FILE_MODULE:open("non_existing__",
+ [compressed, read]),
+ {error, einval} = ?FILE_MODULE:open("non_existing__",
+ [compressed, read, write]),
+ {error, einval} = ?FILE_MODULE:open("non_existing__",
+ [compressed, read, append]),
+ {error, einval} = ?FILE_MODULE:open("non_existing__",
+ [compressed, write, append]),
+ {error, E1} = ?FILE_MODULE:open(DataDir, [compressed, read]),
+ {error, E2} = ?FILE_MODULE:open(DataDirSlash, [compressed, read]),
+ {error, E3} = ?FILE_MODULE:open(DataDir, [compressed, write]),
+ {error, E4} = ?FILE_MODULE:open(DataDirSlash, [compressed, write]),
+ {eisdir,eisdir,eisdir,eisdir} = {E1,E2,E3,E4},
%% Read a corrupted .gz file.
- ?line Corrupted = filename:join(DataDir, "corrupted.gz"),
- ?line {ok, Fd} = ?FILE_MODULE:open(Corrupted, [read, compressed]),
- ?line {error, eio} = ?FILE_MODULE:read(Fd, 100),
- ?line ?FILE_MODULE:close(Fd),
+ Corrupted = filename:join(DataDir, "corrupted.gz"),
+ {ok, Fd} = ?FILE_MODULE:open(Corrupted, [read, compressed]),
+ {error, eio} = ?FILE_MODULE:read(Fd, 100),
+ ?FILE_MODULE:close(Fd),
- ?line [] = flush(),
- ?line test_server:timetrap_cancel(Dog),
+ [] = flush(),
ok.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-compress_async_crash(suite) -> [];
-compress_async_crash(doc) -> [];
compress_async_crash(Config) when is_list(Config) ->
- ?line DataDir = ?config(data_dir, Config),
- ?line Path = filename:join(DataDir, "test.gz"),
+ DataDir = proplists:get_value(data_dir, Config),
+ Path = filename:join(DataDir, "test.gz"),
ExpectedData = <<"qwerty">>,
- ?line _ = ?FILE_MODULE:delete(Path),
- ?line {ok, Fd} = ?FILE_MODULE:open(Path, [write, binary, compressed]),
- ?line ok = ?FILE_MODULE:write(Fd, ExpectedData),
- ?line ok = ?FILE_MODULE:close(Fd),
+ _ = ?FILE_MODULE:delete(Path),
+ {ok, Fd} = ?FILE_MODULE:open(Path, [write, binary, compressed]),
+ ok = ?FILE_MODULE:write(Fd, ExpectedData),
+ ok = ?FILE_MODULE:close(Fd),
- % Test that when using async thread pool, the emulator doesn't crash
- % when the efile port driver is stopped while a compressed file operation
- % is in progress (being carried by an async thread).
- ?line ok = compress_async_crash_loop(10000, Path, ExpectedData),
- ?line ok = ?FILE_MODULE:delete(Path),
+ %% Test that when using async thread pool, the emulator doesn't crash
+ %% when the efile port driver is stopped while a compressed file operation
+ %% is in progress (being carried by an async thread).
+ ok = compress_async_crash_loop(10000, Path, ExpectedData),
+ ok = ?FILE_MODULE:delete(Path),
ok.
compress_async_crash_loop(0, _Path, _ExpectedData) ->
@@ -2756,35 +2555,35 @@ compress_async_crash_loop(0, _Path, _ExpectedData) ->
compress_async_crash_loop(N, Path, ExpectedData) ->
Parent = self(),
{Pid, Ref} = spawn_monitor(
- fun() ->
- ?line {ok, Fd} = ?FILE_MODULE:open(
- Path, [read, compressed, raw, binary]),
- Len = byte_size(ExpectedData),
- Parent ! {self(), continue},
- ?line {ok, ExpectedData} = ?FILE_MODULE:read(Fd, Len),
- ?line ok = ?FILE_MODULE:close(Fd),
- receive foobar -> ok end
- end),
+ fun() ->
+ {ok, Fd} = ?FILE_MODULE:open(
+ Path, [read, compressed, raw, binary]),
+ Len = byte_size(ExpectedData),
+ Parent ! {self(), continue},
+ {ok, ExpectedData} = ?FILE_MODULE:read(Fd, Len),
+ ok = ?FILE_MODULE:close(Fd),
+ receive foobar -> ok end
+ end),
receive
{Pid, continue} ->
exit(Pid, shutdown),
receive
{'DOWN', Ref, _, _, Reason} ->
- ?line shutdown = Reason
+ shutdown = Reason
end;
{'DOWN', Ref, _, _, Reason2} ->
- test_server:fail({worker_exited, Reason2})
+ ct:fail({worker_exited, Reason2})
after 60000 ->
exit(Pid, shutdown),
erlang:demonitor(Ref, [flush]),
- test_server:fail(worker_timeout)
+ ct:fail(worker_timeout)
end,
compress_async_crash_loop(N - 1, Path, ExpectedData).
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
unicode(Config) when is_list(Config) ->
- Dir = ?config(priv_dir, Config),
+ Dir = proplists:get_value(priv_dir, Config),
Name = filename:join(Dir, "data-utf8.txt"),
Txt = lists:seq(128, 255),
D = unicode:characters_to_binary(Txt, latin1, latin1),
@@ -2817,53 +2616,46 @@ unicode(Config) when is_list(Config) ->
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-altname(doc) ->
- "Test the file:altname/1 function";
-altname(suite) ->
- [];
+%% Test the file:altname/1 function.
altname(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,
- "long alternative path name with spaces"),
- ?line ok = ?FILE_MODULE:make_dir(NewDir),
- ?line Name = filename:join(NewDir, "a_file_with_long_name"),
- ?line ShortName = filename:join(NewDir, "short"),
- ?line NonexName = filename:join(NewDir, "nonexistent"),
- ?line ok = ?FILE_MODULE:write_file(Name, "some contents\n"),
- ?line ok = ?FILE_MODULE:write_file(ShortName, "some contents\n"),
- ?line Result =
+ RootDir = proplists:get_value(priv_dir, Config),
+ NewDir = filename:join(RootDir,
+ "long alternative path name with spaces"),
+ ok = ?FILE_MODULE:make_dir(NewDir),
+ Name = filename:join(NewDir, "a_file_with_long_name"),
+ ShortName = filename:join(NewDir, "short"),
+ NonexName = filename:join(NewDir, "nonexistent"),
+ ok = ?FILE_MODULE:write_file(Name, "some contents\n"),
+ ok = ?FILE_MODULE:write_file(ShortName, "some contents\n"),
+ Result =
case ?FILE_MODULE:altname(NewDir) of
{error, enotsup} ->
{skipped, "Altname not supported on this platform"};
{ok, "LONGAL~1"} ->
- ?line {ok, "A_FILE~1"} = ?FILE_MODULE:altname(Name),
- ?line {ok, "C:/"} = ?FILE_MODULE:altname("C:/"),
- ?line {ok, "C:\\"} = ?FILE_MODULE:altname("C:\\"),
- ?line {error,enoent} = ?FILE_MODULE:altname(NonexName),
- ?line {ok, "short"} = ?FILE_MODULE:altname(ShortName),
+ {ok, "A_FILE~1"} = ?FILE_MODULE:altname(Name),
+ {ok, "C:/"} = ?FILE_MODULE:altname("C:/"),
+ {ok, "C:\\"} = ?FILE_MODULE:altname("C:\\"),
+ {error,enoent} = ?FILE_MODULE:altname(NonexName),
+ {ok, "short"} = ?FILE_MODULE:altname(ShortName),
ok
end,
- ?line [] = flush(),
- ?line test_server:timetrap_cancel(Dog),
+ [] = flush(),
Result.
-make_link(doc) -> "Test creating a hard link.";
-make_link(suite) -> [];
+%% Test creating a hard link.
make_link(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)
- ++"_make_link"),
- ?line ok = ?FILE_MODULE:make_dir(NewDir),
-
- ?line Name = filename:join(NewDir, "a_file"),
- ?line ok = ?FILE_MODULE:write_file(Name, "some contents\n"),
-
- ?line Alias = filename:join(NewDir, "an_alias"),
- ?line Result =
+ RootDir = proplists:get_value(priv_dir, Config),
+ NewDir = filename:join(RootDir,
+ atom_to_list(?MODULE)
+ ++"_make_link"),
+ ok = ?FILE_MODULE:make_dir(NewDir),
+
+ Name = filename:join(NewDir, "a_file"),
+ ok = ?FILE_MODULE:write_file(Name, "some contents\n"),
+
+ Alias = filename:join(NewDir, "an_alias"),
+ Result =
case ?FILE_MODULE:make_link(Name, Alias) of
{error, enotsup} ->
{skipped, "Links not supported on this platform"};
@@ -2873,53 +2665,45 @@ make_link(Config) when is_list(Config) ->
%% which should in behave exactly as
%% ?FILE_MODULE:read_file_info/1
%% since they are not used on symbolic links.
-
- ?line {ok, Info} = ?FILE_MODULE:read_link_info(Name),
+
+ {ok, Info} = ?FILE_MODULE:read_link_info(Name),
{ok,Info} = ?FILE_MODULE:read_link_info(Name, [raw]),
- ?line {ok, Info} = ?FILE_MODULE:read_link_info(Alias),
+ {ok, Info} = ?FILE_MODULE:read_link_info(Alias),
{ok,Info} = ?FILE_MODULE:read_link_info(Alias, [raw]),
- ?line #file_info{links = 2, type = regular} = Info,
- ?line {error, eexist} =
+ #file_info{links = 2, type = regular} = Info,
+ {error, eexist} =
?FILE_MODULE:make_link(Name, Alias),
ok
end,
-
- ?line [] = flush(),
- ?line test_server:timetrap_cancel(Dog),
+
+ [] = flush(),
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) -> [];
+%% Test that reading link info for an ordinary file or directory works
+%% (on all platforms).
read_link_info_for_non_link(Config) when is_list(Config) ->
- ?line Dog = test_server:timetrap(test_server:seconds(10)),
-
- ?line {ok, #file_info{type=directory}} =
+ {ok, #file_info{type=directory}} =
?FILE_MODULE:read_link_info("."),
{ok, #file_info{type=directory}} = ?FILE_MODULE:read_link_info(".", [raw]),
-
- ?line [] = flush(),
- ?line test_server:timetrap_cancel(Dog),
+
+ [] = flush(),
ok.
-symlinks(doc) -> "Test operations on symbolic links (for Unix).";
-symlinks(suite) -> [];
+%% Test operations on symbolic links (for Unix).
symlinks(Config) when is_list(Config) ->
- ?line Dog = test_server:timetrap(test_server:seconds(10)),
- ?line {error, _} = ?FILE_MODULE:read_link(lists:duplicate(10000,$a)),
+ {error, _} = ?FILE_MODULE:read_link(lists:duplicate(10000,$a)),
{error, _} = ?FILE_MODULE:read_link_all(lists:duplicate(10000,$a)),
- ?line RootDir = ?config(priv_dir, Config),
- ?line NewDir = filename:join(RootDir,
- atom_to_list(?MODULE)
- ++"_symlinks"),
- ?line ok = ?FILE_MODULE:make_dir(NewDir),
-
- ?line Name = filename:join(NewDir, "a_plain_file"),
- ?line ok = ?FILE_MODULE:write_file(Name, "some stupid content\n"),
-
- ?line Alias = filename:join(NewDir, "a_symlink_alias"),
- ?line Result =
+ RootDir = proplists:get_value(priv_dir, Config),
+ NewDir = filename:join(RootDir,
+ atom_to_list(?MODULE)
+ ++"_symlinks"),
+ ok = ?FILE_MODULE:make_dir(NewDir),
+
+ Name = filename:join(NewDir, "a_plain_file"),
+ ok = ?FILE_MODULE:write_file(Name, "some stupid content\n"),
+
+ Alias = filename:join(NewDir, "a_symlink_alias"),
+ Result =
case ?FILE_MODULE:make_symlink(Name, Alias) of
{error, enotsup} ->
{skipped, "Links not supported on this platform"};
@@ -2927,41 +2711,37 @@ symlinks(Config) when is_list(Config) ->
{win32,_} = os:type(),
{skipped, "Windows user not privileged to create symlinks"};
ok ->
- ?line {ok, Info1} = ?FILE_MODULE:read_file_info(Name),
+ {ok, Info1} = ?FILE_MODULE:read_file_info(Name),
{ok,Info1} = ?FILE_MODULE:read_file_info(Name, [raw]),
- ?line {ok, Info1} = ?FILE_MODULE:read_file_info(Alias),
+ {ok, Info1} = ?FILE_MODULE:read_file_info(Alias),
{ok,Info1} = ?FILE_MODULE:read_file_info(Alias, [raw]),
- ?line {ok, Info1} = ?FILE_MODULE:read_link_info(Name),
+ {ok, Info1} = ?FILE_MODULE:read_link_info(Name),
{ok,Info1} = ?FILE_MODULE:read_link_info(Name, [raw]),
- ?line #file_info{links = 1, type = regular} = Info1,
-
- ?line {ok, Info2} = ?FILE_MODULE:read_link_info(Alias),
+ #file_info{links = 1, type = regular} = Info1,
+
+ {ok, Info2} = ?FILE_MODULE:read_link_info(Alias),
{ok,Info2} = ?FILE_MODULE:read_link_info(Alias, [raw]),
- ?line #file_info{links=1, type=symlink} = Info2,
- ?line {ok, Name} = ?FILE_MODULE:read_link(Alias),
+ #file_info{links=1, type=symlink} = Info2,
+ {ok, Name} = ?FILE_MODULE:read_link(Alias),
{ok, Name} = ?FILE_MODULE:read_link_all(Alias),
%% If all is good, delete dir again (avoid hanging dir on windows)
rm_rf(?FILE_MODULE,NewDir),
ok
- end,
-
- ?line [] = flush(),
- ?line test_server:timetrap_cancel(Dog),
+ end,
+
+ [] = flush(),
Result.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-copy(doc) -> [];
-copy(suite) -> [];
copy(Config) when is_list(Config) ->
- ?line Dog = test_server:timetrap(test_server:seconds(10)),
- ?line RootDir = ?config(priv_dir, Config),
+ RootDir = proplists:get_value(priv_dir, Config),
%% Create a text file.
- ?line Name1 = filename:join(RootDir, atom_to_list(?MODULE)++"_copy_1.txt"),
- ?line Line = "The quick brown fox jumps over a lazy dog. 0123456789\n",
- ?line Len = length(Line),
- ?line {ok, Handle1} = ?FILE_MODULE:open(Name1, [write]),
- ?line {_, Size1} =
+ Name1 = filename:join(RootDir, atom_to_list(?MODULE)++"_copy_1.txt"),
+ Line = "The quick brown fox jumps over a lazy dog. 0123456789\n",
+ Len = length(Line),
+ {ok, Handle1} = ?FILE_MODULE:open(Name1, [write]),
+ {_, Size1} =
iterate({0, 0},
done,
fun({_, S}) when S >= 128*1024 ->
@@ -2971,45 +2751,44 @@ copy(Config) when is_list(Config) ->
ok = ?FILE_MODULE:write(Handle1, [H, " ", Line]),
{N + 1, S + length(H) + 1 + Len}
end),
- ?line ?FILE_MODULE:close(Handle1),
+ ?FILE_MODULE:close(Handle1),
%% Make a copy
- ?line Name2 = filename:join(RootDir, atom_to_list(?MODULE)++"_copy_2.txt"),
- ?line {ok, Size1} = ?FILE_MODULE:copy(Name1, Name2),
+ Name2 = filename:join(RootDir, atom_to_list(?MODULE)++"_copy_2.txt"),
+ {ok, Size1} = ?FILE_MODULE:copy(Name1, Name2),
%% Concatenate 1
- ?line Name3 = filename:join(RootDir, atom_to_list(?MODULE)++"_copy_3.txt"),
- ?line {ok, Handle3} = ?FILE_MODULE:open(Name3, [raw, write, binary]),
- ?line {ok, Size1} = ?FILE_MODULE:copy(Name1, Handle3),
- ?line {ok, Handle2} = ?FILE_MODULE:open(Name2, [read, binary]),
- ?line {ok, Size1} = ?FILE_MODULE:copy(Handle2, Handle3),
- ?line ok = ?FILE_MODULE:close(Handle3),
- ?line ok = ?FILE_MODULE:close(Handle2),
+ Name3 = filename:join(RootDir, atom_to_list(?MODULE)++"_copy_3.txt"),
+ {ok, Handle3} = ?FILE_MODULE:open(Name3, [raw, write, binary]),
+ {ok, Size1} = ?FILE_MODULE:copy(Name1, Handle3),
+ {ok, Handle2} = ?FILE_MODULE:open(Name2, [read, binary]),
+ {ok, Size1} = ?FILE_MODULE:copy(Handle2, Handle3),
+ ok = ?FILE_MODULE:close(Handle3),
+ ok = ?FILE_MODULE:close(Handle2),
%% Concatenate 2
- ?line Name4 = filename:join(RootDir, atom_to_list(?MODULE)++"_copy_4.txt"),
- ?line {ok, Handle4} = ?FILE_MODULE:open(Name4, [write, binary]),
- ?line {ok, Size1} = ?FILE_MODULE:copy(Name1, Handle4),
- ?line {ok, Handle5} = ?FILE_MODULE:open(Name2, [raw, read, binary]),
- ?line {ok, Size1} = ?FILE_MODULE:copy(Handle5, Handle4),
- ?line ok = ?FILE_MODULE:close(Handle5),
- ?line ok = ?FILE_MODULE:close(Handle4),
+ Name4 = filename:join(RootDir, atom_to_list(?MODULE)++"_copy_4.txt"),
+ {ok, Handle4} = ?FILE_MODULE:open(Name4, [write, binary]),
+ {ok, Size1} = ?FILE_MODULE:copy(Name1, Handle4),
+ {ok, Handle5} = ?FILE_MODULE:open(Name2, [raw, read, binary]),
+ {ok, Size1} = ?FILE_MODULE:copy(Handle5, Handle4),
+ ok = ?FILE_MODULE:close(Handle5),
+ ok = ?FILE_MODULE:close(Handle4),
%% %% Just for test of the test
- %% ?line {ok, Handle2q} = ?FILE_MODULE:open(Name2, [write, append]),
- %% ?line ok = ?FILE_MODULE:write(Handle2q, "q"),
- %% ?line ok = ?FILE_MODULE:close(Handle2q),
+ %% {ok, Handle2q} = ?FILE_MODULE:open(Name2, [write, append]),
+ %% ok = ?FILE_MODULE:write(Handle2q, "q"),
+ %% ok = ?FILE_MODULE:close(Handle2q),
%% Compare the files
- ?line {ok, Handle1a} = ?FILE_MODULE:open(Name1, [raw, read]),
- ?line {ok, Handle2a} = ?FILE_MODULE:open(Name2, [raw, read]),
- ?line true = stream_cmp(fd_stream_factory([Handle1a]),
- fd_stream_factory([Handle2a])),
- ?line {ok, 0} = ?FILE_MODULE:position(Handle1a, 0),
- ?line {ok, 0} = ?FILE_MODULE:position(Handle2a, 0),
- ?line {ok, Handle3a} = ?FILE_MODULE:open(Name3, [raw, read]),
- ?line true = stream_cmp(fd_stream_factory([Handle1a, Handle2a]),
- fd_stream_factory([Handle2a])),
- ?line ok = ?FILE_MODULE:close(Handle1a),
- ?line ok = ?FILE_MODULE:close(Handle2a),
- ?line ok = ?FILE_MODULE:close(Handle3a),
- ?line [] = flush(),
- ?line test_server:timetrap_cancel(Dog),
+ {ok, Handle1a} = ?FILE_MODULE:open(Name1, [raw, read]),
+ {ok, Handle2a} = ?FILE_MODULE:open(Name2, [raw, read]),
+ true = stream_cmp(fd_stream_factory([Handle1a]),
+ fd_stream_factory([Handle2a])),
+ {ok, 0} = ?FILE_MODULE:position(Handle1a, 0),
+ {ok, 0} = ?FILE_MODULE:position(Handle2a, 0),
+ {ok, Handle3a} = ?FILE_MODULE:open(Name3, [raw, read]),
+ true = stream_cmp(fd_stream_factory([Handle1a, Handle2a]),
+ fd_stream_factory([Handle2a])),
+ ok = ?FILE_MODULE:close(Handle1a),
+ ok = ?FILE_MODULE:close(Handle2a),
+ ok = ?FILE_MODULE:close(Handle3a),
+ [] = flush(),
ok.
@@ -3030,7 +2809,7 @@ fd_stream_factory([Fd | T] = L) ->
end
end.
-
+
stream_cmp(F1, F2) when is_function(F1), is_function(F2) ->
stream_cmp(F1(), F2());
@@ -3055,80 +2834,75 @@ stream_cmp([H | T1], [H | T2]) ->
%% Test the get_cwd(), open(), and copy() file server calls.
new_slave(_RootDir, Cwd) ->
- ?line L = "qwertyuiopasdfghjklzxcvbnm",
- ?line N = length(L),
- ?line {ok, Cwd} = ?FILE_MODULE:get_cwd(),
- ?line {error, enotsup} = ?FILE_MODULE:get_cwd("C:"), % Unix only testcase
- ?line {ok, FD1} = ?FILE_MODULE:open("file1.txt", write),
- ?line ok = ?FILE_MODULE:close(FD1),
- ?line {ok, FD2} = ?FILE_MODULE:open("file1.txt",
- [write, append,
- binary, compressed,
- delayed_write,
- {delayed_write, 0, 0},
- read_ahead,
- {read_ahead, 0}]),
- ?line ok = ?FILE_MODULE:write(FD2, L),
- ?line ok = ?FILE_MODULE:close(FD2),
- ?line {ok, N2} = ?FILE_MODULE:copy("file1.txt", "file2.txt"),
- ?line io:format("Size ~p, compressed ~p.~n", [N, N2]),
- ?line {ok, FD3} = ?FILE_MODULE:open("file2.txt",
- [binary, compressed]),
+ L = "qwertyuiopasdfghjklzxcvbnm",
+ N = length(L),
+ {ok, Cwd} = ?FILE_MODULE:get_cwd(),
+ {error, enotsup} = ?FILE_MODULE:get_cwd("C:"), % Unix only testcase
+ {ok, FD1} = ?FILE_MODULE:open("file1.txt", write),
+ ok = ?FILE_MODULE:close(FD1),
+ {ok, FD2} = ?FILE_MODULE:open("file1.txt",
+ [write, append,
+ binary, compressed,
+ delayed_write,
+ {delayed_write, 0, 0},
+ read_ahead,
+ {read_ahead, 0}]),
+ ok = ?FILE_MODULE:write(FD2, L),
+ ok = ?FILE_MODULE:close(FD2),
+ {ok, N2} = ?FILE_MODULE:copy("file1.txt", "file2.txt"),
+ io:format("Size ~p, compressed ~p.~n", [N, N2]),
+ {ok, FD3} = ?FILE_MODULE:open("file2.txt",
+ [binary, compressed]),
%% The file_io_server will translate the binary into a list
- ?line {ok, L} = ?FILE_MODULE:read(FD3, N+1),
- ?line ok = ?FILE_MODULE:close(FD3),
+ {ok, L} = ?FILE_MODULE:read(FD3, N+1),
+ ok = ?FILE_MODULE:close(FD3),
%%
- ?line ok = ?FILE_MODULE:delete("file1.txt"),
- ?line ok = ?FILE_MODULE:delete("file2.txt"),
- ?line [] = flush(),
+ ok = ?FILE_MODULE:delete("file1.txt"),
+ ok = ?FILE_MODULE:delete("file2.txt"),
+ [] = flush(),
ok.
%% Test the get_cwd() and open() file server calls.
old_slave(_RootDir, Cwd) ->
- ?line L = "qwertyuiopasdfghjklzxcvbnm",
- ?line N = length(L),
- ?line {ok, Cwd} = ?FILE_MODULE:get_cwd(),
- ?line {error, enotsup} = ?FILE_MODULE:get_cwd("C:"), % Unix only testcase
- ?line {ok, FD1} = ?FILE_MODULE:open("file1.txt", write),
- ?line ok = ?FILE_MODULE:close(FD1),
- ?line {ok, FD2} = ?FILE_MODULE:open("file1.txt",
- [write, binary, compressed]),
- ?line ok = ?FILE_MODULE:write(FD2, L),
- ?line ok = ?FILE_MODULE:close(FD2),
- ?line {ok, FD3} = ?FILE_MODULE:open("file1.txt", [write, append]),
- ?line ok = ?FILE_MODULE:close(FD3),
- ?line {ok, FD4} = ?FILE_MODULE:open("file1.txt",
- [binary, compressed]),
+ L = "qwertyuiopasdfghjklzxcvbnm",
+ N = length(L),
+ {ok, Cwd} = ?FILE_MODULE:get_cwd(),
+ {error, enotsup} = ?FILE_MODULE:get_cwd("C:"), % Unix only testcase
+ {ok, FD1} = ?FILE_MODULE:open("file1.txt", write),
+ ok = ?FILE_MODULE:close(FD1),
+ {ok, FD2} = ?FILE_MODULE:open("file1.txt",
+ [write, binary, compressed]),
+ ok = ?FILE_MODULE:write(FD2, L),
+ ok = ?FILE_MODULE:close(FD2),
+ {ok, FD3} = ?FILE_MODULE:open("file1.txt", [write, append]),
+ ok = ?FILE_MODULE:close(FD3),
+ {ok, FD4} = ?FILE_MODULE:open("file1.txt",
+ [binary, compressed]),
%% The file_io_server will translate the binary into a list
- ?line {ok, L} = ?FILE_MODULE:read(FD4, N+1),
- ?line ok = ?FILE_MODULE:close(FD4),
+ {ok, L} = ?FILE_MODULE:read(FD4, N+1),
+ ok = ?FILE_MODULE:close(FD4),
%%
- ?line ok = ?FILE_MODULE:delete("file1.txt"),
- ?line [] = flush(),
+ ok = ?FILE_MODULE:delete("file1.txt"),
+ [] = flush(),
ok.
run_test(Test, Args) ->
- ?line case (catch apply(?MODULE, Test, Args)) of
- {'EXIT', _} = Exit ->
- {done, Exit, get(test_server_loc)};
- Result ->
- {done, Result}
- end.
+ case (catch apply(?MODULE, Test, Args)) of
+ {'EXIT', _} = Exit ->
+ {done, Exit, get(test_server_loc)};
+ Result ->
+ {done, Result}
+ end.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-delayed_write(suite) ->
- [];
-delayed_write(doc) ->
- ["Tests the file open option {delayed_write, Size, Delay}"];
+%% Tests the file open option {delayed_write, Size, Delay}.
delayed_write(Config) when is_list(Config) ->
- Dog = ?t:timetrap(?t:seconds(20)),
-
- RootDir = ?config(priv_dir, Config),
+ RootDir = proplists:get_value(priv_dir, Config),
File = filename:join(RootDir,
- atom_to_list(?MODULE)++"_delayed_write.txt"),
+ atom_to_list(?MODULE)++"_delayed_write.txt"),
Data1 = "asdfghjkl",
Data2 = "qwertyuio",
Data3 = "zxcvbnm,.",
@@ -3143,18 +2917,18 @@ delayed_write(Config) when is_list(Config) ->
{ok, Fd1} =
?FILE_MODULE:open(File, [write, {delayed_write, Size+1, 2000}]),
ok = ?FILE_MODULE:write(Fd1, Data1),
- ?t:sleep(1000), % Just in case the file system is slow
+ timer:sleep(1000), % Just in case the file system is slow
{ok, Fd2} = ?FILE_MODULE:open(File, [read]),
eof = ?FILE_MODULE:read(Fd2, 1),
ok = ?FILE_MODULE:write(Fd1, Data1), % Data flush on size
- ?t:sleep(1000), % Just in case the file system is slow
+ timer:sleep(1000), % Just in case the file system is slow
{ok, Data1Data1} = ?FILE_MODULE:pread(Fd2, bof, 2*Size+1),
ok = ?FILE_MODULE:write(Fd1, Data1),
- ?t:sleep(3000), % Wait until data flush on timeout
+ timer:sleep(3000), % Wait until data flush on timeout
{ok, Data1Data1Data1} = ?FILE_MODULE:pread(Fd2, bof, 3*Size+1),
ok = ?FILE_MODULE:write(Fd1, Data1),
ok = ?FILE_MODULE:close(Fd1), % Data flush on close
- ?t:sleep(1000), % Just in case the file system is slow
+ timer:sleep(1000), % Just in case the file system is slow
{ok, Data1Data1Data1Data1} = ?FILE_MODULE:pread(Fd2, bof, 4*Size+1),
ok = ?FILE_MODULE:close(Fd2),
%%
@@ -3162,33 +2936,33 @@ delayed_write(Config) when is_list(Config) ->
%% raw file, default parameters.
Parent = self(),
Fun = fun() ->
- Child = self(),
- Test =
- fun () ->
- {ok, Fd} = ?FILE_MODULE:open(File,
- [raw, write, delayed_write]),
- ok = ?FILE_MODULE:write(Fd, Data1),
- Parent ! {Child, wrote},
- receive
- {Parent, continue, Reason} ->
- {ok, Reason}
- end
- end,
- case (catch Test()) of
- {ok, Reason} -> exit(Reason);
- Unknown ->
- exit({Unknown, get(test_server_loc)})
- end
- end,
+ Child = self(),
+ Test =
+ fun () ->
+ {ok, Fd} = ?FILE_MODULE:open(File,
+ [raw, write, delayed_write]),
+ ok = ?FILE_MODULE:write(Fd, Data1),
+ Parent ! {Child, wrote},
+ receive
+ {Parent, continue, Reason} ->
+ {ok, Reason}
+ end
+ end,
+ case (catch Test()) of
+ {ok, Reason} -> exit(Reason);
+ Unknown ->
+ exit({Unknown, get(test_server_loc)})
+ end
+ end,
Child1 = spawn(Fun),
Mref1 = erlang:monitor(process, Child1),
receive
{Child1, wrote} ->
ok;
{'DOWN', Mref1, _, _, _} = Down1a ->
- ?t:fail(Down1a)
+ ct:fail(Down1a)
end,
- ?t:sleep(1000), % Just in case the file system is slow
+ timer:sleep(1000), % Just in case the file system is slow
{ok, Fd3} = ?FILE_MODULE:open(File, [read]),
eof = ?FILE_MODULE:read(Fd3, 1),
Child1 ! {Parent, continue, normal},
@@ -3196,9 +2970,9 @@ delayed_write(Config) when is_list(Config) ->
{'DOWN', Mref1, process, Child1, normal} ->
ok;
{'DOWN', Mref1, _, _, _} = Down1b ->
- ?t:fail(Down1b)
+ ct:fail(Down1b)
end,
- ?t:sleep(1000), % Just in case the file system is slow
+ timer:sleep(1000), % Just in case the file system is slow
{ok, Data1} = ?FILE_MODULE:pread(Fd3, bof, Size+1),
ok = ?FILE_MODULE:close(Fd3),
%%
@@ -3209,9 +2983,9 @@ delayed_write(Config) when is_list(Config) ->
{Child2, wrote} ->
ok;
{'DOWN', Mref2, _, _, _} = Down2a ->
- ?t:fail(Down2a)
+ ct:fail(Down2a)
end,
- ?t:sleep(1000), % Just in case the file system is slow
+ timer:sleep(1000), % Just in case the file system is slow
{ok, Fd4} = ?FILE_MODULE:open(File, [read]),
eof = ?FILE_MODULE:read(Fd4, 1),
Child2 ! {Parent, continue, kill},
@@ -3219,15 +2993,15 @@ delayed_write(Config) when is_list(Config) ->
{'DOWN', Mref2, process, Child2, kill} ->
ok;
{'DOWN', Mref2, _, _, _} = Down2b ->
- ?t:fail(Down2b)
+ ct:fail(Down2b)
end,
- ?t:sleep(1000), % Just in case the file system is slow
+ timer:sleep(1000), % Just in case the file system is slow
eof = ?FILE_MODULE:pread(Fd4, bof, 1),
ok = ?FILE_MODULE:close(Fd4),
%%
%% Test if file position works with delayed_write
{ok, Fd5} = ?FILE_MODULE:open(File, [raw, read, write,
- delayed_write]),
+ delayed_write]),
ok = ?FILE_MODULE:truncate(Fd5),
ok = ?FILE_MODULE:write(Fd5, [Data1|Data2]),
{ok, 0} = ?FILE_MODULE:position(Fd5, bof),
@@ -3239,93 +3013,82 @@ delayed_write(Config) when is_list(Config) ->
ok = ?FILE_MODULE:close(Fd5),
%%
[] = flush(),
- ?t:timetrap_cancel(Dog),
ok.
-pid2name(doc) -> "Tests file:pid2name/1.";
-pid2name(suite) -> [];
+%% Tests file:pid2name/1.
pid2name(Config) when is_list(Config) ->
- ?line Dog = test_server:timetrap(test_server:seconds(10)),
- ?line RootDir = ?config(priv_dir, Config),
- ?line Base = test_server:temp_name(
- filename:join(RootDir, "pid2name_")),
- ?line Name1 = [Base, '.txt'],
- ?line Name2 = Base ++ ".txt",
- %%
- ?line {ok, Pid} = file:open(Name1, [write]),
- ?line {ok, Name2} = file:pid2name(Pid),
- ?line undefined = file:pid2name(self()),
- ?line ok = file:close(Pid),
- ?line test_server:sleep(1000),
- ?line false = is_process_alive(Pid),
- ?line undefined = file:pid2name(Pid),
+ RootDir = proplists:get_value(priv_dir, Config),
+ Base = test_server:temp_name(
+ filename:join(RootDir, "pid2name_")),
+ Name1 = [Base, '.txt'],
+ Name2 = Base ++ ".txt",
%%
- ?line test_server:timetrap_cancel(Dog),
+ {ok, Pid} = file:open(Name1, [write]),
+ {ok, Name2} = file:pid2name(Pid),
+ undefined = file:pid2name(self()),
+ ok = file:close(Pid),
+ ct:sleep(1000),
+ false = is_process_alive(Pid),
+ undefined = file:pid2name(Pid),
ok.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-read_ahead(suite) ->
- [];
-read_ahead(doc) ->
- ["Tests the file open option {read_ahead, Size}"];
+%% Tests the file open option {read_ahead, Size}.
read_ahead(Config) when is_list(Config) ->
- ?line Dog = ?t:timetrap(?t:seconds(20)),
- %%
- ?line RootDir = ?config(priv_dir, Config),
- ?line File = filename:join(RootDir,
- atom_to_list(?MODULE)++"_read_ahead.txt"),
- ?line Data1 = "asdfghjkl", % Must be
- ?line Data2 = "qwertyuio", % same
- ?line Data3 = "zxcvbnm,.", % length
- ?line Size = length(Data1),
- ?line Size = length(Data2),
- ?line Size = length(Data3),
+ RootDir = proplists:get_value(priv_dir, Config),
+ File = filename:join(RootDir,
+ atom_to_list(?MODULE)++"_read_ahead.txt"),
+ Data1 = "asdfghjkl", % Must be
+ Data2 = "qwertyuio", % same
+ Data3 = "zxcvbnm,.", % length
+ Size = length(Data1),
+ Size = length(Data2),
+ Size = length(Data3),
%%
%% Test caching of normal non-raw file
- ?line {ok, Fd1} = ?FILE_MODULE:open(File, [write]),
- ?line ok = ?FILE_MODULE:write(Fd1, [Data1|Data1]),
- ?line ?t:sleep(1000), % Just in case the file system is slow
- ?line {ok, Fd2} = ?FILE_MODULE:open(File, [read, {read_ahead, 2*Size}]),
- ?line {ok, Data1} = ?FILE_MODULE:read(Fd2, Size),
- ?line ok = ?FILE_MODULE:pwrite(Fd1, Size, Data2),
- ?line ?t:sleep(1000), % Just in case the file system is slow
- ?line {ok, Data1} = ?FILE_MODULE:read(Fd2, Size), % Will read cached data
- ?line Data2Data2Data2 = Data2++Data2++Data2,
- ?line ok = ?FILE_MODULE:pwrite(Fd1, eof, Data2Data2Data2),
- ?line ?t:sleep(1000), % Just in case the file system is slow
- ?line {ok, Data2Data2Data2} =
+ {ok, Fd1} = ?FILE_MODULE:open(File, [write]),
+ ok = ?FILE_MODULE:write(Fd1, [Data1|Data1]),
+ timer:sleep(1000), % Just in case the file system is slow
+ {ok, Fd2} = ?FILE_MODULE:open(File, [read, {read_ahead, 2*Size}]),
+ {ok, Data1} = ?FILE_MODULE:read(Fd2, Size),
+ ok = ?FILE_MODULE:pwrite(Fd1, Size, Data2),
+ timer:sleep(1000), % Just in case the file system is slow
+ {ok, Data1} = ?FILE_MODULE:read(Fd2, Size), % Will read cached data
+ Data2Data2Data2 = Data2++Data2++Data2,
+ ok = ?FILE_MODULE:pwrite(Fd1, eof, Data2Data2Data2),
+ timer:sleep(1000), % Just in case the file system is slow
+ {ok, Data2Data2Data2} =
?FILE_MODULE:read(Fd2, 3*Size), % Read more than cache buffer
- ?line ok = ?FILE_MODULE:close(Fd1),
- ?line ok = ?FILE_MODULE:close(Fd2),
+ ok = ?FILE_MODULE:close(Fd1),
+ ok = ?FILE_MODULE:close(Fd2),
%% Test caching of raw file and default parameters
- ?line {ok, Fd3} = ?FILE_MODULE:open(File, [raw, write]),
- ?line ok = ?FILE_MODULE:write(Fd3, [Data1|Data1]),
- ?line ?t:sleep(1000), % Just in case the file system is slow
- ?line {ok, Fd4} = ?FILE_MODULE:open(File, [raw, read, read_ahead]),
- ?line {ok, Data1} = ?FILE_MODULE:read(Fd4, Size),
- ?line ok = ?FILE_MODULE:pwrite(Fd3, Size, Data2),
- ?line ?t:sleep(1000), % Just in case the file system is slow
- ?line {ok, Data1} = ?FILE_MODULE:read(Fd4, Size), % Will read cached data
- ?line ok = ?FILE_MODULE:close(Fd3),
- ?line ok = ?FILE_MODULE:close(Fd4),
+ {ok, Fd3} = ?FILE_MODULE:open(File, [raw, write]),
+ ok = ?FILE_MODULE:write(Fd3, [Data1|Data1]),
+ timer:sleep(1000), % Just in case the file system is slow
+ {ok, Fd4} = ?FILE_MODULE:open(File, [raw, read, read_ahead]),
+ {ok, Data1} = ?FILE_MODULE:read(Fd4, Size),
+ ok = ?FILE_MODULE:pwrite(Fd3, Size, Data2),
+ timer:sleep(1000), % Just in case the file system is slow
+ {ok, Data1} = ?FILE_MODULE:read(Fd4, Size), % Will read cached data
+ ok = ?FILE_MODULE:close(Fd3),
+ ok = ?FILE_MODULE:close(Fd4),
%% Test if the file position works in combination with read_ahead
- ?line {ok, Fd5} = ?FILE_MODULE:open(File, [raw, read, write, read_ahead]),
- ?line ok = ?FILE_MODULE:truncate(Fd5),
- ?line ok = ?FILE_MODULE:write(Fd5, [Data1,Data1|Data3]),
- ?line {ok, 0} = ?FILE_MODULE:position(Fd5, bof),
- ?line {ok, Data1} = ?FILE_MODULE:read(Fd5, Size),
- ?line ok = ?FILE_MODULE:write(Fd5, Data2),
- ?line {ok, 0} = ?FILE_MODULE:position(Fd5, bof),
- ?line Data1Data2Data3 = Data1++Data2++Data3,
- ?line {ok, Data1Data2Data3} = ?FILE_MODULE:read(Fd5, 3*Size+1),
- ?line ok = ?FILE_MODULE:close(Fd5),
+ {ok, Fd5} = ?FILE_MODULE:open(File, [raw, read, write, read_ahead]),
+ ok = ?FILE_MODULE:truncate(Fd5),
+ ok = ?FILE_MODULE:write(Fd5, [Data1,Data1|Data3]),
+ {ok, 0} = ?FILE_MODULE:position(Fd5, bof),
+ {ok, Data1} = ?FILE_MODULE:read(Fd5, Size),
+ ok = ?FILE_MODULE:write(Fd5, Data2),
+ {ok, 0} = ?FILE_MODULE:position(Fd5, bof),
+ Data1Data2Data3 = Data1++Data2++Data3,
+ {ok, Data1Data2Data3} = ?FILE_MODULE:read(Fd5, 3*Size+1),
+ ok = ?FILE_MODULE:close(Fd5),
%%
- ?line [] = flush(),
- ?line ?t:timetrap_cancel(Dog),
+ [] = flush(),
ok.
@@ -3334,137 +3097,131 @@ read_ahead(Config) when is_list(Config) ->
-segment_read(suite) ->
- [];
-segment_read(doc) ->
- ["Tests the segmenting of large reads"];
+%% Tests the segmenting of large reads.
segment_read(Config) when is_list(Config) ->
- ?line Dog = ?t:timetrap(?t:seconds(60)),
- %%
- ?line Name = filename:join(?config(priv_dir, Config),
- ?MODULE_STRING ++ "_segment_read"),
- ?line SegSize = 256*1024,
- ?line SegCnt = SegSize div 4,
- ?line Cnt = 4 * SegCnt,
- ?line ok = create_file(Name, Cnt),
+ Name = filename:join(proplists:get_value(priv_dir, Config),
+ ?MODULE_STRING ++ "_segment_read"),
+ SegSize = 256*1024,
+ SegCnt = SegSize div 4,
+ Cnt = 4 * SegCnt,
+ ok = create_file(Name, Cnt),
%%
%% read_file/1
%%
- ?line {ok, Bin} = ?FILE_MODULE:read_file(Name),
- ?line true = verify_bin(Bin, 0, Cnt),
+ {ok, Bin} = ?FILE_MODULE:read_file(Name),
+ true = verify_bin(Bin, 0, Cnt),
%%
%% read/2
%%
%% Not segmented
- ?line {ok, FD1} = ?FILE_MODULE:open(Name, [read, raw, binary]),
- ?line {ok, B1a} = ?FILE_MODULE:read(FD1, SegSize),
- ?line {ok, B1b} = ?FILE_MODULE:read(FD1, SegSize),
- ?line {ok, B1c} = ?FILE_MODULE:read(FD1, SegSize),
- ?line {ok, B1d} = ?FILE_MODULE:read(FD1, SegSize),
- ?line ok = ?FILE_MODULE:close(FD1),
- ?line true = verify_bin(B1a, 0*SegCnt, SegCnt),
- ?line true = verify_bin(B1b, 1*SegCnt, SegCnt),
- ?line true = verify_bin(B1c, 2*SegCnt, SegCnt),
- ?line true = verify_bin(B1d, 3*SegCnt, SegCnt),
+ {ok, FD1} = ?FILE_MODULE:open(Name, [read, raw, binary]),
+ {ok, B1a} = ?FILE_MODULE:read(FD1, SegSize),
+ {ok, B1b} = ?FILE_MODULE:read(FD1, SegSize),
+ {ok, B1c} = ?FILE_MODULE:read(FD1, SegSize),
+ {ok, B1d} = ?FILE_MODULE:read(FD1, SegSize),
+ ok = ?FILE_MODULE:close(FD1),
+ true = verify_bin(B1a, 0*SegCnt, SegCnt),
+ true = verify_bin(B1b, 1*SegCnt, SegCnt),
+ true = verify_bin(B1c, 2*SegCnt, SegCnt),
+ true = verify_bin(B1d, 3*SegCnt, SegCnt),
%%
%% Segmented
- ?line {ok, FD2} = ?FILE_MODULE:open(Name, [read, raw, binary]),
- ?line {ok, B2a} = ?FILE_MODULE:read(FD2, 1*SegSize),
- ?line {ok, B2b} = ?FILE_MODULE:read(FD2, 2*SegSize),
- ?line {ok, B2c} = ?FILE_MODULE:read(FD2, 2*SegSize),
- ?line ok = ?FILE_MODULE:close(FD2),
- ?line true = verify_bin(B2a, 0*SegCnt, 1*SegCnt),
- ?line true = verify_bin(B2b, 1*SegCnt, 2*SegCnt),
- ?line true = verify_bin(B2c, 3*SegCnt, 1*SegCnt),
+ {ok, FD2} = ?FILE_MODULE:open(Name, [read, raw, binary]),
+ {ok, B2a} = ?FILE_MODULE:read(FD2, 1*SegSize),
+ {ok, B2b} = ?FILE_MODULE:read(FD2, 2*SegSize),
+ {ok, B2c} = ?FILE_MODULE:read(FD2, 2*SegSize),
+ ok = ?FILE_MODULE:close(FD2),
+ true = verify_bin(B2a, 0*SegCnt, 1*SegCnt),
+ true = verify_bin(B2b, 1*SegCnt, 2*SegCnt),
+ true = verify_bin(B2c, 3*SegCnt, 1*SegCnt),
%%
%% pread/3
%%
- ?line {ok, FD3} = ?FILE_MODULE:open(Name, [read, raw, binary]),
+ {ok, FD3} = ?FILE_MODULE:open(Name, [read, raw, binary]),
%%
%% Not segmented
- ?line {ok, B3d} = ?FILE_MODULE:pread(FD3, 3*SegSize, SegSize),
- ?line {ok, B3c} = ?FILE_MODULE:pread(FD3, 2*SegSize, SegSize),
- ?line {ok, B3b} = ?FILE_MODULE:pread(FD3, 1*SegSize, SegSize),
- ?line {ok, B3a} = ?FILE_MODULE:pread(FD3, 0*SegSize, SegSize),
- ?line true = verify_bin(B3a, 0*SegCnt, SegCnt),
- ?line true = verify_bin(B3b, 1*SegCnt, SegCnt),
- ?line true = verify_bin(B3c, 2*SegCnt, SegCnt),
- ?line true = verify_bin(B3d, 3*SegCnt, SegCnt),
+ {ok, B3d} = ?FILE_MODULE:pread(FD3, 3*SegSize, SegSize),
+ {ok, B3c} = ?FILE_MODULE:pread(FD3, 2*SegSize, SegSize),
+ {ok, B3b} = ?FILE_MODULE:pread(FD3, 1*SegSize, SegSize),
+ {ok, B3a} = ?FILE_MODULE:pread(FD3, 0*SegSize, SegSize),
+ true = verify_bin(B3a, 0*SegCnt, SegCnt),
+ true = verify_bin(B3b, 1*SegCnt, SegCnt),
+ true = verify_bin(B3c, 2*SegCnt, SegCnt),
+ true = verify_bin(B3d, 3*SegCnt, SegCnt),
%%
%% Segmented
- ?line {ok, B3g} = ?FILE_MODULE:pread(FD3, 3*SegSize, 2*SegSize),
- ?line {ok, B3f} = ?FILE_MODULE:pread(FD3, 1*SegSize, 2*SegSize),
- ?line {ok, B3e} = ?FILE_MODULE:pread(FD3, 0*SegSize, 1*SegSize),
- ?line true = verify_bin(B3e, 0*SegCnt, 1*SegCnt),
- ?line true = verify_bin(B3f, 1*SegCnt, 2*SegCnt),
- ?line true = verify_bin(B3g, 3*SegCnt, 1*SegCnt),
+ {ok, B3g} = ?FILE_MODULE:pread(FD3, 3*SegSize, 2*SegSize),
+ {ok, B3f} = ?FILE_MODULE:pread(FD3, 1*SegSize, 2*SegSize),
+ {ok, B3e} = ?FILE_MODULE:pread(FD3, 0*SegSize, 1*SegSize),
+ true = verify_bin(B3e, 0*SegCnt, 1*SegCnt),
+ true = verify_bin(B3f, 1*SegCnt, 2*SegCnt),
+ true = verify_bin(B3g, 3*SegCnt, 1*SegCnt),
%%
- ?line ok = ?FILE_MODULE:close(FD3),
+ ok = ?FILE_MODULE:close(FD3),
%%
%% pread/2
%%
- ?line {ok, FD5} = ?FILE_MODULE:open(Name, [read, raw, binary]),
+ {ok, FD5} = ?FILE_MODULE:open(Name, [read, raw, binary]),
%%
%% +---+---+---+---+
%% | 4 | 3 | 2 | 1 |
%% +---+---+---+---+
%% < ^ >
- ?line {ok, [B5d, B5c, B5b, B5a]} =
+ {ok, [B5d, B5c, B5b, B5a]} =
?FILE_MODULE:pread(FD5, [{3*SegSize, SegSize},
{2*SegSize, SegSize},
{1*SegSize, SegSize},
{0*SegSize, SegSize}]),
- ?line true = verify_bin(B5a, 0*SegCnt, SegCnt),
- ?line true = verify_bin(B5b, 1*SegCnt, SegCnt),
- ?line true = verify_bin(B5c, 2*SegCnt, SegCnt),
- ?line true = verify_bin(B5d, 3*SegCnt, SegCnt),
+ true = verify_bin(B5a, 0*SegCnt, SegCnt),
+ true = verify_bin(B5b, 1*SegCnt, SegCnt),
+ true = verify_bin(B5c, 2*SegCnt, SegCnt),
+ true = verify_bin(B5d, 3*SegCnt, SegCnt),
%%
%% +---+-------+-------+
%% | 3 | 2 | 1 |
%% +---+-------+-------+
%% < ^ ^ >
- ?line {ok, [B5g, B5f, B5e]} =
+ {ok, [B5g, B5f, B5e]} =
?FILE_MODULE:pread(FD5, [{3*SegSize, 2*SegSize},
{1*SegSize, 2*SegSize},
{0*SegSize, 1*SegSize}]),
- ?line true = verify_bin(B5e, 0*SegCnt, 1*SegCnt),
- ?line true = verify_bin(B5f, 1*SegCnt, 2*SegCnt),
- ?line true = verify_bin(B5g, 3*SegCnt, 1*SegCnt),
+ true = verify_bin(B5e, 0*SegCnt, 1*SegCnt),
+ true = verify_bin(B5f, 1*SegCnt, 2*SegCnt),
+ true = verify_bin(B5g, 3*SegCnt, 1*SegCnt),
%%
%%
%% +-------+-----------+
%% | 2 | 1 |
%% +-------+-----------+
%% < ^ ^ >
- ?line {ok, [B5i, B5h]} =
+ {ok, [B5i, B5h]} =
?FILE_MODULE:pread(FD5, [{2*SegSize, 3*SegSize},
{0*SegSize, 2*SegSize}]),
- ?line true = verify_bin(B5h, 0*SegCnt, 2*SegCnt),
- ?line true = verify_bin(B5i, 2*SegCnt, 2*SegCnt),
+ true = verify_bin(B5h, 0*SegCnt, 2*SegCnt),
+ true = verify_bin(B5i, 2*SegCnt, 2*SegCnt),
%%
%% +-------+---+---+
%% | 3 | 2 | 1 |
%% +-------+---+---+
%% < ^ ^ >
- ?line {ok, [B5l, B5k, B5j]} =
+ {ok, [B5l, B5k, B5j]} =
?FILE_MODULE:pread(FD5, [{3*SegSize, 1*SegSize},
{2*SegSize, 1*SegSize},
{0*SegSize, 2*SegSize}]),
- ?line true = verify_bin(B5j, 0*SegCnt, 2*SegCnt),
- ?line true = verify_bin(B5k, 2*SegCnt, 1*SegCnt),
- ?line true = verify_bin(B5l, 3*SegCnt, 1*SegCnt),
+ true = verify_bin(B5j, 0*SegCnt, 2*SegCnt),
+ true = verify_bin(B5k, 2*SegCnt, 1*SegCnt),
+ true = verify_bin(B5l, 3*SegCnt, 1*SegCnt),
%%
%% Real time response time test.
%%
Req = lists:flatten(lists:duplicate(17,
[{2*SegSize, 2*SegSize},
{0*SegSize, 2*SegSize}])),
- ?line {{ok, _}, Comment} =
+ {{ok, _}, Comment} =
response_analysis(?FILE_MODULE, pread, [FD5, Req]),
- ?line ok = ?FILE_MODULE:close(FD5),
+ ok = ?FILE_MODULE:close(FD5),
%%
- ?line [] = flush(),
- ?line ?t:timetrap_cancel(Dog),
+ [] = flush(),
{comment, Comment}.
@@ -3473,100 +3230,95 @@ segment_read(Config) when is_list(Config) ->
-segment_write(suite) ->
- [];
-segment_write(doc) ->
- ["Tests the segmenting of large writes"];
+%% Tests the segmenting of large writes.
segment_write(Config) when is_list(Config) ->
- ?line Dog = ?t:timetrap(?t:seconds(60)),
- %%
- ?line Name = filename:join(?config(priv_dir, Config),
- ?MODULE_STRING ++ "_segment_write"),
- ?line SegSize = 256*1024,
- ?line SegCnt = SegSize div 4,
- ?line Cnt = 4 * SegCnt,
- ?line Bin = create_bin(0, Cnt),
+ Name = filename:join(proplists:get_value(priv_dir, Config),
+ ?MODULE_STRING ++ "_segment_write"),
+ SegSize = 256*1024,
+ SegCnt = SegSize div 4,
+ Cnt = 4 * SegCnt,
+ Bin = create_bin(0, Cnt),
%%
%% write/2
%%
%% Not segmented
- ?line {ok, FD1} = ?FILE_MODULE:open(Name, [write, raw, binary]),
- ?line ok = ?FILE_MODULE:write(FD1, subbin(Bin, 0*SegSize, 1*SegSize)),
- ?line ok = ?FILE_MODULE:write(FD1, subbin(Bin, 1*SegSize, 1*SegSize)),
- ?line ok = ?FILE_MODULE:write(FD1, subbin(Bin, 2*SegSize, 1*SegSize)),
- ?line ok = ?FILE_MODULE:write(FD1, subbin(Bin, 3*SegSize, 1*SegSize)),
- ?line ok = ?FILE_MODULE:close(FD1),
- ?line true = verify_file(Name, Cnt),
+ {ok, FD1} = ?FILE_MODULE:open(Name, [write, raw, binary]),
+ ok = ?FILE_MODULE:write(FD1, subbin(Bin, 0*SegSize, 1*SegSize)),
+ ok = ?FILE_MODULE:write(FD1, subbin(Bin, 1*SegSize, 1*SegSize)),
+ ok = ?FILE_MODULE:write(FD1, subbin(Bin, 2*SegSize, 1*SegSize)),
+ ok = ?FILE_MODULE:write(FD1, subbin(Bin, 3*SegSize, 1*SegSize)),
+ ok = ?FILE_MODULE:close(FD1),
+ true = verify_file(Name, Cnt),
%%
%% Segmented
- ?line {ok, FD2} = ?FILE_MODULE:open(Name, [write, raw, binary]),
- ?line ok = ?FILE_MODULE:write(FD2, subbin(Bin, 0*SegSize, 1*SegSize)),
- ?line ok = ?FILE_MODULE:write(FD2, subbin(Bin, 1*SegSize, 2*SegSize)),
- ?line ok = ?FILE_MODULE:write(FD2, subbin(Bin, 3*SegSize, 1*SegSize)),
- ?line ok = ?FILE_MODULE:close(FD2),
- ?line true = verify_file(Name, Cnt),
+ {ok, FD2} = ?FILE_MODULE:open(Name, [write, raw, binary]),
+ ok = ?FILE_MODULE:write(FD2, subbin(Bin, 0*SegSize, 1*SegSize)),
+ ok = ?FILE_MODULE:write(FD2, subbin(Bin, 1*SegSize, 2*SegSize)),
+ ok = ?FILE_MODULE:write(FD2, subbin(Bin, 3*SegSize, 1*SegSize)),
+ ok = ?FILE_MODULE:close(FD2),
+ true = verify_file(Name, Cnt),
%%
%% +---+---+---+---+
%% | | | | |
%% +---+---+---+---+
%% < ^ >
- ?line ok = write_file(Name, [subbin(Bin, 0*SegSize, 1*SegSize),
- subbin(Bin, 1*SegSize, 1*SegSize),
- subbin(Bin, 2*SegSize, 1*SegSize),
- subbin(Bin, 3*SegSize, 1*SegSize)]),
- ?line true = verify_file(Name, Cnt),
+ ok = write_file(Name, [subbin(Bin, 0*SegSize, 1*SegSize),
+ subbin(Bin, 1*SegSize, 1*SegSize),
+ subbin(Bin, 2*SegSize, 1*SegSize),
+ subbin(Bin, 3*SegSize, 1*SegSize)]),
+ true = verify_file(Name, Cnt),
%%
%% +---+-------+---+
%% | | | |
%% +---+-------+---+
%% < ^ ^ >
- ?line ok = write_file(Name, [subbin(Bin, 0*SegSize, 1*SegSize),
- subbin(Bin, 1*SegSize, 2*SegSize),
- subbin(Bin, 3*SegSize, 1*SegSize)]),
- ?line true = verify_file(Name, Cnt),
+ ok = write_file(Name, [subbin(Bin, 0*SegSize, 1*SegSize),
+ subbin(Bin, 1*SegSize, 2*SegSize),
+ subbin(Bin, 3*SegSize, 1*SegSize)]),
+ true = verify_file(Name, Cnt),
%%
%% +-------+-------+
%% | | |
%% +-------+-------+
%% < ^ ^ >
- ?line ok = write_file(Name, [subbin(Bin, 0*SegSize, 2*SegSize),
- subbin(Bin, 2*SegSize, 2*SegSize)]),
- ?line true = verify_file(Name, Cnt),
+ ok = write_file(Name, [subbin(Bin, 0*SegSize, 2*SegSize),
+ subbin(Bin, 2*SegSize, 2*SegSize)]),
+ true = verify_file(Name, Cnt),
%%
%% +-------+---+---+
%% | | | |
%% +-------+---+---+
%% < ^ ^ >
- ?line ok = write_file(Name, [subbin(Bin, 0*SegSize, 2*SegSize),
- subbin(Bin, 2*SegSize, 1*SegSize),
- subbin(Bin, 3*SegSize, 1*SegSize)]),
- ?line true = verify_file(Name, Cnt),
+ ok = write_file(Name, [subbin(Bin, 0*SegSize, 2*SegSize),
+ subbin(Bin, 2*SegSize, 1*SegSize),
+ subbin(Bin, 3*SegSize, 1*SegSize)]),
+ true = verify_file(Name, Cnt),
%%
%% pwrite/3
%%
%% Not segmented
- ?line {ok, FD3} = ?FILE_MODULE:open(Name, [write, raw, binary]),
- ?line ok = ?FILE_MODULE:pwrite(FD3, 3*SegSize,
- subbin(Bin, 3*SegSize, 1*SegSize)),
- ?line ok = ?FILE_MODULE:pwrite(FD3, 2*SegSize,
- subbin(Bin, 2*SegSize, 1*SegSize)),
- ?line ok = ?FILE_MODULE:pwrite(FD3, 1*SegSize,
- subbin(Bin, 1*SegSize, 1*SegSize)),
- ?line ok = ?FILE_MODULE:pwrite(FD3, 0*SegSize,
- subbin(Bin, 0*SegSize, 1*SegSize)),
- ?line ok = ?FILE_MODULE:close(FD3),
- ?line true = verify_file(Name, Cnt),
+ {ok, FD3} = ?FILE_MODULE:open(Name, [write, raw, binary]),
+ ok = ?FILE_MODULE:pwrite(FD3, 3*SegSize,
+ subbin(Bin, 3*SegSize, 1*SegSize)),
+ ok = ?FILE_MODULE:pwrite(FD3, 2*SegSize,
+ subbin(Bin, 2*SegSize, 1*SegSize)),
+ ok = ?FILE_MODULE:pwrite(FD3, 1*SegSize,
+ subbin(Bin, 1*SegSize, 1*SegSize)),
+ ok = ?FILE_MODULE:pwrite(FD3, 0*SegSize,
+ subbin(Bin, 0*SegSize, 1*SegSize)),
+ ok = ?FILE_MODULE:close(FD3),
+ true = verify_file(Name, Cnt),
%%
%% Segmented
- ?line {ok, FD4} = ?FILE_MODULE:open(Name, [write, raw, binary]),
- ?line ok = ?FILE_MODULE:pwrite(FD4, 3*SegSize,
- subbin(Bin, 3*SegSize, 1*SegSize)),
- ?line ok = ?FILE_MODULE:pwrite(FD4, 1*SegSize,
- subbin(Bin, 1*SegSize, 2*SegSize)),
- ?line ok = ?FILE_MODULE:pwrite(FD4, 0*SegSize,
- subbin(Bin, 0*SegSize, 1*SegSize)),
- ?line ok = ?FILE_MODULE:close(FD4),
- ?line true = verify_file(Name, Cnt),
+ {ok, FD4} = ?FILE_MODULE:open(Name, [write, raw, binary]),
+ ok = ?FILE_MODULE:pwrite(FD4, 3*SegSize,
+ subbin(Bin, 3*SegSize, 1*SegSize)),
+ ok = ?FILE_MODULE:pwrite(FD4, 1*SegSize,
+ subbin(Bin, 1*SegSize, 2*SegSize)),
+ ok = ?FILE_MODULE:pwrite(FD4, 0*SegSize,
+ subbin(Bin, 0*SegSize, 1*SegSize)),
+ ok = ?FILE_MODULE:close(FD4),
+ true = verify_file(Name, Cnt),
@@ -3574,125 +3326,118 @@ segment_write(Config) when is_list(Config) ->
%% pwrite/2
%%
%% Not segmented
- ?line {ok, FD5} = ?FILE_MODULE:open(Name, [write, raw, binary]),
- ?line ok = ?FILE_MODULE:pwrite(FD5, [{3*SegSize,
- subbin(Bin, 3*SegSize, 1*SegSize)}]),
- ?line ok = ?FILE_MODULE:pwrite(FD5, [{2*SegSize,
- subbin(Bin, 2*SegSize, 1*SegSize)}]),
- ?line ok = ?FILE_MODULE:pwrite(FD5, [{1*SegSize,
- subbin(Bin, 1*SegSize, 1*SegSize)}]),
- ?line ok = ?FILE_MODULE:pwrite(FD5, [{0*SegSize,
- subbin(Bin, 0*SegSize, 1*SegSize)}]),
- ?line ok = ?FILE_MODULE:close(FD5),
- ?line true = verify_file(Name, Cnt),
+ {ok, FD5} = ?FILE_MODULE:open(Name, [write, raw, binary]),
+ ok = ?FILE_MODULE:pwrite(FD5, [{3*SegSize,
+ subbin(Bin, 3*SegSize, 1*SegSize)}]),
+ ok = ?FILE_MODULE:pwrite(FD5, [{2*SegSize,
+ subbin(Bin, 2*SegSize, 1*SegSize)}]),
+ ok = ?FILE_MODULE:pwrite(FD5, [{1*SegSize,
+ subbin(Bin, 1*SegSize, 1*SegSize)}]),
+ ok = ?FILE_MODULE:pwrite(FD5, [{0*SegSize,
+ subbin(Bin, 0*SegSize, 1*SegSize)}]),
+ ok = ?FILE_MODULE:close(FD5),
+ true = verify_file(Name, Cnt),
%%
%% Segmented
- ?line {ok, FD6} = ?FILE_MODULE:open(Name, [write, raw, binary]),
- ?line ok = ?FILE_MODULE:pwrite(FD6, [{3*SegSize,
- subbin(Bin, 3*SegSize, 1*SegSize)}]),
- ?line ok = ?FILE_MODULE:pwrite(FD6, [{1*SegSize,
- subbin(Bin, 1*SegSize, 2*SegSize)}]),
- ?line ok = ?FILE_MODULE:pwrite(FD6, [{0*SegSize,
- subbin(Bin, 0*SegSize, 1*SegSize)}]),
- ?line ok = ?FILE_MODULE:close(FD6),
- ?line true = verify_file(Name, Cnt),
+ {ok, FD6} = ?FILE_MODULE:open(Name, [write, raw, binary]),
+ ok = ?FILE_MODULE:pwrite(FD6, [{3*SegSize,
+ subbin(Bin, 3*SegSize, 1*SegSize)}]),
+ ok = ?FILE_MODULE:pwrite(FD6, [{1*SegSize,
+ subbin(Bin, 1*SegSize, 2*SegSize)}]),
+ ok = ?FILE_MODULE:pwrite(FD6, [{0*SegSize,
+ subbin(Bin, 0*SegSize, 1*SegSize)}]),
+ ok = ?FILE_MODULE:close(FD6),
+ true = verify_file(Name, Cnt),
%%
%% +---+---+---+---+
%% | 4 | 3 | 2 | 1 |
%% +---+---+---+---+
%% < ^ >
- ?line ok = pwrite_file(Name, [{3*SegSize,
- subbin(Bin, 3*SegSize, 1*SegSize)},
- {2*SegSize,
- subbin(Bin, 2*SegSize, 1*SegSize)},
- {1*SegSize,
- subbin(Bin, 1*SegSize, 1*SegSize)},
- {0*SegSize,
- subbin(Bin, 0*SegSize, 1*SegSize)}]),
- ?line true = verify_file(Name, Cnt),
+ ok = pwrite_file(Name, [{3*SegSize,
+ subbin(Bin, 3*SegSize, 1*SegSize)},
+ {2*SegSize,
+ subbin(Bin, 2*SegSize, 1*SegSize)},
+ {1*SegSize,
+ subbin(Bin, 1*SegSize, 1*SegSize)},
+ {0*SegSize,
+ subbin(Bin, 0*SegSize, 1*SegSize)}]),
+ true = verify_file(Name, Cnt),
%%
%% +---+-------+---+
%% | 3 | 2 | 1 |
%% +---+-------+---+
%% < ^ ^ >
- ?line ok = pwrite_file(Name, [{3*SegSize,
- subbin(Bin, 3*SegSize, 1*SegSize)},
- {1*SegSize,
- subbin(Bin, 1*SegSize, 2*SegSize)},
- {0*SegSize,
- subbin(Bin, 0*SegSize, 1*SegSize)}]),
- ?line true = verify_file(Name, Cnt),
+ ok = pwrite_file(Name, [{3*SegSize,
+ subbin(Bin, 3*SegSize, 1*SegSize)},
+ {1*SegSize,
+ subbin(Bin, 1*SegSize, 2*SegSize)},
+ {0*SegSize,
+ subbin(Bin, 0*SegSize, 1*SegSize)}]),
+ true = verify_file(Name, Cnt),
%%
%% +-------+-------+
%% | 2 | 1 |
%% +-------+-------+
%% < ^ ^ >
- ?line ok = pwrite_file(Name, [{2*SegSize,
- subbin(Bin, 2*SegSize, 2*SegSize)},
- {0*SegSize,
- subbin(Bin, 0*SegSize, 2*SegSize)}]),
- ?line true = verify_file(Name, Cnt),
+ ok = pwrite_file(Name, [{2*SegSize,
+ subbin(Bin, 2*SegSize, 2*SegSize)},
+ {0*SegSize,
+ subbin(Bin, 0*SegSize, 2*SegSize)}]),
+ true = verify_file(Name, Cnt),
%%
%% +-------+---+---+
%% | 3 | 2 | 1 |
%% +-------+---+---+
%% < ^ ^ >
- ?line ok = pwrite_file(Name, [{3*SegSize,
- subbin(Bin, 3*SegSize, 1*SegSize)},
- {2*SegSize,
- subbin(Bin, 2*SegSize, 1*SegSize)},
- {0*SegSize,
- subbin(Bin, 0*SegSize, 2*SegSize)}]),
- ?line true = verify_file(Name, Cnt),
+ ok = pwrite_file(Name, [{3*SegSize,
+ subbin(Bin, 3*SegSize, 1*SegSize)},
+ {2*SegSize,
+ subbin(Bin, 2*SegSize, 1*SegSize)},
+ {0*SegSize,
+ subbin(Bin, 0*SegSize, 2*SegSize)}]),
+ true = verify_file(Name, Cnt),
%%
%% Real time response time test.
%%
- ?line {ok, FD7} = ?FILE_MODULE:open(Name, [write, raw, binary]),
+ {ok, FD7} = ?FILE_MODULE:open(Name, [write, raw, binary]),
Req = lists:flatten(lists:duplicate(17,
[{2*SegSize,
subbin(Bin, 2*SegSize, 2*SegSize)},
- {0*SegSize,
- subbin(Bin, 0*SegSize, 2*SegSize)}])),
- ?line {ok, Comment} =
+ {0*SegSize,
+ subbin(Bin, 0*SegSize, 2*SegSize)}])),
+ {ok, Comment} =
response_analysis(?FILE_MODULE, pwrite, [FD7, Req]),
- ?line ok = ?FILE_MODULE:close(FD7),
+ ok = ?FILE_MODULE:close(FD7),
%%
- ?line [] = flush(),
- ?line ?t:timetrap_cancel(Dog),
+ [] = flush(),
{comment, Comment}.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-ipread(suite) ->
- [];
-ipread(doc) ->
- ["Test Dets special indirect pread"];
+%% Test Dets special indirect pread.
ipread(Config) when is_list(Config) ->
- ?line Dog = ?t:timetrap(?t:seconds(30)),
- %%
- ?line Dir = ?config(priv_dir, Config),
- ?line ok = ipread_int(Dir, [raw, binary]),
- ?line ok = ipread_int(Dir, [raw]),
- ?line ok = ipread_int(Dir, [binary]),
- ?line ok = ipread_int(Dir, []),
- ?line ok = ipread_int(Dir, [ram, binary]),
- ?line ok = ipread_int(Dir, [ram]),
+ Dir = proplists:get_value(priv_dir, Config),
+ ok = ipread_int(Dir, [raw, binary]),
+ ok = ipread_int(Dir, [raw]),
+ ok = ipread_int(Dir, [binary]),
+ ok = ipread_int(Dir, []),
+ ok = ipread_int(Dir, [ram, binary]),
+ ok = ipread_int(Dir, [ram]),
%%
- ?line [] = flush(),
- ?line ?t:timetrap_cancel(Dog),
+ [] = flush(),
ok.
ipread_int(Dir, ModeList) ->
- ?line Name =
+ Name =
filename:join(Dir,
lists:flatten([?MODULE_STRING, "_ipread",
- lists:map(fun (X) ->
- ["_", atom_to_list(X)]
- end,
- ModeList)])),
- ?line io:format("ipread_int<~p, ~p>~n", [Name, ModeList]),
- ?line {Conv, Sizeof} =
+ lists:map(fun (X) ->
+ ["_", atom_to_list(X)]
+ end,
+ ModeList)])),
+ io:format("ipread_int<~p, ~p>~n", [Name, ModeList]),
+ {Conv, Sizeof} =
case lists:member(binary, ModeList) of
true ->
{fun (Bin) when is_binary(Bin) -> Bin;
@@ -3705,144 +3450,130 @@ ipread_int(Dir, ModeList) ->
end,
fun erlang:length/1}
end,
- ?line Pos = 4711,
- ?line Data = Conv("THE QUICK BROWN FOX JUMPS OVER A LAZY DOG"),
- ?line Size = Sizeof(Data),
- ?line Init = Conv(" "),
- ?line SizeInit = Sizeof(Init),
- ?line Head = Conv(<<Size:32/big-unsigned, Pos:32/big-unsigned>>),
- ?line Filler = Conv(bytes($ , Pos-SizeInit-Sizeof(Head))),
- ?line Size1 = Size+1,
- ?line SizePos = Size+Pos,
+ Pos = 4711,
+ Data = Conv("THE QUICK BROWN FOX JUMPS OVER A LAZY DOG"),
+ Size = Sizeof(Data),
+ Init = Conv(" "),
+ SizeInit = Sizeof(Init),
+ Head = Conv(<<Size:32/big-unsigned, Pos:32/big-unsigned>>),
+ Filler = Conv(bytes($ , Pos-SizeInit-Sizeof(Head))),
+ Size1 = Size+1,
+ SizePos = Size+Pos,
%%
- ?line {ok, FD} = ?FILE_MODULE:open(Name, [write, read | ModeList]),
- ?line ok = ?FILE_MODULE:truncate(FD),
- ?line ok = ?FILE_MODULE:write(FD, Init),
- ?line ok = ?FILE_MODULE:write(FD, Head),
- ?line ok = ?FILE_MODULE:write(FD, Filler),
- ?line ok = ?FILE_MODULE:write(FD, Data),
+ {ok, FD} = ?FILE_MODULE:open(Name, [write, read | ModeList]),
+ ok = ?FILE_MODULE:truncate(FD),
+ ok = ?FILE_MODULE:write(FD, Init),
+ ok = ?FILE_MODULE:write(FD, Head),
+ ok = ?FILE_MODULE:write(FD, Filler),
+ ok = ?FILE_MODULE:write(FD, Data),
%% Correct read
- ?line {ok, {Size, Pos, Data}} =
+ {ok, {Size, Pos, Data}} =
?FILE_MODULE:ipread_s32bu_p32bu(FD, SizeInit, infinity),
%% Invalid header - size > max
- ?line eof =
+ eof =
?FILE_MODULE:ipread_s32bu_p32bu(FD, SizeInit, Size-1),
%% Data block protudes over eof
- ?line ok =
+ ok =
?FILE_MODULE:pwrite(FD, SizeInit,
<<Size1:32/big-unsigned,
- Pos:32/big-unsigned>>),
- ?line {ok, {Size1, Pos, Data}} =
+ Pos:32/big-unsigned>>),
+ {ok, {Size1, Pos, Data}} =
?FILE_MODULE:ipread_s32bu_p32bu(FD, SizeInit, Size1),
%% Data block outside file
- ?line ok =
+ ok =
?FILE_MODULE:pwrite(FD, SizeInit,
<<Size:32/big-unsigned,
- SizePos:32/big-unsigned>>),
- ?line {ok, {Size, SizePos, eof}} =
+ SizePos:32/big-unsigned>>),
+ {ok, {Size, SizePos, eof}} =
?FILE_MODULE:ipread_s32bu_p32bu(FD, SizeInit, Size),
%% Zero size
- ?line ok =
+ ok =
?FILE_MODULE:pwrite(FD, SizeInit,
<<0:32/big-unsigned,
- Pos:32/big-unsigned>>),
- ?line {ok, {0, Pos, eof}} =
+ Pos:32/big-unsigned>>),
+ {ok, {0, Pos, eof}} =
?FILE_MODULE:ipread_s32bu_p32bu(FD, SizeInit, Size),
%% Invalid header - protudes over eof
- ?line eof =
+ eof =
?FILE_MODULE:ipread_s32bu_p32bu(FD,
Pos+Size-(Sizeof(Head)-1),
infinity),
%% Header not even in file
- ?line eof =
+ eof =
?FILE_MODULE:ipread_s32bu_p32bu(FD, Pos+Size, infinity),
%%
- ?line ok = ?FILE_MODULE:close(FD),
+ ok = ?FILE_MODULE:close(FD),
ok.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-interleaved_read_write(suite) ->
- [];
-interleaved_read_write(doc) ->
- ["Tests interleaved read and writes"];
+%% Tests interleaved read and writes.
interleaved_read_write(Config) when is_list(Config) ->
- ?line Dog = ?t:timetrap(?t:seconds(30)),
- %%
- ?line Dir = ?config(priv_dir, Config),
- ?line File =
+ Dir = proplists:get_value(priv_dir, Config),
+ File =
filename:join(Dir, ?MODULE_STRING++"interleaved_read_write.txt"),
- ?line {ok,F1} = ?FILE_MODULE:open(File, [write]),
- ?line ok = ?FILE_MODULE:write(F1, "data---r1."), % 10 chars each
- ?line ok = ?FILE_MODULE:write(F1, "data---r2."),
- ?line ok = ?FILE_MODULE:write(F1, "data---r3."),
- ?line ok = ?FILE_MODULE:close(F1),
- ?line {ok,F2} = ?FILE_MODULE:open(File, [read, write]),
- ?line {ok, "data---r1."} = ?FILE_MODULE:read(F2, 10),
- ?line ok = ?FILE_MODULE:write(F2, "data---w2."),
- ?line ok = ?FILE_MODULE:close(F2),
- ?line {ok,F3} = ?FILE_MODULE:open(File, [read]),
- ?line {ok, "data---r1."} = ?FILE_MODULE:read(F3, 10),
- ?line {ok, "data---w2."} = ?FILE_MODULE:read(F3, 10),
- ?line {ok, "data---r3."} = ?FILE_MODULE:read(F3, 10),
- ?line eof = ?FILE_MODULE:read(F3, 1),
- ?line ok = ?FILE_MODULE:close(F2),
+ {ok,F1} = ?FILE_MODULE:open(File, [write]),
+ ok = ?FILE_MODULE:write(F1, "data---r1."), % 10 chars each
+ ok = ?FILE_MODULE:write(F1, "data---r2."),
+ ok = ?FILE_MODULE:write(F1, "data---r3."),
+ ok = ?FILE_MODULE:close(F1),
+ {ok,F2} = ?FILE_MODULE:open(File, [read, write]),
+ {ok, "data---r1."} = ?FILE_MODULE:read(F2, 10),
+ ok = ?FILE_MODULE:write(F2, "data---w2."),
+ ok = ?FILE_MODULE:close(F2),
+ {ok,F3} = ?FILE_MODULE:open(File, [read]),
+ {ok, "data---r1."} = ?FILE_MODULE:read(F3, 10),
+ {ok, "data---w2."} = ?FILE_MODULE:read(F3, 10),
+ {ok, "data---r3."} = ?FILE_MODULE:read(F3, 10),
+ eof = ?FILE_MODULE:read(F3, 1),
+ ok = ?FILE_MODULE:close(F2),
%%
- ?line [] = flush(),
- ?line ?t:timetrap_cancel(Dog),
+ [] = flush(),
ok.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-otp_5814(suite) ->
- [];
-otp_5814(doc) ->
- ["OTP-5814. eval/consult/script return correct line numbers"];
+%% OTP-5814. eval/consult/script return correct line numbers.
otp_5814(Config) when is_list(Config) ->
- ?line Dog = ?t:timetrap(?t:seconds(10)),
- PrivDir = ?config(priv_dir, Config),
+ PrivDir = proplists:get_value(priv_dir, Config),
File = filename:join(PrivDir, "otp_5814"),
Path = [PrivDir],
- ?line ok = file:write_file(File, <<"{a,b,c}.
+ ok = file:write_file(File, <<"{a,b,c}.
a.
- b.
- c.
- {d,e,
- [}.">>),
- ?line {error, {6,erl_parse,_}} = file:eval(File),
- ?line {error, {6,erl_parse,_}} = file:consult(File),
- ?line {error, {6,erl_parse,_}} = file:path_consult(Path, File),
- ?line {error, {6,erl_parse,_}} = file:path_eval(Path, File),
- ?line {error, {6,erl_parse,_}} = file:script(File),
- ?line {error, {6,erl_parse,_}} = file:path_script(Path, File),
-
- ?line ok = file:write_file(File, <<>>),
- ?line {error, {1,file,undefined_script}} = file:path_script(Path, File),
+b.
+c.
+{d,e,
+ [}.">>),
+ {error, {6,erl_parse,_}} = file:eval(File),
+ {error, {6,erl_parse,_}} = file:consult(File),
+ {error, {6,erl_parse,_}} = file:path_consult(Path, File),
+ {error, {6,erl_parse,_}} = file:path_eval(Path, File),
+ {error, {6,erl_parse,_}} = file:script(File),
+ {error, {6,erl_parse,_}} = file:path_script(Path, File),
+
+ ok = file:write_file(File, <<>>),
+ {error, {1,file,undefined_script}} = file:path_script(Path, File),
%% The error is not propagated...
- ?line ok = file:write_file(File, <<"a.
+ ok = file:write_file(File, <<"a.
b.
- 1/0.">>),
- ?line {error, {3, file, {error, badarith, _}}} = file:eval(File),
-
- ?line ok = file:write_file(File, <<"erlang:raise(throw, apa, []).">>),
- ?line {error, {1, file, {throw, apa, _}}} = file:eval(File),
+1/0.">>),
+ {error, {3, file, {error, badarith, _}}} = file:eval(File),
- file:delete(File),
- ?line ?t:timetrap_cancel(Dog),
- ok.
+ok = file:write_file(File, <<"erlang:raise(throw, apa, []).">>),
+{error, {1, file, {throw, apa, _}}} = file:eval(File),
+
+file:delete(File),
+ok.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-otp_10852(suite) ->
- [];
-otp_10852(doc) ->
- ["OTP-10852. +fnu and latin1 filenames"];
+%% OTP-10852. +fnu and latin1 filenames.
otp_10852(Config) when is_list(Config) ->
Node = start_node(erl_pp_helper, "+fnu"),
- Dir = ?config(priv_dir, Config),
+ Dir = proplists:get_value(priv_dir, Config),
B = filename:join(Dir, <<"\xE4">>),
ok = rpc_call(Node, get_cwd, [B]),
{error, no_translation} = rpc_call(Node, set_cwd, [B]),
@@ -3857,10 +3588,10 @@ otp_10852(Config) when is_list(Config) ->
ok = rpc_call(Node, read_file, [B]),
ok = rpc_call(Node, make_link, [B,B]),
case rpc_call(Node, make_symlink, [B,B]) of
- ok -> ok;
- {error, E} when (E =:= enotsup) or (E =:= eperm) ->
- {win32,_} = os:type()
- end,
+ ok -> ok;
+ {error, E} when (E =:= enotsup) or (E =:= eperm) ->
+ {win32,_} = os:type()
+ end,
ok = rpc_call(Node, delete, [B]),
ok = rpc_call(Node, make_dir, [B]),
ok = rpc_call(Node, del_dir, [B]),
@@ -3883,54 +3614,51 @@ rpc_call(N, F, As) ->
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-large_file(suite) ->
- [];
-large_file(doc) ->
- ["Tests positioning in large files (> 4G)"];
+large_file() ->
+ [{timetrap,{minutes,20}}].
+
+%% Tests positioning in large files (> 4G).
large_file(Config) when is_list(Config) ->
run_large_file_test(Config,
fun(Name) -> do_large_file(Name) end,
"_large_file").
do_large_file(Name) ->
- ?line Watchdog = ?t:timetrap(?t:minutes(20)),
-
- ?line S = "1234567890",
+ S = "1234567890",
L = length(S),
R = lists:reverse(S),
P = 1 bsl 32,
Ss = lists:sort(S),
Rs = lists:reverse(Ss),
- ?line {ok,F} = ?FILE_MODULE:open(Name, [raw,read,write]),
- ?line ok = ?FILE_MODULE:write(F, S),
- ?line {ok,P} = ?FILE_MODULE:position(F, P),
- ?line ok = ?FILE_MODULE:write(F, R),
- ?line {ok,0} = ?FILE_MODULE:position(F, bof),
- ?line {ok,S} = ?FILE_MODULE:read(F, L),
- ?line {ok,P} = ?FILE_MODULE:position(F, {eof,-L}),
- ?line {ok,R} = ?FILE_MODULE:read(F, L+1),
- ?line {ok,S} = ?FILE_MODULE:pread(F, 0, L),
- ?line {ok,R} = ?FILE_MODULE:pread(F, P, L+1),
- ?line ok = ?FILE_MODULE:pwrite(F, 0, Ss),
- ?line ok = ?FILE_MODULE:pwrite(F, P, Rs),
- ?line {ok,0} = ?FILE_MODULE:position(F, bof),
- ?line {ok,Ss} = ?FILE_MODULE:read(F, L),
- ?line {ok,P} = ?FILE_MODULE:position(F, {eof,-L}),
- ?line {ok,Rs} = ?FILE_MODULE:read(F, L+1),
- ?line ok = ?FILE_MODULE:close(F),
+ {ok,F} = ?FILE_MODULE:open(Name, [raw,read,write]),
+ ok = ?FILE_MODULE:write(F, S),
+ {ok,P} = ?FILE_MODULE:position(F, P),
+ ok = ?FILE_MODULE:write(F, R),
+ {ok,0} = ?FILE_MODULE:position(F, bof),
+ {ok,S} = ?FILE_MODULE:read(F, L),
+ {ok,P} = ?FILE_MODULE:position(F, {eof,-L}),
+ {ok,R} = ?FILE_MODULE:read(F, L+1),
+ {ok,S} = ?FILE_MODULE:pread(F, 0, L),
+ {ok,R} = ?FILE_MODULE:pread(F, P, L+1),
+ ok = ?FILE_MODULE:pwrite(F, 0, Ss),
+ ok = ?FILE_MODULE:pwrite(F, P, Rs),
+ {ok,0} = ?FILE_MODULE:position(F, bof),
+ {ok,Ss} = ?FILE_MODULE:read(F, L),
+ {ok,P} = ?FILE_MODULE:position(F, {eof,-L}),
+ {ok,Rs} = ?FILE_MODULE:read(F, L+1),
+ ok = ?FILE_MODULE:close(F),
%% Reopen the file with 'append'; used to fail on Windows causing
%% writes to go to the beginning of the file for files > 4GB.
- ?line PL = P + L,
- ?line PLL = PL + L,
- ?line {ok,F1} = ?FILE_MODULE:open(Name, [raw,read,write,append]),
- ?line ok = ?FILE_MODULE:write(F1, R),
- ?line {ok,PLL} = ?FILE_MODULE:position(F1, {cur,0}),
- ?line {ok,Rs} = ?FILE_MODULE:pread(F1, P, L),
- ?line {ok,PL} = ?FILE_MODULE:position(F1, {eof,-L}),
- ?line {ok,R} = ?FILE_MODULE:read(F1, L+1),
- ?line ok = ?FILE_MODULE:close(F1),
- %%
- ?line ?t:timetrap_cancel(Watchdog),
+ PL = P + L,
+ PLL = PL + L,
+ {ok,F1} = ?FILE_MODULE:open(Name, [raw,read,write,append]),
+ ok = ?FILE_MODULE:write(F1, R),
+ {ok,PLL} = ?FILE_MODULE:position(F1, {cur,0}),
+ {ok,Rs} = ?FILE_MODULE:pread(F1, P, L),
+ {ok,PL} = ?FILE_MODULE:position(F1, {eof,-L}),
+ {ok,R} = ?FILE_MODULE:read(F1, L+1),
+ ok = ?FILE_MODULE:close(F1),
+
ok.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
@@ -3964,8 +3692,8 @@ do_large_write(Name) ->
response_analysis(Module, Function, Arguments) ->
Parent = self(),
- ?line erlang:yield(), % Schedule out before test
- ?line Child =
+ erlang:yield(), % Schedule out before test
+ Child =
spawn_link(
fun () ->
receive {Parent, start, Ts} -> ok end,
@@ -3985,19 +3713,19 @@ response_analysis(Module, Function, Arguments) ->
Parent ! {self(), stopped, response_stat(Stat, micro_ts())}
end),
Child ! {Parent, start, micro_ts()},
- ?line Result = apply(Module, Function, Arguments),
- ?line Child ! {Parent, stop},
- ?line {N, Sum, _, M, Max} = receive {Child, stopped, X} -> X end,
- ?line Mean_ms = (0.001*Sum) / (N-1),
- ?line Max_ms = 0.001 * Max,
- ?line Comment =
+ Result = apply(Module, Function, Arguments),
+ Child ! {Parent, stop},
+ {N, Sum, _, M, Max} = receive {Child, stopped, X} -> X end,
+ Mean_ms = (0.001*Sum) / (N-1),
+ Max_ms = 0.001 * Max,
+ Comment =
lists:flatten(
io_lib:format(
"Scheduling interval: Mean = ~.3f ms, "
++"Max = ~.3f ms for no ~p of ~p.~n",
[Mean_ms, Max_ms, M, (N-1)])),
- ?line {Result, Comment}.
-
+ {Result, Comment}.
+
micro_ts() ->
erlang:monotonic_time(micro_seconds).
@@ -4021,10 +3749,10 @@ response_stat({N, Sum, Ts0, M, Max}, Ts) ->
%% create_file/2 below is some 44 times faster.
create_file_slow(Name, N) when is_integer(N), N >= 0 ->
- ?line {ok, FD} =
+ {ok, FD} =
?FILE_MODULE:open(Name, [raw, write, delayed_write, binary]),
- ?line ok = create_file_slow(FD, 0, N),
- ?line ok = ?FILE_MODULE:close(FD),
+ ok = create_file_slow(FD, 0, N),
+ ok = ?FILE_MODULE:close(FD),
ok.
create_file_slow(_FD, M, M) ->
@@ -4039,10 +3767,10 @@ create_file_slow(FD, M, N) ->
%% from 0 to N-1.
create_file(Name, N) when is_integer(N), N >= 0 ->
- ?line {ok, FD} =
+ {ok, FD} =
?FILE_MODULE:open(Name, [raw, write, delayed_write, binary]),
- ?line ok = create_file(FD, 0, N),
- ?line ok = ?FILE_MODULE:close(FD),
+ ok = create_file(FD, 0, N),
+ ok = ?FILE_MODULE:close(FD),
ok.
create_file(_FD, M, M) ->
@@ -4059,10 +3787,10 @@ create_file(FD, M, N0, R) when M + 8 =< N0 ->
N1 = N0-1, N2 = N0-2, N3 = N0-3, N4 = N0-4,
N5 = N0-5, N6 = N0-6, N7 = N0-7, N8 = N0-8,
create_file(FD, M, N8,
- [<<N8:32/unsigned, N7:32/unsigned,
- N6:32/unsigned, N5:32/unsigned,
- N4:32/unsigned, N3:32/unsigned,
- N2:32/unsigned, N1:32/unsigned>> | R]);
+ [<<N8:32/unsigned, N7:32/unsigned,
+ N6:32/unsigned, N5:32/unsigned,
+ N4:32/unsigned, N3:32/unsigned,
+ N2:32/unsigned, N1:32/unsigned>> | R]);
create_file(FD, M, N0, R) ->
N1 = N0-1,
create_file(FD, M, N1, [<<N1:32/unsigned>> | R]).
@@ -4079,14 +3807,14 @@ create_bin(M, N0, R) when M+8 =< N0 ->
N5 = N0-5, N6 = N0-6, N7 = N0-7, N8 = N0-8,
create_bin(M, N8,
[<<N8:32/unsigned, N7:32/unsigned,
- N6:32/unsigned, N5:32/unsigned,
- N4:32/unsigned, N3:32/unsigned,
- N2:32/unsigned, N1:32/unsigned>> | R]);
+ N6:32/unsigned, N5:32/unsigned,
+ N4:32/unsigned, N3:32/unsigned,
+ N2:32/unsigned, N1:32/unsigned>> | R]);
create_bin(M, N0, R) ->
N1 = N0-1,
create_bin(M, N1, [<<N1:32/unsigned>> | R]).
-
-
+
+
verify_bin(<<>>, _, 0) ->
@@ -4098,8 +3826,8 @@ verify_bin(Bin, N, Cnt) ->
N4 = N + 4, N5 = N + 5, N6 = N + 6, N7 = N + 7,
case Bin of
<<N0:32/unsigned, N1:32/unsigned, N2:32/unsigned, N3:32/unsigned,
- N4:32/unsigned, N5:32/unsigned, N6:32/unsigned, N7:32/unsigned,
- B/binary>> ->
+ N4:32/unsigned, N5:32/unsigned, N6:32/unsigned, N7:32/unsigned,
+ B/binary>> ->
verify_bin(B, N+8, Cnt-8);
<<N:32/unsigned, B/binary>> ->
verify_bin(B, N+1, Cnt-1);
@@ -4180,13 +3908,13 @@ pwrite_file(Name, Data) ->
read_line_testdata(PrivDir) ->
All0 = [{fun read_line_create0/1,"Testdata1.txt",5,10},
- {fun read_line_create1/1,"Testdata2.txt",401,802},
- {fun read_line_create2/1,"Testdata3.txt",1,2},
- {fun read_line_create3/1,"Testdata4.txt",601,fail},
- {fun read_line_create4/1,"Testdata5.txt",601,1002},
- {fun read_line_create5/1,"Testdata6.txt",601,1202},
- {fun read_line_create6/1,"Testdata7.txt",601,1202},
- {fun read_line_create7/1,"Testdata8.txt",4001,8002}],
+ {fun read_line_create1/1,"Testdata2.txt",401,802},
+ {fun read_line_create2/1,"Testdata3.txt",1,2},
+ {fun read_line_create3/1,"Testdata4.txt",601,fail},
+ {fun read_line_create4/1,"Testdata5.txt",601,1002},
+ {fun read_line_create5/1,"Testdata6.txt",601,1202},
+ {fun read_line_create6/1,"Testdata7.txt",601,1202},
+ {fun read_line_create7/1,"Testdata8.txt",4001,8002}],
[ {A,filename:join([PrivDir,B]),C,D} || {A,B,C,D} <- All0 ].
read_line_create_files(TestData) ->
@@ -4195,105 +3923,93 @@ read_line_create_files(TestData) ->
read_line_remove_files(TestData) ->
[ file:delete(File) || {_Function,File,_,_} <- TestData ].
-read_line_1(suite) ->
- [];
-read_line_1(doc) ->
- ["read_line with prim_file"];
+%% read_line with prim_file.
read_line_1(Config) when is_list(Config) ->
- ?line PrivDir = ?config(priv_dir, Config),
- ?line All = read_line_testdata(PrivDir),
- ?line read_line_create_files(All),
- ?line [ begin
- io:format("read_line_all: ~s~n",[File]),
- {X,_} = read_line_all(File),
- true
- end || {_,File,X,_} <- All ],
- ?line [ begin
- io:format("read_line_all_alternating: ~s~n",[File]),
- {Y,_} = read_line_all_alternating(File),
- true
- end || {_,File,_,Y} <- All , Y =/= fail],
- ?line [ begin
- io:format("read_line_all_alternating (failing as should): ~s~n",[File]),
- {'EXIT',_} = (catch read_line_all_alternating(File)),
- true
- end || {_,File,_,Y} <- All , Y =:= fail],
- ?line read_line_remove_files(All),
+ PrivDir = proplists:get_value(priv_dir, Config),
+ All = read_line_testdata(PrivDir),
+ read_line_create_files(All),
+ [ begin
+ io:format("read_line_all: ~s~n",[File]),
+ {X,_} = read_line_all(File),
+ true
+ end || {_,File,X,_} <- All ],
+ [ begin
+ io:format("read_line_all_alternating: ~s~n",[File]),
+ {Y,_} = read_line_all_alternating(File),
+ true
+ end || {_,File,_,Y} <- All , Y =/= fail],
+ [ begin
+ io:format("read_line_all_alternating (failing as should): ~s~n",[File]),
+ {'EXIT',_} = (catch read_line_all_alternating(File)),
+ true
+ end || {_,File,_,Y} <- All , Y =:= fail],
+ read_line_remove_files(All),
ok.
-read_line_2(suite) ->
- [];
-read_line_2(doc) ->
- ["read_line with file"];
+%% read_line with file.
read_line_2(Config) when is_list(Config) ->
- ?line PrivDir = ?config(priv_dir, Config),
- ?line All = read_line_testdata(PrivDir),
- ?line read_line_create_files(All),
- ?line [ begin
- io:format("read_line_all: ~s~n",[File]),
- {X,_} = read_line_all2(File),
- true
- end || {_,File,X,_} <- All ],
- ?line [ begin
- io:format("read_line_all_alternating: ~s~n",[File]),
- {Y,_} = read_line_all_alternating2(File),
- true
- end || {_,File,_,Y} <- All , Y =/= fail],
- ?line [ begin
- io:format("read_line_all_alternating (failing as should): ~s~n",[File]),
- {'EXIT',_} = (catch read_line_all_alternating2(File)),
- true
- end || {_,File,_,Y} <- All , Y =:= fail],
- ?line read_line_remove_files(All),
+ PrivDir = proplists:get_value(priv_dir, Config),
+ All = read_line_testdata(PrivDir),
+ read_line_create_files(All),
+ [ begin
+ io:format("read_line_all: ~s~n",[File]),
+ {X,_} = read_line_all2(File),
+ true
+ end || {_,File,X,_} <- All ],
+ [ begin
+ io:format("read_line_all_alternating: ~s~n",[File]),
+ {Y,_} = read_line_all_alternating2(File),
+ true
+ end || {_,File,_,Y} <- All , Y =/= fail],
+ [ begin
+ io:format("read_line_all_alternating (failing as should): ~s~n",[File]),
+ {'EXIT',_} = (catch read_line_all_alternating2(File)),
+ true
+ end || {_,File,_,Y} <- All , Y =:= fail],
+ read_line_remove_files(All),
ok.
-read_line_3(suite) ->
- [];
-read_line_3(doc) ->
- ["read_line with raw file"];
+%% read_line with raw file.
read_line_3(Config) when is_list(Config) ->
- ?line PrivDir = ?config(priv_dir, Config),
- ?line All = read_line_testdata(PrivDir),
- ?line read_line_create_files(All),
- ?line [ begin
- io:format("read_line_all: ~s~n",[File]),
- {X,_} = read_line_all3(File),
- true
- end || {_,File,X,_} <- All ],
- ?line [ begin
- io:format("read_line_all_alternating: ~s~n",[File]),
- {Y,_} = read_line_all_alternating3(File),
- true
- end || {_,File,_,Y} <- All , Y =/= fail],
- ?line [ begin
- io:format("read_line_all_alternating (failing as should): ~s~n",[File]),
- {'EXIT',_} = (catch read_line_all_alternating3(File)),
- true
- end || {_,File,_,Y} <- All , Y =:= fail],
- ?line read_line_remove_files(All),
+ PrivDir = proplists:get_value(priv_dir, Config),
+ All = read_line_testdata(PrivDir),
+ read_line_create_files(All),
+ [ begin
+ io:format("read_line_all: ~s~n",[File]),
+ {X,_} = read_line_all3(File),
+ true
+ end || {_,File,X,_} <- All ],
+ [ begin
+ io:format("read_line_all_alternating: ~s~n",[File]),
+ {Y,_} = read_line_all_alternating3(File),
+ true
+ end || {_,File,_,Y} <- All , Y =/= fail],
+ [ begin
+ io:format("read_line_all_alternating (failing as should): ~s~n",[File]),
+ {'EXIT',_} = (catch read_line_all_alternating3(File)),
+ true
+ end || {_,File,_,Y} <- All , Y =:= fail],
+ read_line_remove_files(All),
ok.
-read_line_4(suite) ->
- [];
-read_line_4(doc) ->
- ["read_line with raw buffered file"];
+%% read_line with raw buffered file.
read_line_4(Config) when is_list(Config) ->
- ?line PrivDir = ?config(priv_dir, Config),
- ?line All = read_line_testdata(PrivDir),
- ?line read_line_create_files(All),
- ?line [ begin
- io:format("read_line_all: ~s~n",[File]),
- {X,_} = read_line_all4(File),
- true
- end || {_,File,X,_} <- All ],
- ?line [ begin
- io:format("read_line_all_alternating: ~s~n",[File]),
- {Y,_} = read_line_all_alternating4(File),
- true
- end || {_,File,_,Y} <- All , Y =/= fail],
- ?line [ begin
- io:format("read_line_all_alternating (failing as should): ~s~n",[File]),
- {'EXIT',_} = (catch read_line_all_alternating4(File)),
- true
- end || {_,File,_,Y} <- All , Y =:= fail],
- ?line read_line_remove_files(All),
+ PrivDir = proplists:get_value(priv_dir, Config),
+ All = read_line_testdata(PrivDir),
+ read_line_create_files(All),
+ [ begin
+ io:format("read_line_all: ~s~n",[File]),
+ {X,_} = read_line_all4(File),
+ true
+ end || {_,File,X,_} <- All ],
+ [ begin
+ io:format("read_line_all_alternating: ~s~n",[File]),
+ {Y,_} = read_line_all_alternating4(File),
+ true
+ end || {_,File,_,Y} <- All , Y =/= fail],
+ [ begin
+ io:format("read_line_all_alternating (failing as should): ~s~n",[File]),
+ {'EXIT',_} = (catch read_line_all_alternating4(File)),
+ true
+ end || {_,File,_,Y} <- All , Y =:= fail],
+ read_line_remove_files(All),
ok.
rl_lines() ->
@@ -4548,7 +4264,7 @@ run_large_file_test(Config, Run, Name) ->
{{unix,sunos},OsVersion} when OsVersion < {5,5,1} ->
{skip,"Only supported on Win32, Unix or SunOS >= 5.5.1"};
{{unix,_},_} ->
- N = disc_free(?config(priv_dir, Config)),
+ N = disc_free(proplists:get_value(priv_dir, Config)),
io:format("Free disk: ~w KByte~n", [N]),
if N < 5 * (1 bsl 20) ->
%% Less than 5 GByte free
@@ -4562,9 +4278,9 @@ run_large_file_test(Config, Run, Name) ->
do_run_large_file_test(Config, Run, Name0) ->
- Name = filename:join(?config(priv_dir, Config),
+ Name = filename:join(proplists:get_value(priv_dir, Config),
?MODULE_STRING ++ Name0),
-
+
%% Set up a process that will delete this file.
Tester = self(),
Deleter =
@@ -4577,7 +4293,7 @@ do_run_large_file_test(Config, Run, Name0) ->
end,
?FILE_MODULE:delete(Name)
end),
-
+
%% Run the test case.
Res = Run(Name),