aboutsummaryrefslogtreecommitdiffstats
path: root/lib/kernel/test/disk_log_SUITE.erl
diff options
context:
space:
mode:
Diffstat (limited to 'lib/kernel/test/disk_log_SUITE.erl')
-rw-r--r--lib/kernel/test/disk_log_SUITE.erl5954
1 files changed, 2901 insertions, 3053 deletions
diff --git a/lib/kernel/test/disk_log_SUITE.erl b/lib/kernel/test/disk_log_SUITE.erl
index 21da958c11..135144bbe7 100644
--- a/lib/kernel/test/disk_log_SUITE.erl
+++ b/lib/kernel/test/disk_log_SUITE.erl
@@ -19,7 +19,7 @@
%%
-module(disk_log_SUITE).
-%-define(debug, true).
+%%-define(debug, true).
-ifdef(debug).
-define(format(S, A), io:format(S, A)).
@@ -31,8 +31,8 @@
-else.
-include_lib("common_test/include/ct.hrl").
-define(format(S, A), ok).
--define(privdir(Conf), ?config(priv_dir, Conf)).
--define(datadir(Conf), ?config(data_dir, Conf)).
+-define(privdir(Conf), proplists:get_value(priv_dir, Conf)).
+-define(datadir(Conf), proplists:get_value(data_dir, Conf)).
-endif.
-export([all/0, suite/0,groups/0,init_per_suite/1, end_per_suite/1,
@@ -102,8 +102,6 @@
-export([client/4]).
--define(default_timeout, ?t:minutes(1)).
-
%% error_logger
-export([init/1,
handle_event/2, handle_call/2, handle_info/2,
@@ -139,7 +137,9 @@
change_size_after, default_size]).
-suite() -> [{ct_hooks,[ts_install_cth]}].
+suite() ->
+ [{ct_hooks,[ts_install_cth]},
+ {timetrap,{minutes,2}}].
all() ->
[{group, halt_int}, {group, wrap_int},
@@ -194,259 +194,229 @@ end_per_group(_GroupName, Config) ->
-init_per_testcase(Case, Config) ->
- case should_skip(Case,Config) of
- true ->
- CS = check_nfs(Config),
- {skipped, lists:flatten
- (io_lib:format
- ("The test does not work "
- "with current NFS cache size (~w),"
- " to get this test to run, "
- "~s the NFS cache size~n",
- [CS, case CS of
- 0 ->
- "enlarge";
- _ ->
- "zero"
- end]))};
- _ ->
- Dog=?t:timetrap(?t:minutes(2)),
- [{watchdog, Dog}|Config]
- end.
+init_per_testcase(_Case, Config) ->
+ Config.
-end_per_testcase(_Case, Config) ->
- Dog=?config(watchdog, Config),
- test_server:timetrap_cancel(Dog),
+end_per_testcase(_Case, _Config) ->
ok.
-halt_int_inf(suite) -> [];
-halt_int_inf(doc) -> ["Test simple halt disk log, size infinity"];
+%% Test simple halt disk log, size infinity.
halt_int_inf(Conf) when is_list(Conf) ->
Dir = ?privdir(Conf),
- ?line ok = disk_log:start(),
+ ok = disk_log:start(),
File = filename:join(Dir, "a.LOG"),
- ?line {ok, a} = disk_log:open([{name,a}, {type,halt}, {size,infinity},
- {format,internal},
- {file, File}]),
- ?line simple_log(a),
- ?line ok = disk_log:close(a),
- ?line ok = file:delete(File).
+ {ok, a} = disk_log:open([{name,a}, {type,halt}, {size,infinity},
+ {format,internal},
+ {file, File}]),
+ simple_log(a),
+ ok = disk_log:close(a),
+ ok = file:delete(File).
-halt_int_sz_1(suite) -> [];
-halt_int_sz_1(doc) -> ["Test simple halt disk log, size defined"];
+%% Test simple halt disk log, size defined.
halt_int_sz_1(Conf) when is_list(Conf) ->
Dir = ?privdir(Conf),
File = filename:join(Dir, "a.LOG"),
- ?line {ok, a} = disk_log:open([{name,a}, {type,halt}, {size,18000},
- {format,internal},
- {file, File}]),
- ?line simple_log(a),
- ?line ok = disk_log:truncate(a),
- ?line [] = get_all_terms(a),
+ {ok, a} = disk_log:open([{name,a}, {type,halt}, {size,18000},
+ {format,internal},
+ {file, File}]),
+ simple_log(a),
+ ok = disk_log:truncate(a),
+ [] = get_all_terms(a),
T1 = mk_bytes(10000),
T2 = mk_bytes(5000),
- ?line ok = disk_log:log(a, T1),
- ?line case get_all_terms(a) of
- [T1] ->
- ok;
- E1 ->
- test_server_fail({bad_terms, E1, [T1]})
- end,
- ?line ok = disk_log:log(a, T2),
- ?line {error, {full, a}} = disk_log:log(a, T1),
- ?line ok = disk_log:alog(a, T1),
- ?line case get_all_terms(a) of
- [T1, T2] ->
- ok;
- E2 ->
- test_server_fail({bad_terms, E2, [T1, T2]})
- end,
- ?line ok = disk_log:close(a),
- ?line ok = file:delete(File).
+ ok = disk_log:log(a, T1),
+ case get_all_terms(a) of
+ [T1] ->
+ ok;
+ E1 ->
+ test_server_fail({bad_terms, E1, [T1]})
+ end,
+ ok = disk_log:log(a, T2),
+ {error, {full, a}} = disk_log:log(a, T1),
+ ok = disk_log:alog(a, T1),
+ case get_all_terms(a) of
+ [T1, T2] ->
+ ok;
+ E2 ->
+ test_server_fail({bad_terms, E2, [T1, T2]})
+ end,
+ ok = disk_log:close(a),
+ ok = file:delete(File).
-halt_int_sz_2(suite) -> [];
-halt_int_sz_2(doc) -> ["Test simple halt disk log, size ~8192"];
+%% Test simple halt disk log, size ~8192.
halt_int_sz_2(Conf) when is_list(Conf) ->
Dir = ?privdir(Conf),
File1 = filename:join(Dir, "a.LOG"),
File2 = filename:join(Dir, "b.LOG"),
File3 = filename:join(Dir, "c.LOG"),
- ?line {ok, a} = disk_log:open([{name,a}, {type,halt}, {size,8191},
- {format,internal},
- {file, File1}]),
- ?line {ok, b} = disk_log:open([{name,b}, {type,halt}, {size,8192},
- {format,internal},
- {file, File2}]),
- ?line {ok, c} = disk_log:open([{name,c}, {type,halt}, {size,8193},
- {format,internal},
- {file, File3}]),
+ {ok, a} = disk_log:open([{name,a}, {type,halt}, {size,8191},
+ {format,internal},
+ {file, File1}]),
+ {ok, b} = disk_log:open([{name,b}, {type,halt}, {size,8192},
+ {format,internal},
+ {file, File2}]),
+ {ok, c} = disk_log:open([{name,c}, {type,halt}, {size,8193},
+ {format,internal},
+ {file, File3}]),
T1 = mk_bytes(8191-16), % 16 is size of header + magics for 1 item
T2 = mk_bytes(8192-16),
T3 = mk_bytes(8193-16),
- ?line ok = disk_log:log(a, T1),
- ?line ok = disk_log:log(b, T2),
- ?line ok = disk_log:log(c, T3),
- ?line case get_all_terms(a) of
- [T1] ->
- ok;
- E1 ->
- test_server_fail({bad_terms, E1, [T1]})
- end,
- ?line case get_all_terms(b) of
- [T2] ->
- ok;
- E2 ->
- test_server_fail({bad_terms, E2, [T2]})
- end,
- ?line case get_all_terms(c) of
- [T3] ->
- ok;
- E3 ->
- test_server_fail({bad_terms, E3, [T3]})
- end,
- ?line ok = disk_log:truncate(a),
- ?line ok = disk_log:truncate(b),
- ?line {error, {full, a}} = disk_log:log(a, T2),
- ?line {error, {full, b}} = disk_log:log(b, T3),
- ?line [] = get_all_terms(a),
- ?line [] = get_all_terms(b),
- ?line ok = disk_log:close(a),
- ?line ok = disk_log:close(b),
- ?line ok = disk_log:close(c),
- ?line ok = file:delete(File1),
- ?line ok = file:delete(File2),
- ?line ok = file:delete(File3),
+ ok = disk_log:log(a, T1),
+ ok = disk_log:log(b, T2),
+ ok = disk_log:log(c, T3),
+ case get_all_terms(a) of
+ [T1] ->
+ ok;
+ E1 ->
+ test_server_fail({bad_terms, E1, [T1]})
+ end,
+ case get_all_terms(b) of
+ [T2] ->
+ ok;
+ E2 ->
+ test_server_fail({bad_terms, E2, [T2]})
+ end,
+ case get_all_terms(c) of
+ [T3] ->
+ ok;
+ E3 ->
+ test_server_fail({bad_terms, E3, [T3]})
+ end,
+ ok = disk_log:truncate(a),
+ ok = disk_log:truncate(b),
+ {error, {full, a}} = disk_log:log(a, T2),
+ {error, {full, b}} = disk_log:log(b, T3),
+ [] = get_all_terms(a),
+ [] = get_all_terms(b),
+ ok = disk_log:close(a),
+ ok = disk_log:close(b),
+ ok = disk_log:close(c),
+ ok = file:delete(File1),
+ ok = file:delete(File2),
+ ok = file:delete(File3),
ok.
-halt_int_ro(suite) -> [];
-halt_int_ro(doc) -> ["Test simple halt disk log, read only, internal"];
+%% Test simple halt disk log, read only, internal.
halt_int_ro(Conf) when is_list(Conf) ->
Dir = ?privdir(Conf),
File = filename:join(Dir, "a.LOG"),
- ?line {ok, a} = disk_log:open([{name,a}, {type,halt}, {size,infinity},
- {format,internal}, {file, File}]),
+ {ok, a} = disk_log:open([{name,a}, {type,halt}, {size,infinity},
+ {format,internal}, {file, File}]),
simple_log(a),
- ?line ok = disk_log:close(a),
+ ok = disk_log:close(a),
- ?line {ok, a} = disk_log:open([{name,a}, {type,halt}, {size,infinity},
- {format,internal}, {file, File},
- {mode,read_only}]),
+ {ok, a} = disk_log:open([{name,a}, {type,halt}, {size,infinity},
+ {format,internal}, {file, File},
+ {mode,read_only}]),
T1 = "not allowed to write",
- ?line {error, {read_only_mode, a}} = disk_log:log(a, T1),
- ?line ok = disk_log:close(a),
- ?line ok = file:delete(File).
+ {error, {read_only_mode, a}} = disk_log:log(a, T1),
+ ok = disk_log:close(a),
+ ok = file:delete(File).
-halt_ext_ro(suite) -> [];
-halt_ext_ro(doc) -> ["Test simple halt disk log, read only, external"];
+%% Test simple halt disk log, read only, external.
halt_ext_ro(Conf) when is_list(Conf) ->
Dir = ?privdir(Conf),
File = filename:join(Dir, "a.LOG"),
- ?line {ok, a} = disk_log:open([{name,a}, {type,halt}, {size,infinity},
- {format,external}, {file, File}]),
+ {ok, a} = disk_log:open([{name,a}, {type,halt}, {size,infinity},
+ {format,external}, {file, File}]),
xsimple_log(File, a),
- ?line ok = disk_log:close(a),
- ?line {ok, a} = disk_log:open([{name,a}, {type,halt}, {size,infinity},
- {format,external}, {file, File},
- {mode,read_only}]),
+ ok = disk_log:close(a),
+ {ok, a} = disk_log:open([{name,a}, {type,halt}, {size,infinity},
+ {format,external}, {file, File},
+ {mode,read_only}]),
T1 = "not allowed to write",
- ?line {error, {read_only_mode, a}} = disk_log:blog(a, T1),
- ?line ok = disk_log:close(a),
- ?line ok = file:delete(File).
+ {error, {read_only_mode, a}} = disk_log:blog(a, T1),
+ ok = disk_log:close(a),
+ ok = file:delete(File).
-wrap_int_ro(suite) -> [];
-wrap_int_ro(doc) -> ["Test simple wrap disk log, read only, internal"];
+%% Test simple wrap disk log, read only, internal.
wrap_int_ro(Conf) when is_list(Conf) ->
Dir = ?privdir(Conf),
File = filename:join(Dir, "a.LOG"),
- ?line {ok, a} = disk_log:open([{name,a}, {type,wrap}, {size,{8000, 4}},
- {format,internal}, {file, File}]),
+ {ok, a} = disk_log:open([{name,a}, {type,wrap}, {size,{8000, 4}},
+ {format,internal}, {file, File}]),
simple_log(a),
- ?line ok = disk_log:close(a),
- ?line {ok, a} = disk_log:open([{name,a}, {type,wrap}, {size,{8000, 4}},
- {format,internal}, {file, File}, {mode,read_only}]),
+ ok = disk_log:close(a),
+ {ok, a} = disk_log:open([{name,a}, {type,wrap}, {size,{8000, 4}},
+ {format,internal}, {file, File}, {mode,read_only}]),
T1 = "not allowed to write",
- ?line {error, {read_only_mode, a}} = disk_log:log(a, T1),
- ?line ok = disk_log:close(a),
- ?line del(File, 4).
+ {error, {read_only_mode, a}} = disk_log:log(a, T1),
+ ok = disk_log:close(a),
+ del(File, 4).
-wrap_ext_ro(suite) -> [];
-wrap_ext_ro(doc) -> ["Test simple wrap disk log, read only, external"];
+%% Test simple wrap disk log, read only, external.
wrap_ext_ro(Conf) when is_list(Conf) ->
Dir = ?privdir(Conf),
File = filename:join(Dir, "a.LOG"),
- ?line {ok, a} = disk_log:open([{name,a}, {type,wrap}, {size,{8000, 4}},
- {format,external}, {file, File}]),
+ {ok, a} = disk_log:open([{name,a}, {type,wrap}, {size,{8000, 4}},
+ {format,external}, {file, File}]),
x2simple_log(File ++ ".1", a),
- ?line ok = disk_log:close(a),
- ?line {ok, a} = disk_log:open([{name,a}, {type,wrap}, {size,{8000, 4}},
- {format,external}, {file, File},
- {mode,read_only}]),
+ ok = disk_log:close(a),
+ {ok, a} = disk_log:open([{name,a}, {type,wrap}, {size,{8000, 4}},
+ {format,external}, {file, File},
+ {mode,read_only}]),
T1 = "not allowed to write",
- ?line {error, {read_only_mode, a}} = disk_log:blog(a, T1),
- ?line {error, {read_only_mode, a}} = disk_log:inc_wrap_file(a),
- ?line ok = disk_log:close(a),
+ {error, {read_only_mode, a}} = disk_log:blog(a, T1),
+ {error, {read_only_mode, a}} = disk_log:inc_wrap_file(a),
+ ok = disk_log:close(a),
del(File, 4).
-halt_trunc(suite) -> [];
-halt_trunc(doc) -> ["Test truncation of halt disk log"];
+%% Test truncation of halt disk log.
halt_trunc(Conf) when is_list(Conf) ->
Dir = ?privdir(Conf),
File = filename:join(Dir, "a.LOG"),
- ?line {ok, a} = disk_log:open([{name,a}, {type,halt}, {size,infinity},
- {format,internal}, {file, File}]),
+ {ok, a} = disk_log:open([{name,a}, {type,halt}, {size,infinity},
+ {format,internal}, {file, File}]),
simple_log(a),
- ?line ok = disk_log:close(a),
- ?line {error,{badarg,repair_read_only}} =
+ ok = disk_log:close(a),
+ {error,{badarg,repair_read_only}} =
disk_log:open([{name,a}, {type,halt}, {size,infinity},
{repair, truncate}, {format,internal},
{file, File}, {mode,read_only}]),
- ?line ok = file:delete(File).
+ ok = file:delete(File).
-halt_misc(suite) -> [];
-halt_misc(doc) -> ["Test truncation of halt disk log"];
+%% Test truncation of halt disk log.
halt_misc(Conf) when is_list(Conf) ->
Dir = ?privdir(Conf),
File = filename:join(Dir, "a.LOG"),
- ?line {ok, a} = disk_log:open([{name,a}, {type,halt}, {size,infinity},
- {format,internal}, {file, File}]),
+ {ok, a} = disk_log:open([{name,a}, {type,halt}, {size,infinity},
+ {format,internal}, {file, File}]),
simple_log(a),
- ?line ok = disk_log:close(a),
- ?line {ok, a} = disk_log:open([{name,a}, {type,halt}, {size,infinity},
- {format,internal}, {file, File},
- {mode,read_only}]),
+ ok = disk_log:close(a),
+ {ok, a} = disk_log:open([{name,a}, {type,halt}, {size,infinity},
+ {format,internal}, {file, File},
+ {mode,read_only}]),
T1 = "not allowed to write",
- ?line {error, {read_only_mode, a}} = disk_log:log(a, T1),
- ?line {error, {read_only_mode, a}} = disk_log:sync(a),
- ?line {error, {read_only_mode, a}} = disk_log:reopen(a, "b.LOG"),
- ?line {error, {read_only_mode, a}} =
+ {error, {read_only_mode, a}} = disk_log:log(a, T1),
+ {error, {read_only_mode, a}} = disk_log:sync(a),
+ {error, {read_only_mode, a}} = disk_log:reopen(a, "b.LOG"),
+ {error, {read_only_mode, a}} =
disk_log:change_header(a, {head,header}),
- ?line {error, {read_only_mode, a}} =
+ {error, {read_only_mode, a}} =
disk_log:change_size(a, infinity),
- ?line ok = disk_log:close(a),
- ?line ok = file:delete(File).
+ ok = disk_log:close(a),
+ ok = file:delete(File).
-halt_ro_alog(suite) -> [];
-halt_ro_alog(doc) -> ["Test truncation of halt disk log, read only"];
+%% Test truncation of halt disk log, read only.
halt_ro_alog(Conf) when is_list(Conf) ->
Dir = ?privdir(Conf),
File = filename:join(Dir, "a.LOG"),
- ?line {ok, a} = disk_log:open([{name,a}, {type,halt}, {size,infinity},
- {format,internal}, {file, File}]),
+ {ok, a} = disk_log:open([{name,a}, {type,halt}, {size,infinity},
+ {format,internal}, {file, File}]),
simple_log(a),
- ?line ok = disk_log:close(a),
- ?line {ok, a} = disk_log:open([{name,a}, {type,halt}, {size,infinity},
- {notify,true}, {format,internal},
- {file, File}, {mode,read_only}]),
+ ok = disk_log:close(a),
+ {ok, a} = disk_log:open([{name,a}, {type,halt}, {size,infinity},
+ {notify,true}, {format,internal},
+ {file, File}, {mode,read_only}]),
T1 = "not allowed to write",
- ?line ok = disk_log:alog(a, T1),
- ?line ok = halt_ro_alog_wait_notify(a, T1),
- ?line ok = disk_log:close(a),
- ?line ok = file:delete(File).
+ ok = disk_log:alog(a, T1),
+ ok = halt_ro_alog_wait_notify(a, T1),
+ ok = disk_log:close(a),
+ ok = file:delete(File).
halt_ro_alog_wait_notify(Log, T) ->
Term = term_to_binary(T),
@@ -459,23 +429,22 @@ halt_ro_alog_wait_notify(Log, T) ->
failed
end.
-halt_ro_balog(suite) -> [];
-halt_ro_balog(doc) -> ["Test truncation of halt disk log, read only"];
+%% Test truncation of halt disk log, read only.
halt_ro_balog(Conf) when is_list(Conf) ->
Dir = ?privdir(Conf),
File = filename:join(Dir, "a.LOG"),
- ?line {ok, a} = disk_log:open([{name,a}, {type,halt}, {size,infinity},
- {format,internal}, {file, File}]),
+ {ok, a} = disk_log:open([{name,a}, {type,halt}, {size,infinity},
+ {format,internal}, {file, File}]),
simple_log(a),
- ?line ok = disk_log:close(a),
- ?line {ok, a} = disk_log:open([{name,a}, {type,halt}, {size,infinity},
- {notify,true}, {format,external},
- {file, File}, {mode,read_only}]),
+ ok = disk_log:close(a),
+ {ok, a} = disk_log:open([{name,a}, {type,halt}, {size,infinity},
+ {notify,true}, {format,external},
+ {file, File}, {mode,read_only}]),
T1 = "not allowed to write",
- ?line ok = disk_log:balog(a, T1),
- ?line ok = halt_ro_balog_wait_notify(a, T1),
- ?line ok = disk_log:close(a),
- ?line ok = file:delete(File).
+ ok = disk_log:balog(a, T1),
+ ok = halt_ro_balog_wait_notify(a, T1),
+ ok = disk_log:close(a),
+ ok = file:delete(File).
halt_ro_balog_wait_notify(Log, T) ->
Term = list_to_binary(T),
@@ -488,127 +457,123 @@ halt_ro_balog_wait_notify(Log, T) ->
failed
end.
-halt_ro_crash(suite) -> [];
-halt_ro_crash(doc) -> ["Test truncation of halt disk log, read only, repair"];
+%% Test truncation of halt disk log, read only, repair.
halt_ro_crash(Conf) when is_list(Conf) ->
Dir = ?privdir(Conf),
File = filename:join(Dir, "a.LOG"),
- ?line file:delete(File),
- ?line {ok, a} = disk_log:open([{name,a}, {type,halt}, {size,infinity},
- {format,internal},{file, File}]),
+ file:delete(File),
+ {ok, a} = disk_log:open([{name,a}, {type,halt}, {size,infinity},
+ {format,internal},{file, File}]),
simple_log(a),
- ?line ok = disk_log:close(a),
+ ok = disk_log:close(a),
crash(File, 10),
- ?line {ok, a} = disk_log:open([{name,a}, {type,halt}, {size,infinity},
- {notify,true}, {format,internal},
- {file, File}, {mode,read_only}]),
+ {ok, a} = disk_log:open([{name,a}, {type,halt}, {size,infinity},
+ {notify,true}, {format,internal},
+ {file, File}, {mode,read_only}]),
- ?line Error1 = {error, {read_only_mode, a}} = disk_log:truncate(a),
- ?line "The disk log" ++ _ = format_error(Error1),
+ Error1 = {error, {read_only_mode, a}} = disk_log:truncate(a),
+ "The disk log" ++ _ = format_error(Error1),
%% crash/1 sets the length of the first item to something big (2.5 kb).
%% In R6B, binary_to_term accepts garbage at the end of the binary,
%% which means that the first item is recognized!
%% This is how it was before R6B:
- %% ?line {C1,T1,15} = disk_log:chunk(a,start),
- %% ?line {C2,T2} = disk_log:chunk(a,C1),
+ %% {C1,T1,15} = disk_log:chunk(a,start),
+ %% {C2,T2} = disk_log:chunk(a,C1),
{C1,_OneItem,7478} = disk_log:chunk(a,start),
{C2, [], 7} = disk_log:chunk(a,C1),
- ?line eof = disk_log:chunk(a,C2),
- ?line ok = disk_log:close(a),
- ?line ok = file:delete(File).
+ eof = disk_log:chunk(a,C2),
+ ok = disk_log:close(a),
+ ok = file:delete(File).
-wrap_int_1(suite) -> [];
-wrap_int_1(doc) -> ["Test wrap disk log, internal"];
+%% Test wrap disk log, internal.
wrap_int_1(Conf) when is_list(Conf) ->
Dir = ?privdir(Conf),
File = filename:join(Dir, "a.LOG"),
- ?line {ok, a} = disk_log:open([{name,a}, {type,wrap}, {size,{8000, 4}},
- {format,internal},
- {file, File}]),
- ?line [_] =
+ {ok, a} = disk_log:open([{name,a}, {type,wrap}, {size,{8000, 4}},
+ {format,internal},
+ {file, File}]),
+ [_] =
lists:filter(fun(P) -> disk_log:pid2name(P) =/= undefined end,
erlang:processes()),
simple_log(a),
- ?line ok = disk_log:close(a),
+ ok = disk_log:close(a),
del(File, 4),
- ?line {ok, a} = disk_log:open([{name,a}, {type,wrap}, {size,{8000, 4}},
- {format,internal},
- {file, File}]),
- ?line [] = get_all_terms(a),
+ {ok, a} = disk_log:open([{name,a}, {type,wrap}, {size,{8000, 4}},
+ {format,internal},
+ {file, File}]),
+ [] = get_all_terms(a),
T1 = mk_bytes(10000), % file 2
T2 = mk_bytes(5000), % file 3
T3 = mk_bytes(4000), % file 4
T4 = mk_bytes(2000), % file 4
T5 = mk_bytes(5000), % file 1
T6 = mk_bytes(5000), % file 2
- ?line ok = disk_log:log(a, T1),
- ?line ok = disk_log:log(a, T2),
- ?line ok = disk_log:log(a, T3),
- ?line ok = disk_log:log_terms(a, [T4, T5, T6]),
- ?line case get_all_terms(a) of
- [T2,T3,T4,T5,T6] ->
- ok;
- E1 ->
- test_server_fail({bad_terms, E1, [T2,T3,T4,T5,T6]})
- end,
- ?line ok = disk_log:close(a),
+ ok = disk_log:log(a, T1),
+ ok = disk_log:log(a, T2),
+ ok = disk_log:log(a, T3),
+ ok = disk_log:log_terms(a, [T4, T5, T6]),
+ case get_all_terms(a) of
+ [T2,T3,T4,T5,T6] ->
+ ok;
+ E1 ->
+ test_server_fail({bad_terms, E1, [T2,T3,T4,T5,T6]})
+ end,
+ ok = disk_log:close(a),
del(File, 4).
-wrap_int_2(suite) -> [];
-wrap_int_2(doc) -> ["Test wrap disk log, internal"];
+%% Test wrap disk log, internal.
wrap_int_2(Conf) when is_list(Conf) ->
Dir = ?privdir(Conf),
File1 = filename:join(Dir, "a.LOG"),
File2 = filename:join(Dir, "b.LOG"),
File3 = filename:join(Dir, "c.LOG"),
- ?line {ok, a} = disk_log:open([{name,a}, {type,wrap}, {size,{8191,3}},
- {format,internal},
- {file, File1}]),
- ?line {ok, b} = disk_log:open([{name,b}, {type,wrap}, {size,{8192,3}},
- {format,internal},
- {file, File2}]),
- ?line {ok, c} = disk_log:open([{name,c}, {type,wrap}, {size,{8193,3}},
- {format,internal},
- {file, File3}]),
+ {ok, a} = disk_log:open([{name,a}, {type,wrap}, {size,{8191,3}},
+ {format,internal},
+ {file, File1}]),
+ {ok, b} = disk_log:open([{name,b}, {type,wrap}, {size,{8192,3}},
+ {format,internal},
+ {file, File2}]),
+ {ok, c} = disk_log:open([{name,c}, {type,wrap}, {size,{8193,3}},
+ {format,internal},
+ {file, File3}]),
T1 = mk_bytes(8191-16), % 16 is size of header + magics for 1 item
T2 = mk_bytes(8192-16),
T3 = mk_bytes(8193-16),
- ?line ok = disk_log:log(a, T1),
- ?line ok = disk_log:log(b, T2),
- ?line ok = disk_log:log(c, T3),
- ?line case get_all_terms(a) of
- [T1] ->
- ok;
- E1 ->
- test_server_fail({bad_terms, E1, [T1]})
- end,
- ?line case get_all_terms(b) of
- [T2] ->
- ok;
- E2 ->
- test_server_fail({bad_terms, E2, [T2]})
- end,
- ?line case get_all_terms(c) of
- [T3] ->
- ok;
- E3 ->
- test_server_fail({bad_terms, E3, [T3]})
- end,
- ?line ok = disk_log:close(a),
- ?line ok = disk_log:close(b),
- ?line ok = disk_log:close(c),
+ ok = disk_log:log(a, T1),
+ ok = disk_log:log(b, T2),
+ ok = disk_log:log(c, T3),
+ case get_all_terms(a) of
+ [T1] ->
+ ok;
+ E1 ->
+ test_server_fail({bad_terms, E1, [T1]})
+ end,
+ case get_all_terms(b) of
+ [T2] ->
+ ok;
+ E2 ->
+ test_server_fail({bad_terms, E2, [T2]})
+ end,
+ case get_all_terms(c) of
+ [T3] ->
+ ok;
+ E3 ->
+ test_server_fail({bad_terms, E3, [T3]})
+ end,
+ ok = disk_log:close(a),
+ ok = disk_log:close(b),
+ ok = disk_log:close(c),
del(File1, 3),
del(File2, 3),
del(File3, 3).
-inc_wrap_file(suite) -> [];
-inc_wrap_file(doc) -> ["Test disk log, force a change to next file"];
+%% Test disk log, force a change to next file.
inc_wrap_file(Conf) when is_list(Conf) ->
Dir = ?privdir(Conf),
File1 = filename:join(Dir, "a.LOG"),
@@ -616,262 +581,257 @@ inc_wrap_file(Conf) when is_list(Conf) ->
File3 = filename:join(Dir, "c.LOG"),
%% Test that halt logs gets an error message
- ?line {ok, a} = disk_log:open([{name, a}, {type, halt},
- {format, internal},
- {file, File1}]),
- ?line ok = disk_log:log(a, "message one"),
- ?line {error, {halt_log, a}} = disk_log:inc_wrap_file(a),
+ {ok, a} = disk_log:open([{name, a}, {type, halt},
+ {format, internal},
+ {file, File1}]),
+ ok = disk_log:log(a, "message one"),
+ {error, {halt_log, a}} = disk_log:inc_wrap_file(a),
%% test an internally formatted wrap log file
- ?line {ok, b} = disk_log:open([{name, b}, {type, wrap}, {size, {100,3}},
- {format, internal}, {head, 'thisisahead'},
- {file, File2}]),
- ?line ok = disk_log:log(b, "message one"),
- ?line ok = disk_log:inc_wrap_file(b),
- ?line ok = disk_log:log(b, "message two"),
- ?line ok = disk_log:inc_wrap_file(b),
- ?line ok = disk_log:log(b, "message three"),
- ?line ok = disk_log:inc_wrap_file(b),
- ?line ok = disk_log:log(b, "message four"),
- ?line T1 = get_all_terms(b),
- ?line ['thisisahead', "message two",
- 'thisisahead', "message three",
- 'thisisahead', "message four"] = T1,
+ {ok, b} = disk_log:open([{name, b}, {type, wrap}, {size, {100,3}},
+ {format, internal}, {head, 'thisisahead'},
+ {file, File2}]),
+ ok = disk_log:log(b, "message one"),
+ ok = disk_log:inc_wrap_file(b),
+ ok = disk_log:log(b, "message two"),
+ ok = disk_log:inc_wrap_file(b),
+ ok = disk_log:log(b, "message three"),
+ ok = disk_log:inc_wrap_file(b),
+ ok = disk_log:log(b, "message four"),
+ T1 = get_all_terms(b),
+ ['thisisahead', "message two",
+ 'thisisahead', "message three",
+ 'thisisahead', "message four"] = T1,
%% test an externally formatted wrap log file
- ?line {ok, c} = disk_log:open([{name, c}, {type, wrap}, {size, {100,3}},
- {format,external}, {head,"this is a head "},
- {file, File3}]),
- ?line ok = disk_log:blog(c, "message one"),
- ?line ok = disk_log:inc_wrap_file(c),
- ?line ok = disk_log:blog(c, "message two"),
- ?line ok = disk_log:inc_wrap_file(c),
- ?line ok = disk_log:blog(c, "message three"),
- ?line ok = disk_log:inc_wrap_file(c),
- ?line ok = disk_log:blog(c, "message four"),
- ?line ok = disk_log:sync(c),
- ?line {ok, Fd31} = file:open(File3 ++ ".1", [read]),
- ?line {ok,"this is a head message four"} = file:read(Fd31, 200),
- ?line {ok, Fd32} = file:open(File3 ++ ".2", [read]),
- ?line {ok,"this is a head message two"} = file:read(Fd32, 200),
- ?line {ok, Fd33} = file:open(File3 ++ ".3", [read]),
- ?line {ok,"this is a head message three"} = file:read(Fd33, 200),
- ?line ok = file:close(Fd31),
- ?line ok = file:close(Fd32),
- ?line ok = file:close(Fd33),
-
- ?line ok = disk_log:close(a),
- ?line ok = disk_log:close(b),
- ?line ok = disk_log:close(c),
- ?line ok = file:delete(File1),
+ {ok, c} = disk_log:open([{name, c}, {type, wrap}, {size, {100,3}},
+ {format,external}, {head,"this is a head "},
+ {file, File3}]),
+ ok = disk_log:blog(c, "message one"),
+ ok = disk_log:inc_wrap_file(c),
+ ok = disk_log:blog(c, "message two"),
+ ok = disk_log:inc_wrap_file(c),
+ ok = disk_log:blog(c, "message three"),
+ ok = disk_log:inc_wrap_file(c),
+ ok = disk_log:blog(c, "message four"),
+ ok = disk_log:sync(c),
+ {ok, Fd31} = file:open(File3 ++ ".1", [read]),
+ {ok,"this is a head message four"} = file:read(Fd31, 200),
+ {ok, Fd32} = file:open(File3 ++ ".2", [read]),
+ {ok,"this is a head message two"} = file:read(Fd32, 200),
+ {ok, Fd33} = file:open(File3 ++ ".3", [read]),
+ {ok,"this is a head message three"} = file:read(Fd33, 200),
+ ok = file:close(Fd31),
+ ok = file:close(Fd32),
+ ok = file:close(Fd33),
+
+ ok = disk_log:close(a),
+ ok = disk_log:close(b),
+ ok = disk_log:close(c),
+ ok = file:delete(File1),
del(File2, 3),
del(File3, 3).
-halt_ext_inf(suite) -> [];
-halt_ext_inf(doc) -> ["Test halt disk log, external, infinity"];
+%% Test halt disk log, external, infinity.
halt_ext_inf(Conf) when is_list(Conf) ->
Dir = ?privdir(Conf),
File = filename:join(Dir, "a.LOG"),
- ?line {ok, a} = disk_log:open([{name,a}, {type,halt}, {size,infinity},
- {format,external},
- {file, File}]),
- ?line xsimple_log(File, a),
- ?line ok = disk_log:close(a),
- ?line ok = file:delete(File).
+ {ok, a} = disk_log:open([{name,a}, {type,halt}, {size,infinity},
+ {format,external},
+ {file, File}]),
+ xsimple_log(File, a),
+ ok = disk_log:close(a),
+ ok = file:delete(File).
-halt_ext_sz_1(suite) -> [];
-halt_ext_sz_1(doc) -> ["Test halt disk log, external, size defined"];
+%% Test halt disk log, external, size defined.
halt_ext_sz_1(Conf) when is_list(Conf) ->
Dir = ?privdir(Conf),
File = filename:join(Dir, "a.LOG"),
- ?line {ok, a} = disk_log:open([{name,a}, {type,halt}, {size,18000},
- {format,external},
- {file, File}]),
+ {ok, a} = disk_log:open([{name,a}, {type,halt}, {size,18000},
+ {format,external},
+ {file, File}]),
xsimple_log(File, a),
- ?line ok = disk_log:truncate(a),
- ?line [] = get_list(File, a),
+ ok = disk_log:truncate(a),
+ [] = get_list(File, a),
{B1, T1} = x_mk_bytes(10000),
{B2, T2} = x_mk_bytes(5000),
{B3, T3} = x_mk_bytes(1000),
- ?line ok = disk_log:blog(a, B1),
- ?line case get_list(File, a) of
- T1 ->
- ok;
- E1 ->
- test_server_fail({bad_terms, E1, T1})
- end,
- ?line ok = disk_log:blog(a, B2),
- ?line {error, {full, a}} = disk_log:blog_terms(a, [B3,B3,B1]),
- ?line ok = disk_log:balog(a, B1),
- ?line Tmp = T1 ++ T2 ++ T3 ++ T3,
- ?line case get_list(File, a) of
- Tmp ->
- ok;
- E2 ->
- test_server_fail({bad_terms, E2, Tmp})
- end,
- ?line ok = disk_log:close(a),
- ?line ok = file:delete(File).
+ ok = disk_log:blog(a, B1),
+ case get_list(File, a) of
+ T1 ->
+ ok;
+ E1 ->
+ test_server_fail({bad_terms, E1, T1})
+ end,
+ ok = disk_log:blog(a, B2),
+ {error, {full, a}} = disk_log:blog_terms(a, [B3,B3,B1]),
+ ok = disk_log:balog(a, B1),
+ Tmp = T1 ++ T2 ++ T3 ++ T3,
+ case get_list(File, a) of
+ Tmp ->
+ ok;
+ E2 ->
+ test_server_fail({bad_terms, E2, Tmp})
+ end,
+ ok = disk_log:close(a),
+ ok = file:delete(File).
-halt_ext_sz_2(suite) -> [];
-halt_ext_sz_2(doc) -> ["Test halt disk log, external, size defined"];
+%% Test halt disk log, external, size defined.
halt_ext_sz_2(Conf) when is_list(Conf) ->
Dir = ?privdir(Conf),
File1 = filename:join(Dir, "a.LOG"),
File2 = filename:join(Dir, "b.LOG"),
File3 = filename:join(Dir, "c.LOG"),
- ?line {ok, a} = disk_log:open([{name,a}, {type,halt}, {size,8191},
- {format,external},
- {file, File1}]),
- ?line {ok, b} = disk_log:open([{name,b}, {type,halt}, {size,8192},
- {format,external},
- {file, File2}]),
- ?line {ok, c} = disk_log:open([{name,c}, {type,halt}, {size,8193},
- {format,external},
- {file, File3}]),
+ {ok, a} = disk_log:open([{name,a}, {type,halt}, {size,8191},
+ {format,external},
+ {file, File1}]),
+ {ok, b} = disk_log:open([{name,b}, {type,halt}, {size,8192},
+ {format,external},
+ {file, File2}]),
+ {ok, c} = disk_log:open([{name,c}, {type,halt}, {size,8193},
+ {format,external},
+ {file, File3}]),
{B1, T1} = x_mk_bytes(8191),
{B2, T2} = x_mk_bytes(8192),
{B3, T3} = x_mk_bytes(8193),
- ?line ok = disk_log:blog(a, B1),
- ?line ok = disk_log:blog(b, B2),
- ?line ok = disk_log:blog(c, B3),
- ?line case get_list(File1, a) of
- T1 ->
- ok;
- E1 ->
- test_server_fail({bad_terms, E1, T1})
- end,
- ?line case get_list(File2, b) of
- T2 ->
- ok;
- E2 ->
- test_server_fail({bad_terms, E2, T2})
- end,
- ?line case get_list(File3, c) of
- T3 ->
- ok;
- E3 ->
- test_server_fail({bad_terms, E3, T3})
- end,
- ?line ok = disk_log:truncate(a),
- ?line ok = disk_log:truncate(b),
- ?line {error, {full, a}} = disk_log:blog(a, B2),
- ?line Error1 = {error, {full, b}} = disk_log:blog(b, B3),
- ?line "The halt log" ++ _ = format_error(Error1),
- ?line true = info(b, full, false),
- ?line [] = get_list(File1, a),
- ?line [] = get_list(File2, b),
- ?line ok = disk_log:close(a),
- ?line ok = disk_log:close(b),
- ?line ok = disk_log:close(c),
- ?line ok = file:delete(File1),
- ?line ok = file:delete(File2),
- ?line ok = file:delete(File3),
+ ok = disk_log:blog(a, B1),
+ ok = disk_log:blog(b, B2),
+ ok = disk_log:blog(c, B3),
+ case get_list(File1, a) of
+ T1 ->
+ ok;
+ E1 ->
+ test_server_fail({bad_terms, E1, T1})
+ end,
+ case get_list(File2, b) of
+ T2 ->
+ ok;
+ E2 ->
+ test_server_fail({bad_terms, E2, T2})
+ end,
+ case get_list(File3, c) of
+ T3 ->
+ ok;
+ E3 ->
+ test_server_fail({bad_terms, E3, T3})
+ end,
+ ok = disk_log:truncate(a),
+ ok = disk_log:truncate(b),
+ {error, {full, a}} = disk_log:blog(a, B2),
+ Error1 = {error, {full, b}} = disk_log:blog(b, B3),
+ "The halt log" ++ _ = format_error(Error1),
+ true = info(b, full, false),
+ [] = get_list(File1, a),
+ [] = get_list(File2, b),
+ ok = disk_log:close(a),
+ ok = disk_log:close(b),
+ ok = disk_log:close(c),
+ ok = file:delete(File1),
+ ok = file:delete(File2),
+ ok = file:delete(File3),
ok.
-wrap_ext_1(suite) -> [];
-wrap_ext_1(doc) -> ["Test wrap disk log, external, size defined"];
+%% Test wrap disk log, external, size defined.
wrap_ext_1(Conf) when is_list(Conf) ->
Dir = ?privdir(Conf),
File = filename:join(Dir, "a.LOG"),
- ?line {ok, a} = disk_log:open([{name,a}, {type,wrap}, {size,{8000, 4}},
- {format,external},
- {file, File}]),
+ {ok, a} = disk_log:open([{name,a}, {type,wrap}, {size,{8000, 4}},
+ {format,external},
+ {file, File}]),
x2simple_log(File ++ ".1", a),
- ?line ok = disk_log:close(a),
-% del(File, 4),
- ?line {ok, a} = disk_log:open([{name,a}, {type,wrap}, {size,{8000, 4}},
- {format,external},
- {file, File}]),
+ ok = disk_log:close(a),
+ %% del(File, 4),
+ {ok, a} = disk_log:open([{name,a}, {type,wrap}, {size,{8000, 4}},
+ {format,external},
+ {file, File}]),
{B1, _T1} = x_mk_bytes(10000), % file 2
{B2, T2} = x_mk_bytes(5000), % file 3
{B3, T3} = x_mk_bytes(4000), % file 4
{B4, T4} = x_mk_bytes(2000), % file 4
{B5, T5} = x_mk_bytes(5000), % file 1
{B6, T6} = x_mk_bytes(5000), % file 2
- ?line ok = disk_log:blog(a, B1),
- ?line ok = disk_log:blog(a, B2),
- ?line ok = disk_log:blog(a, B3),
- ?line ok = disk_log:blog_terms(a, [B4, B5, B6]),
- ?line case get_list(File ++ ".3", a) of
- T2 ->
- ok;
- E2 ->
- test_server_fail({bad_terms, E2, T2})
- end,
- ?line T34 = T3 ++ T4,
- ?line case get_list(File ++ ".4", a) of
- T34 ->
- ok;
- E34 ->
- test_server_fail({bad_terms, E34, T34})
- end,
- ?line case get_list(File ++ ".1", a) of
- T5 ->
- ok;
- E5 ->
- test_server_fail({bad_terms, E5, T5})
- end,
- ?line case get_list(File ++ ".2", a) of
- T6 ->
- ok;
- E6 ->
- test_server_fail({bad_terms, E6, T6})
- end,
- ?line ok = disk_log:close(a),
+ ok = disk_log:blog(a, B1),
+ ok = disk_log:blog(a, B2),
+ ok = disk_log:blog(a, B3),
+ ok = disk_log:blog_terms(a, [B4, B5, B6]),
+ case get_list(File ++ ".3", a) of
+ T2 ->
+ ok;
+ E2 ->
+ test_server_fail({bad_terms, E2, T2})
+ end,
+ T34 = T3 ++ T4,
+ case get_list(File ++ ".4", a) of
+ T34 ->
+ ok;
+ E34 ->
+ test_server_fail({bad_terms, E34, T34})
+ end,
+ case get_list(File ++ ".1", a) of
+ T5 ->
+ ok;
+ E5 ->
+ test_server_fail({bad_terms, E5, T5})
+ end,
+ case get_list(File ++ ".2", a) of
+ T6 ->
+ ok;
+ E6 ->
+ test_server_fail({bad_terms, E6, T6})
+ end,
+ ok = disk_log:close(a),
del(File, 4).
-wrap_ext_2(suite) -> [];
-wrap_ext_2(doc) -> ["Test wrap disk log, external, size defined"];
+%% Test wrap disk log, external, size defined.
wrap_ext_2(Conf) when is_list(Conf) ->
Dir = ?privdir(Conf),
File1 = filename:join(Dir, "a.LOG"),
File2 = filename:join(Dir, "b.LOG"),
File3 = filename:join(Dir, "c.LOG"),
- ?line {ok, a} = disk_log:open([{name,a}, {type,wrap}, {size,{8191,3}},
- {format,external},
- {file, File1}]),
- ?line {ok, b} = disk_log:open([{name,b}, {type,wrap}, {size,{8192,3}},
- {format,external},
- {file, File2}]),
- ?line {ok, c} = disk_log:open([{name,c}, {type,wrap}, {size,{8193,3}},
- {format,external},
- {file, File3}]),
+ {ok, a} = disk_log:open([{name,a}, {type,wrap}, {size,{8191,3}},
+ {format,external},
+ {file, File1}]),
+ {ok, b} = disk_log:open([{name,b}, {type,wrap}, {size,{8192,3}},
+ {format,external},
+ {file, File2}]),
+ {ok, c} = disk_log:open([{name,c}, {type,wrap}, {size,{8193,3}},
+ {format,external},
+ {file, File3}]),
{B1, T1} = x_mk_bytes(8191),
{B2, T2} = x_mk_bytes(8192),
{B3, T3} = x_mk_bytes(8193),
- ?line ok = disk_log:blog(a, B1),
- ?line ok = disk_log:blog(b, B2),
- ?line ok = disk_log:blog(c, B3),
- ?line case get_list(File1 ++ ".1", a) of
- T1 ->
- ok;
- E1 ->
- test_server_fail({bad_terms, E1, T1})
- end,
- ?line case get_list(File2 ++ ".1", b) of
- T2 ->
- ok;
- E2 ->
- test_server_fail({bad_terms, E2, T2})
- end,
- ?line case get_list(File3 ++ ".1", c) of
- T3 ->
- ok;
- E3 ->
- test_server_fail({bad_terms, E3, T3})
- end,
- ?line ok = disk_log:close(a),
- ?line ok = disk_log:close(b),
- ?line ok = disk_log:close(c),
- ?line del(File1, 3),
- ?line del(File2, 3),
- ?line del(File3, 3),
+ ok = disk_log:blog(a, B1),
+ ok = disk_log:blog(b, B2),
+ ok = disk_log:blog(c, B3),
+ case get_list(File1 ++ ".1", a) of
+ T1 ->
+ ok;
+ E1 ->
+ test_server_fail({bad_terms, E1, T1})
+ end,
+ case get_list(File2 ++ ".1", b) of
+ T2 ->
+ ok;
+ E2 ->
+ test_server_fail({bad_terms, E2, T2})
+ end,
+ case get_list(File3 ++ ".1", c) of
+ T3 ->
+ ok;
+ E3 ->
+ test_server_fail({bad_terms, E3, T3})
+ end,
+ ok = disk_log:close(a),
+ ok = disk_log:close(b),
+ ok = disk_log:close(c),
+ del(File1, 3),
+ del(File2, 3),
+ del(File3, 3),
ok.
simple_log(Log) ->
@@ -879,61 +839,61 @@ simple_log(Log) ->
T2 = hopp,
T3 = {tjena, 12},
T4 = mk_bytes(10000),
- ?line ok = disk_log:log(Log, T1),
- ?line ok = disk_log:log_terms(Log, [T2, T3]),
- ?line case get_all_terms(Log) of
- [T1, T2, T3] ->
- ok;
- E1 ->
- test_server_fail({bad_terms, E1, [T1, T2, T3]})
- end,
- ?line ok = disk_log:log(a, T4),
- ?line case get_all_terms(Log) of
- [T1, T2, T3, T4] ->
- ok;
- E2 ->
- test_server_fail({bad_terms, E2, [T1, T2, T3, T4]})
- end.
+ ok = disk_log:log(Log, T1),
+ ok = disk_log:log_terms(Log, [T2, T3]),
+ case get_all_terms(Log) of
+ [T1, T2, T3] ->
+ ok;
+ E1 ->
+ test_server_fail({bad_terms, E1, [T1, T2, T3]})
+ end,
+ ok = disk_log:log(a, T4),
+ case get_all_terms(Log) of
+ [T1, T2, T3, T4] ->
+ ok;
+ E2 ->
+ test_server_fail({bad_terms, E2, [T1, T2, T3, T4]})
+ end.
xsimple_log(File, Log) ->
T1 = "hej",
T2 = list_to_binary("hopp"),
T3 = list_to_binary(["sena", list_to_binary("sejer")]),
T4 = list_to_binary(By = mk_bytes(10000)),
- ?line ok = disk_log:blog(Log, T1),
- ?line ok = disk_log:blog_terms(Log, [T2, T3]),
- ?line X = "hejhoppsenasejer",
- ?line X2 = get_list(File, Log),
- ?line case X2 of
- X -> ok;
- Z1 -> test_server_fail({bad_terms, Z1, X2})
- end,
- ?line ok = disk_log:blog(Log, T4),
- ?line Tmp = get_list(File, Log),
- ?line case X ++ By of
- Tmp -> ok;
- Z2 -> test_server_fail({bad_terms, Z2, X ++ By})
- end.
+ ok = disk_log:blog(Log, T1),
+ ok = disk_log:blog_terms(Log, [T2, T3]),
+ X = "hejhoppsenasejer",
+ X2 = get_list(File, Log),
+ case X2 of
+ X -> ok;
+ Z1 -> test_server_fail({bad_terms, Z1, X2})
+ end,
+ ok = disk_log:blog(Log, T4),
+ Tmp = get_list(File, Log),
+ case X ++ By of
+ Tmp -> ok;
+ Z2 -> test_server_fail({bad_terms, Z2, X ++ By})
+ end.
x2simple_log(File, Log) ->
T1 = "hej",
T2 = list_to_binary("hopp"),
T3 = list_to_binary(["sena", list_to_binary("sejer")]),
T4 = list_to_binary(By = mk_bytes(1000)),
- ?line ok = disk_log:blog(Log, T1),
- ?line ok = disk_log:blog_terms(Log, [T2, T3]),
- ?line X = "hejhoppsenasejer",
- ?line X2 = get_list(File, Log),
- ?line case X2 of
- X -> ok;
- Z1 -> test_server_fail({bad_terms, Z1, X2})
- end,
- ?line ok = disk_log:blog(Log, T4),
- ?line Tmp = get_list(File, Log),
- ?line case X ++ By of
- Tmp -> ok;
- Z2 -> test_server_fail({bad_terms, Z2, X ++ By})
- end.
+ ok = disk_log:blog(Log, T1),
+ ok = disk_log:blog_terms(Log, [T2, T3]),
+ X = "hejhoppsenasejer",
+ X2 = get_list(File, Log),
+ case X2 of
+ X -> ok;
+ Z1 -> test_server_fail({bad_terms, Z1, X2})
+ end,
+ ok = disk_log:blog(Log, T4),
+ Tmp = get_list(File, Log),
+ case X ++ By of
+ Tmp -> ok;
+ Z2 -> test_server_fail({bad_terms, Z2, X ++ By})
+ end.
x_mk_bytes(N) ->
X = lists:duplicate(N, $a),
@@ -947,7 +907,7 @@ mk_bytes(N) when N > 4 ->
end.
get_list(File, Log) ->
- ?t:format(0, "File ~p~n",[File]),
+ ct:pal(?HI_VERBOSITY, "File ~p~n", [File]),
ok = disk_log:sync(Log),
{ok, B} = file:read_file(File),
binary_to_list(B).
@@ -955,7 +915,7 @@ get_list(File, Log) ->
get_all_terms(Log, File, Type) ->
{ok, _Log} = disk_log:open([{name,Log}, {type,Type}, {size,infinity},
- {format,internal}, {file, File},
+ {format,internal}, {file, File},
{mode, read_only}]),
Ts = get_all_terms(Log),
ok = disk_log:close(Log),
@@ -976,14 +936,14 @@ get_all_terms1(Log, Cont, Res) ->
get_all_terms_and_bad(Log, File, Type) ->
{ok, _Log} = disk_log:open([{name,Log}, {type,Type}, {size,infinity},
- {format,internal}, {file, File},
+ {format,internal}, {file, File},
{mode, read_only}]),
Ts = get_all_terms_and_bad(Log),
ok = disk_log:close(Log),
Ts.
get_all_terms_and_bad(Log) ->
- ?line read_only = info(Log, mode, foo),
+ read_only = info(Log, mode, foo),
get_all_terms_and_bad1(Log, start, [], 0).
%%
@@ -999,7 +959,7 @@ get_all_terms_and_bad1(Log, Cont, Res, Bad0) ->
get_all_binary_terms_and_bad(Log, File, Type) ->
{ok, _Log} = disk_log:open([{name,Log}, {type,Type}, {size,infinity},
- {format,internal}, {file, File},
+ {format,internal}, {file, File},
{mode, read_only}]),
Ts = get_all_binary_terms_and_bad(Log),
ok = disk_log:close(Log),
@@ -1037,7 +997,7 @@ xx() ->
{format,internal}, {file, File}]),
W = xwr(a, 400),
disk_log:close(a),
-% file:delete(File),
+ %% file:delete(File),
W.
%% old: 6150
@@ -1186,73 +1146,72 @@ end_times({T1,W1}) ->
{T2-T1, W2-W1}.
-head_func(suite) -> [];
-head_func(doc) -> ["Test head parameter"];
+%% Test head parameter.
head_func(Conf) when is_list(Conf) ->
Dir = ?privdir(Conf),
File = filename:join(Dir, "a.LOG"),
ets:new(xxx, [named_table, set, public]),
ets:insert(xxx, {wrapc, 0}),
- ?line {ok, a} = disk_log:open([{name,a}, {file, File}, {type, wrap},
- {size, {100,4}},
- {head_func, {?MODULE, hf, []}}]),
- ?line B = mk_bytes(60),
- ?line disk_log:log(a, B),
- ?line disk_log:alog(a, B),
- ?line disk_log:alog(a, B),
- ?line disk_log:log(a, B),
+ {ok, a} = disk_log:open([{name,a}, {file, File}, {type, wrap},
+ {size, {100,4}},
+ {head_func, {?MODULE, hf, []}}]),
+ B = mk_bytes(60),
+ disk_log:log(a, B),
+ disk_log:alog(a, B),
+ disk_log:alog(a, B),
+ disk_log:log(a, B),
H = [1,2,3],
- ?line [{wrapc, 4}] = ets:lookup(xxx, wrapc),
+ [{wrapc, 4}] = ets:lookup(xxx, wrapc),
ets:delete(xxx),
- ?line case get_all_terms(a) of
- [H,B,H,B,H,B,H,B] ->
- ok;
- E1 ->
- test_server_fail({bad_terms, E1,
- [H,B,H,B,H,B,H,B]})
- end,
- ?line 8 = no_written_items(a),
+ case get_all_terms(a) of
+ [H,B,H,B,H,B,H,B] ->
+ ok;
+ E1 ->
+ test_server_fail({bad_terms, E1,
+ [H,B,H,B,H,B,H,B]})
+ end,
+ 8 = no_written_items(a),
disk_log:close(a),
del(File, 4),
- % invalid header function
- ?line {error, {invalid_header, {_, {term}}}} =
+ %% invalid header function
+ {error, {invalid_header, {_, {term}}}} =
disk_log:open([{name, n}, {file, File}, {type, halt},
{format, external},
{head_func, {?MODULE, head_fun, [{term}]}}]),
file:delete(File),
- ?line {error, {invalid_header, _}} =
+ {error, {invalid_header, _}} =
disk_log:open([{name, n}, {file, File}, {type, halt},
{format, external},
{head_func, {?MODULE, head_fun, [{ok,{term}}]}}]),
file:delete(File),
- ?line {ok,n} =
+ {ok,n} =
disk_log:open([{name, n}, {file, File}, {type, halt},
{format, external},
{head_func, {?MODULE, head_fun, [{ok,<<"head">>}]}}]),
- ?line ok = disk_log:close(n),
- ?line {ok,<<"head">>} = file:read_file(File),
+ ok = disk_log:close(n),
+ {ok,<<"head">>} = file:read_file(File),
file:delete(File),
- ?line {ok,n} =
+ {ok,n} =
disk_log:open([{name, n}, {file, File}, {type, halt},
{format, external},
{head_func, {?MODULE, head_fun, [{ok,"head"}]}}]),
- ?line ok = disk_log:close(n),
- ?line {ok,<<"head">>} = file:read_file(File),
+ ok = disk_log:close(n),
+ {ok,<<"head">>} = file:read_file(File),
file:delete(File),
- ?line Error1 = {error, {badarg, _}} =
+ Error1 = {error, {badarg, _}} =
disk_log:open([{name, n}, {file, File}, {type, wrap},
{head_func, {tjo,hej,san}},{size, {100, 4}}]),
- ?line "The argument " ++ _ = format_error(Error1),
-
- ?line Error2 = {error, {invalid_header, _}} =
+ "The argument " ++ _ = format_error(Error1),
+
+ Error2 = {error, {invalid_header, _}} =
disk_log:open([{name, n}, {file, File}, {type, halt},
{head_func, {tjo,hej,[san]}}]),
- ?line "The disk log header" ++ _ = format_error(Error2),
+ "The disk log header" ++ _ = format_error(Error2),
file:delete(File).
@@ -1263,194 +1222,186 @@ hf() ->
ets:update_counter(xxx, wrapc, 1),
{ok, [1,2,3]}.
-plain_head(suite) -> [];
-plain_head(doc) -> ["Test head parameter"];
+%% Test head parameter.
plain_head(Conf) when is_list(Conf) ->
Dir = ?privdir(Conf),
File = filename:join(Dir, "a.LOG"),
H = [1,2,3],
- ?line {ok, a} = disk_log:open([{name,a}, {file, File}, {type, wrap},
- {size, {100,4}}, {head, H}]),
+ {ok, a} = disk_log:open([{name,a}, {file, File}, {type, wrap},
+ {size, {100,4}}, {head, H}]),
%% This one is not "counted".
- ?line {ok, a} = disk_log:open([{name,a}, {file, File}, {type, wrap},
- {size, {100,4}}, {head, H}]),
- ?line B = mk_bytes(60),
- ?line disk_log:log(a, B),
- ?line disk_log:alog(a, B),
- ?line disk_log:alog(a, B),
- ?line disk_log:log(a, B),
- ?line case get_all_terms(a) of
- [H,B,H,B,H,B,H,B] ->
- ok;
- E1 ->
- test_server_fail({bad_terms, E1,
- [H,B,H,B,H,B,H,B]})
- end,
- ?line 8 = no_written_items(a),
- ?line ok = disk_log:close(a),
- ?line {error, no_such_log} = disk_log:close(a),
+ {ok, a} = disk_log:open([{name,a}, {file, File}, {type, wrap},
+ {size, {100,4}}, {head, H}]),
+ B = mk_bytes(60),
+ disk_log:log(a, B),
+ disk_log:alog(a, B),
+ disk_log:alog(a, B),
+ disk_log:log(a, B),
+ case get_all_terms(a) of
+ [H,B,H,B,H,B,H,B] ->
+ ok;
+ E1 ->
+ test_server_fail({bad_terms, E1,
+ [H,B,H,B,H,B,H,B]})
+ end,
+ 8 = no_written_items(a),
+ ok = disk_log:close(a),
+ {error, no_such_log} = disk_log:close(a),
del(File, 4).
-one_header(suite) -> [];
-one_header(doc) -> ["Test that a header is just printed once in a log file"];
+%% Test that a header is just printed once in a log file.
one_header(Conf) when is_list(Conf) ->
Dir = ?privdir(Conf),
File = filename:join(Dir, "a.LOG"),
H = [1,2,3],
- ?line {ok, a} = disk_log:open([{name,a}, {file, File}, {type, wrap},
- {size, {100,4}}, {head, H}]),
- ?line B = mk_bytes(60),
- ?line ok = disk_log:log(a, B),
- ?line ok = disk_log:alog(a, B),
- ?line ok = disk_log:alog(a, B),
- ?line ok = disk_log:log(a, B),
- ?line case get_all_terms(a) of
- [H,B,H,B,H,B,H,B] ->
- ok;
- E1 ->
- test_server_fail({bad_terms, E1,
- [H,B,H,B,H,B,H,B]})
- end,
- ?line 8 = no_written_items(a),
- ?line ok = disk_log:close(a),
+ {ok, a} = disk_log:open([{name,a}, {file, File}, {type, wrap},
+ {size, {100,4}}, {head, H}]),
+ B = mk_bytes(60),
+ ok = disk_log:log(a, B),
+ ok = disk_log:alog(a, B),
+ ok = disk_log:alog(a, B),
+ ok = disk_log:log(a, B),
+ case get_all_terms(a) of
+ [H,B,H,B,H,B,H,B] ->
+ ok;
+ E1 ->
+ test_server_fail({bad_terms, E1,
+ [H,B,H,B,H,B,H,B]})
+ end,
+ 8 = no_written_items(a),
+ ok = disk_log:close(a),
del(File, 4),
Fileb = filename:join(Dir, "b.LOG"),
- ?line {ok, b} = disk_log:open([{name,b}, {file, Fileb}, {head, H}]),
- ?line ok = disk_log:close(b),
- ?line {ok, b} = disk_log:open([{name,b}, {file, Fileb}, {head, H}]),
- ?line ok = disk_log:log(b, "first log"),
- ?line ok = disk_log:alog(b, "second log"),
- ?line ok = disk_log:close(b),
- ?line {ok, b} = disk_log:open([{name,b}, {file, Fileb}, {head, H}]),
- ?line ok = disk_log:alog(b, "3rd log"),
- ?line ok = disk_log:log(b, "4th log"),
- ?line case get_all_terms(b) of
- [H, "first log", "second log", "3rd log", "4th log"] ->
- ok;
- E2 ->
- test_server_fail({bad_terms, E2,
- [H, "first log", "second log",
- "3rd log", "4th log"]})
- end,
- ?line 2 = no_written_items(b),
- ?line ok = disk_log:close(b),
- ?line ok = file:delete(Fileb),
+ {ok, b} = disk_log:open([{name,b}, {file, Fileb}, {head, H}]),
+ ok = disk_log:close(b),
+ {ok, b} = disk_log:open([{name,b}, {file, Fileb}, {head, H}]),
+ ok = disk_log:log(b, "first log"),
+ ok = disk_log:alog(b, "second log"),
+ ok = disk_log:close(b),
+ {ok, b} = disk_log:open([{name,b}, {file, Fileb}, {head, H}]),
+ ok = disk_log:alog(b, "3rd log"),
+ ok = disk_log:log(b, "4th log"),
+ case get_all_terms(b) of
+ [H, "first log", "second log", "3rd log", "4th log"] ->
+ ok;
+ E2 ->
+ test_server_fail({bad_terms, E2,
+ [H, "first log", "second log",
+ "3rd log", "4th log"]})
+ end,
+ 2 = no_written_items(b),
+ ok = disk_log:close(b),
+ ok = file:delete(Fileb),
Filec = filename:join(Dir, "c.LOG"),
H2 = "this is a header ",
- ?line {ok, c} = disk_log:open([{name,c}, {format, external},
- {file, Filec}, {head, H2}]),
- ?line ok = disk_log:close(c),
- ?line {ok, c} = disk_log:open([{name,c}, {format, external},
- {file, Filec}, {head, H2}]),
- ?line ok = disk_log:blog(c, "first log"),
- ?line ok = disk_log:balog(c, "second log"),
- ?line ok = disk_log:close(c),
- ?line {ok, c} = disk_log:open([{name,c}, {format, external},
- {file, Filec}, {head, H2}]),
- ?line ok = disk_log:balog(c, "3rd log"),
- ?line ok = disk_log:blog(c, "4th log"),
- ?line ok = disk_log:sync(c),
- ?line {ok, Fdc} = file:open(Filec, [read]),
- ?line {ok,"this is a header first logsecond log3rd log4th log"} =
+ {ok, c} = disk_log:open([{name,c}, {format, external},
+ {file, Filec}, {head, H2}]),
+ ok = disk_log:close(c),
+ {ok, c} = disk_log:open([{name,c}, {format, external},
+ {file, Filec}, {head, H2}]),
+ ok = disk_log:blog(c, "first log"),
+ ok = disk_log:balog(c, "second log"),
+ ok = disk_log:close(c),
+ {ok, c} = disk_log:open([{name,c}, {format, external},
+ {file, Filec}, {head, H2}]),
+ ok = disk_log:balog(c, "3rd log"),
+ ok = disk_log:blog(c, "4th log"),
+ ok = disk_log:sync(c),
+ {ok, Fdc} = file:open(Filec, [read]),
+ {ok,"this is a header first logsecond log3rd log4th log"} =
file:read(Fdc, 200),
- ?line ok = file:close(Fdc),
- ?line 2 = no_written_items(c),
- ?line disk_log:close(c),
- ?line ok = file:delete(Filec),
+ ok = file:close(Fdc),
+ 2 = no_written_items(c),
+ disk_log:close(c),
+ ok = file:delete(Filec),
ok.
-wrap_notif(suite) -> [];
-wrap_notif(doc) -> ["Test notify parameter, wrap"];
+%% Test notify parameter, wrap.
wrap_notif(Conf) when is_list(Conf) ->
Dir = ?privdir(Conf),
File = filename:join(Dir, "a.LOG"),
- ?line {ok, a} = disk_log:open([{name,a}, {file, File}, {type, wrap},
- {size, {100,4}}, {notify, true}]),
- ?line B = mk_bytes(60),
- ?line disk_log:log(a, B),
- ?line disk_log:alog(a, B),
- ?line disk_log:alog(a, B),
- ?line disk_log:log(a, B),
- ?line disk_log:log(a, B),
- ?line rec(3, {disk_log, node(), a, {wrap, 0}}),
- ?line rec(1, {disk_log, node(), a, {wrap, 1}}),
+ {ok, a} = disk_log:open([{name,a}, {file, File}, {type, wrap},
+ {size, {100,4}}, {notify, true}]),
+ B = mk_bytes(60),
+ disk_log:log(a, B),
+ disk_log:alog(a, B),
+ disk_log:alog(a, B),
+ disk_log:log(a, B),
+ disk_log:log(a, B),
+ rec(3, {disk_log, node(), a, {wrap, 0}}),
+ rec(1, {disk_log, node(), a, {wrap, 1}}),
disk_log:close(a),
del(File, 4).
-full_notif(suite) -> [];
-full_notif(doc) -> ["Test notify parameter, wrap, filled file"];
+%% Test notify parameter, wrap, filled file.
full_notif(Conf) when is_list(Conf) ->
Dir = ?privdir(Conf),
File = filename:join(Dir, "a.LOG"),
file:delete(File),
- ?line {ok, a} = disk_log:open([{name, a}, {file, File}, {type, halt},
- {size, 100}, {notify, true}]),
- ?line B = mk_bytes(60),
- ?line disk_log:log(a, B),
- ?line disk_log:alog(a, B),
- ?line rec(1, {disk_log, node(), a, full}),
+ {ok, a} = disk_log:open([{name, a}, {file, File}, {type, halt},
+ {size, 100}, {notify, true}]),
+ B = mk_bytes(60),
+ disk_log:log(a, B),
+ disk_log:alog(a, B),
+ rec(1, {disk_log, node(), a, full}),
disk_log:close(a),
file:delete(File).
-trunc_notif(suite) -> [];
-trunc_notif(doc) -> ["Test notify parameter, wrap, truncated file"];
+%% Test notify parameter, wrap, truncated file.
trunc_notif(Conf) when is_list(Conf) ->
Dir = ?privdir(Conf),
File = filename:join(Dir, "a.LOG"),
File2 = filename:join(Dir, "a.DUMP"),
- ?line {ok, a} = disk_log:open([{name, a}, {file, File}, {type, halt},
- {size, 100}, {notify, true}]),
- ?line B = mk_bytes(60),
- ?line disk_log:log(a, B),
- ?line disk_log:truncate(a),
- ?line rec(1, {disk_log, node(), a, {truncated, 1}}),
- ?line disk_log:log(a, B),
- ?line ok = disk_log:reopen(a, File2),
- ?line rec(1, {disk_log, node(), a, {truncated, 1}}),
+ {ok, a} = disk_log:open([{name, a}, {file, File}, {type, halt},
+ {size, 100}, {notify, true}]),
+ B = mk_bytes(60),
+ disk_log:log(a, B),
+ disk_log:truncate(a),
+ rec(1, {disk_log, node(), a, {truncated, 1}}),
+ disk_log:log(a, B),
+ ok = disk_log:reopen(a, File2),
+ rec(1, {disk_log, node(), a, {truncated, 1}}),
disk_log:close(a),
file:delete(File),
file:delete(File2).
-blocked_notif(suite) -> [];
-blocked_notif(doc) ->
- ["Test notify parameters 'format_external' and 'blocked_log"];
+%% Test notify parameters 'format_external' and 'blocked_log.
blocked_notif(Conf) when is_list(Conf) ->
Dir = ?privdir(Conf),
File = filename:join(Dir, "n.LOG"),
No = 4,
- ?line {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
- {size, {100,No}}, {notify, true},
- {format, external}]),
- ?line B = mk_bytes(60),
- ?line Error1 = {error,{format_external,n}} = disk_log:log(n, B),
- ?line "The requested operation" ++ _ = format_error(Error1),
- ?line ok = disk_log:blog(n, B),
- ?line ok = disk_log:alog(n, B),
- ?line rec(1, {disk_log, node(), n, {format_external, term_to_binary(B)}}),
- ?line ok = disk_log:alog_terms(n, [B,B,B,B]),
- ?line rec(1, {disk_log, node(), n, {format_external,
- lists:map(fun term_to_binary/1, [B,B,B,B])}}),
- ?line ok = disk_log:block(n, false),
- ?line ok = disk_log:alog(n, B),
- ?line rec(1, {disk_log, node(), n, {blocked_log, term_to_binary(B)}}),
- ?line ok = disk_log:balog(n, B),
- ?line rec(1, {disk_log, node(), n, {blocked_log, list_to_binary(B)}}),
- ?line ok = disk_log:balog_terms(n, [B,B,B,B]),
- ?line disk_log:close(n),
- ?line rec(1, {disk_log, node(), n, {blocked_log,
- lists:map(fun list_to_binary/1, [B,B,B,B])}}),
- ?line del(File, No).
-
-
-new_idx_vsn(suite) -> [];
-new_idx_vsn(doc) -> ["Test the new version of the .idx file"];
+ {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
+ {size, {100,No}}, {notify, true},
+ {format, external}]),
+ B = mk_bytes(60),
+ Error1 = {error,{format_external,n}} = disk_log:log(n, B),
+ "The requested operation" ++ _ = format_error(Error1),
+ ok = disk_log:blog(n, B),
+ ok = disk_log:alog(n, B),
+ rec(1, {disk_log, node(), n, {format_external, term_to_binary(B)}}),
+ ok = disk_log:alog_terms(n, [B,B,B,B]),
+ rec(1, {disk_log, node(), n, {format_external,
+ lists:map(fun term_to_binary/1, [B,B,B,B])}}),
+ ok = disk_log:block(n, false),
+ ok = disk_log:alog(n, B),
+ rec(1, {disk_log, node(), n, {blocked_log, term_to_binary(B)}}),
+ ok = disk_log:balog(n, B),
+ rec(1, {disk_log, node(), n, {blocked_log, list_to_binary(B)}}),
+ ok = disk_log:balog_terms(n, [B,B,B,B]),
+ disk_log:close(n),
+ rec(1, {disk_log, node(), n, {blocked_log,
+ lists:map(fun list_to_binary/1, [B,B,B,B])}}),
+ del(File, No).
+
+
+%% Test the new version of the .idx file.
new_idx_vsn(Conf) when is_list(Conf) ->
DataDir = ?datadir(Conf),
PrivDir = ?privdir(Conf),
@@ -1459,201 +1410,197 @@ new_idx_vsn(Conf) when is_list(Conf) ->
Kurt2 = filename:join(PrivDir, "kurt2.LOG"),
%% Test that a wrap log file can have more than 255 files
- ?line {ok, new_vsn} = disk_log:open([{file, File}, {name, new_vsn},
- {type, wrap}, {size, {40, 270}}]),
- ?line ok = log(new_vsn, 280),
- ?line {ok, Bin} = file:read_file(add_ext(File, "idx")),
- ?line <<0,0:32,2,10:32,1:64,1:64,_/binary>> = Bin,
- ?line disk_log:close(new_vsn),
- ?line del(File, 270),
+ {ok, new_vsn} = disk_log:open([{file, File}, {name, new_vsn},
+ {type, wrap}, {size, {40, 270}}]),
+ ok = log(new_vsn, 280),
+ {ok, Bin} = file:read_file(add_ext(File, "idx")),
+ <<0,0:32,2,10:32,1:64,1:64,_/binary>> = Bin,
+ disk_log:close(new_vsn),
+ del(File, 270),
%% convert a very old version (0) of wrap log file to the new format (2)
copy_wrap_log("kurt.LOG", 4, DataDir, PrivDir),
- ?line {repaired, kurt, {recovered, 1}, {badbytes, 0}} =
+ {repaired, kurt, {recovered, 1}, {badbytes, 0}} =
disk_log:open([{file, Kurt}, {name, kurt},
{type, wrap}, {size, {40, 4}}]),
- ?line ok = disk_log:log(kurt, "this is a logged message number X"),
- ?line ok = disk_log:log(kurt, "this is a logged message number Y"),
- ?line {ok, BinK} = file:read_file(add_ext(Kurt, "idx")),
- ?line <<0,0:32,2,2:32,1:64,1:64,1:64,1:64>> = BinK,
- ?line {{40,4}, 2} = disk_log_1:read_size_file_version(Kurt),
+ ok = disk_log:log(kurt, "this is a logged message number X"),
+ ok = disk_log:log(kurt, "this is a logged message number Y"),
+ {ok, BinK} = file:read_file(add_ext(Kurt, "idx")),
+ <<0,0:32,2,2:32,1:64,1:64,1:64,1:64>> = BinK,
+ {{40,4}, 2} = disk_log_1:read_size_file_version(Kurt),
disk_log:close(kurt),
- ?line del(Kurt, 4),
+ del(Kurt, 4),
%% keep the old format (1)
copy_wrap_log("kurt2.LOG", 4, DataDir, PrivDir),
- ?line {repaired, kurt2, {recovered, 1}, {badbytes, 0}} =
+ {repaired, kurt2, {recovered, 1}, {badbytes, 0}} =
disk_log:open([{file, Kurt2}, {name, kurt2},
{type, wrap}, {size, {40, 4}}]),
- ?line ok = disk_log:log(kurt2, "this is a logged message number X"),
- ?line ok = disk_log:log(kurt2, "this is a logged message number Y"),
- ?line {ok, BinK2} = file:read_file(add_ext(Kurt2, "idx")),
- ?line <<0,2:32,1:32,1:32,1:32,1:32>> = BinK2,
- ?line {{40,4}, 1} = disk_log_1:read_size_file_version(Kurt2),
+ ok = disk_log:log(kurt2, "this is a logged message number X"),
+ ok = disk_log:log(kurt2, "this is a logged message number Y"),
+ {ok, BinK2} = file:read_file(add_ext(Kurt2, "idx")),
+ <<0,2:32,1:32,1:32,1:32,1:32>> = BinK2,
+ {{40,4}, 1} = disk_log_1:read_size_file_version(Kurt2),
disk_log:close(kurt2),
- ?line del(Kurt2, 4),
+ del(Kurt2, 4),
ok.
-reopen(suite) -> [];
-reopen(doc) ->
- ["Test reopen/1 on halt and wrap logs."];
+%% Test reopen/1 on halt and wrap logs.
reopen(Conf) when is_list(Conf) ->
Dir = ?privdir(Conf),
- ?line File = filename:join(Dir, "n.LOG"),
- ?line NewFile = filename:join(Dir, "nn.LOG"),
- ?line B = mk_bytes(60),
-
- ?line file:delete(File), % cleanup
- ?line file:delete(NewFile), % cleanup
- ?line Q = qlen(),
+ File = filename:join(Dir, "n.LOG"),
+ NewFile = filename:join(Dir, "nn.LOG"),
+ B = mk_bytes(60),
+
+ file:delete(File), % cleanup
+ file:delete(NewFile), % cleanup
+ Q = qlen(),
%% External halt log.
- ?line {ok, n} = disk_log:open([{name, n}, {file, File}, {type, halt},
- {notify, true}, {head, "header"},
- {size, infinity},{format, external}]),
- ?line ok = disk_log:blog(n, B),
- ?line ok = disk_log:breopen(n, NewFile, "head"),
- ?line rec(1, {disk_log, node(), n, {truncated, 2}}),
- ?line ok = disk_log:blog(n, B),
- ?line ok = disk_log:blog(n, B),
- ?line ok = disk_log:breopen(n, NewFile, "head"),
- ?line rec(1, {disk_log, node(), n, {truncated, 3}}),
- ?line ok = disk_log:close(n),
- ?line {ok,BinaryFile} = file:read_file(File),
- ?line "head" = binary_to_list(BinaryFile),
- ?line file:delete(File),
- ?line file:delete(NewFile),
+ {ok, n} = disk_log:open([{name, n}, {file, File}, {type, halt},
+ {notify, true}, {head, "header"},
+ {size, infinity},{format, external}]),
+ ok = disk_log:blog(n, B),
+ ok = disk_log:breopen(n, NewFile, "head"),
+ rec(1, {disk_log, node(), n, {truncated, 2}}),
+ ok = disk_log:blog(n, B),
+ ok = disk_log:blog(n, B),
+ ok = disk_log:breopen(n, NewFile, "head"),
+ rec(1, {disk_log, node(), n, {truncated, 3}}),
+ ok = disk_log:close(n),
+ {ok,BinaryFile} = file:read_file(File),
+ "head" = binary_to_list(BinaryFile),
+ file:delete(File),
+ file:delete(NewFile),
%% Internal halt log.
- ?line {ok, n} = disk_log:open([{name, n}, {file, File}, {type, halt},
- {notify, true}, {head, header},
- {size, infinity}]),
- ?line ok = disk_log:log(n, B),
- ?line Error1 = {error, {same_file_name, n}} = disk_log:reopen(n, File),
- ?line "Current and new" ++ _ = format_error(Error1),
- ?line ok = disk_log:reopen(n, NewFile),
- ?line rec(1, {disk_log, node(), n, {truncated, 2}}),
- ?line ok = disk_log:log(n, B),
- ?line ok = disk_log:log(n, B),
- ?line ok = disk_log:reopen(n, NewFile),
- ?line rec(1, {disk_log, node(), n, {truncated, 3}}),
- ?line ok = disk_log:close(n),
- ?line [header, _B, _B] = get_all_terms(nn, NewFile, halt),
- ?line file:delete(File),
- ?line file:delete(NewFile),
+ {ok, n} = disk_log:open([{name, n}, {file, File}, {type, halt},
+ {notify, true}, {head, header},
+ {size, infinity}]),
+ ok = disk_log:log(n, B),
+ Error1 = {error, {same_file_name, n}} = disk_log:reopen(n, File),
+ "Current and new" ++ _ = format_error(Error1),
+ ok = disk_log:reopen(n, NewFile),
+ rec(1, {disk_log, node(), n, {truncated, 2}}),
+ ok = disk_log:log(n, B),
+ ok = disk_log:log(n, B),
+ ok = disk_log:reopen(n, NewFile),
+ rec(1, {disk_log, node(), n, {truncated, 3}}),
+ ok = disk_log:close(n),
+ [header, _B, _B] = get_all_terms(nn, NewFile, halt),
+ file:delete(File),
+ file:delete(NewFile),
%% Internal wrap log.
- ?line No = 4,
- ?line del(File, No), % cleanup
- ?line del(NewFile, No), % cleanup
-
- ?line {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
- {notify, true},
- {head, header}, {size, {100, No}}]),
- ?line ok = disk_log:log(n, B),
- ?line ok = disk_log:log_terms(n, [B,B,B]),
+ No = 4,
+ del(File, No), % cleanup
+ del(NewFile, No), % cleanup
+
+ {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
+ {notify, true},
+ {head, header}, {size, {100, No}}]),
+ ok = disk_log:log(n, B),
+ ok = disk_log:log_terms(n, [B,B,B]),
%% Used to be one message, but now one per wrapped file.
- ?line rec(3, {disk_log, node(), n, {wrap, 0}}),
- ?line ok = disk_log:log_terms(n, [B]),
- ?line rec(1, {disk_log, node(), n, {wrap, 2}}),
- ?line ok = disk_log:log_terms(n, [B]),
- ?line rec(1, {disk_log, node(), n, {wrap, 2}}),
- ?line ok = disk_log:reopen(n, NewFile, new_header),
- ?line rec(1, {disk_log, node(), n, {truncated, 8}}),
- ?line ok = disk_log:log_terms(n, [B,B]),
- ?line rec(1, {disk_log, node(), n, {wrap, 0}}),
- ?line ok = disk_log:log_terms(n, [B]),
- ?line rec(1, {disk_log, node(), n, {wrap, 0}}),
- ?line ok = disk_log:close(n),
- ?line [header, _, header, _, header, _, header, _] =
+ rec(3, {disk_log, node(), n, {wrap, 0}}),
+ ok = disk_log:log_terms(n, [B]),
+ rec(1, {disk_log, node(), n, {wrap, 2}}),
+ ok = disk_log:log_terms(n, [B]),
+ rec(1, {disk_log, node(), n, {wrap, 2}}),
+ ok = disk_log:reopen(n, NewFile, new_header),
+ rec(1, {disk_log, node(), n, {truncated, 8}}),
+ ok = disk_log:log_terms(n, [B,B]),
+ rec(1, {disk_log, node(), n, {wrap, 0}}),
+ ok = disk_log:log_terms(n, [B]),
+ rec(1, {disk_log, node(), n, {wrap, 0}}),
+ ok = disk_log:close(n),
+ [header, _, header, _, header, _, header, _] =
get_all_terms(nn, NewFile, wrap),
- ?line [new_header, _, header, _, header, _] = get_all_terms(n, File, wrap),
+ [new_header, _, header, _, header, _] = get_all_terms(n, File, wrap),
- ?line del(NewFile, No),
- ?line file:delete(File ++ ".2"),
- ?line {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
- {notify, true},
- {head, header}, {size, {100, No}}]),
+ del(NewFile, No),
+ file:delete(File ++ ".2"),
+ {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
+ {notify, true},
+ {head, header}, {size, {100, No}}]),
%% One file is missing...
- ?line ok = disk_log:reopen(n, NewFile),
- ?line rec(1, {disk_log, node(), n, {truncated, 6}}),
- ?line ok = disk_log:close(n),
+ ok = disk_log:reopen(n, NewFile),
+ rec(1, {disk_log, node(), n, {truncated, 6}}),
+ ok = disk_log:close(n),
- ?line del(File, No),
- ?line del(NewFile, No),
- ?line Q = qlen(),
+ del(File, No),
+ del(NewFile, No),
+ Q = qlen(),
ok.
-block_blocked(suite) -> [];
-block_blocked(doc) ->
- ["Test block/1 on external and internal logs."];
+%% Test block/1 on external and internal logs.
block_blocked(Conf) when is_list(Conf) ->
Dir = ?privdir(Conf),
- ?line B = mk_bytes(60),
+ B = mk_bytes(60),
Halt = join(Dir, "halt.LOG"),
- % External logs.
- ?line file:delete(Halt), % cleanup
- ?line {ok, halt} = disk_log:open([{name, halt}, {type, halt},
- {format, external}, {file, Halt}]),
- ?line ok = disk_log:sync(halt),
- ?line ok = disk_log:block(halt, false),
- ?line Error1 = {error, {blocked_log, halt}} = disk_log:block(halt),
- ?line "The blocked disk" ++ _ = format_error(Error1),
- ?line {error, {blocked_log, halt}} = disk_log:sync(halt),
- ?line {error, {blocked_log, halt}} = disk_log:truncate(halt),
- ?line {error, {blocked_log, halt}} = disk_log:change_size(halt, infinity),
- ?line {error, {blocked_log, halt}} =
+ %% External logs.
+ file:delete(Halt), % cleanup
+ {ok, halt} = disk_log:open([{name, halt}, {type, halt},
+ {format, external}, {file, Halt}]),
+ ok = disk_log:sync(halt),
+ ok = disk_log:block(halt, false),
+ Error1 = {error, {blocked_log, halt}} = disk_log:block(halt),
+ "The blocked disk" ++ _ = format_error(Error1),
+ {error, {blocked_log, halt}} = disk_log:sync(halt),
+ {error, {blocked_log, halt}} = disk_log:truncate(halt),
+ {error, {blocked_log, halt}} = disk_log:change_size(halt, infinity),
+ {error, {blocked_log, halt}} =
disk_log:change_notify(halt, self(), false),
- ?line {error, {blocked_log, halt}} =
+ {error, {blocked_log, halt}} =
disk_log:change_header(halt, {head, header}),
- ?line {error, {blocked_log, halt}} = disk_log:reopen(halt, "foo"),
- ?line ok = disk_log:close(halt),
-
- ?line {ok, halt} = disk_log:open([{name, halt}, {type, halt},
- {format, external}]),
- ?line ok = disk_log:sync(halt),
- ?line ok = disk_log:block(halt, true),
- ?line {error, {blocked_log, halt}} = disk_log:blog(halt, B),
- ?line {error, {blocked_log, halt}} = disk_log:blog(halt, B),
- ?line {error, {blocked_log, halt}} = disk_log:block(halt),
- ?line {error, {blocked_log, halt}} = disk_log:sync(halt),
- ?line {error, {blocked_log, halt}} = disk_log:truncate(halt),
- ?line {error, {blocked_log, halt}} = disk_log:change_size(halt, infinity),
- ?line {error, {blocked_log, halt}} =
+ {error, {blocked_log, halt}} = disk_log:reopen(halt, "foo"),
+ ok = disk_log:close(halt),
+
+ {ok, halt} = disk_log:open([{name, halt}, {type, halt},
+ {format, external}]),
+ ok = disk_log:sync(halt),
+ ok = disk_log:block(halt, true),
+ {error, {blocked_log, halt}} = disk_log:blog(halt, B),
+ {error, {blocked_log, halt}} = disk_log:blog(halt, B),
+ {error, {blocked_log, halt}} = disk_log:block(halt),
+ {error, {blocked_log, halt}} = disk_log:sync(halt),
+ {error, {blocked_log, halt}} = disk_log:truncate(halt),
+ {error, {blocked_log, halt}} = disk_log:change_size(halt, infinity),
+ {error, {blocked_log, halt}} =
disk_log:change_notify(halt, self(), false),
- ?line {error, {blocked_log, halt}} =
+ {error, {blocked_log, halt}} =
disk_log:change_header(halt, {head, header}),
- ?line {error, {blocked_log, halt}} = disk_log:reopen(halt, "foo"),
-
- ?line ok = disk_log:unblock(halt),
- ?line ok = disk_log:close(halt),
- ?line file:delete(Halt),
-
- % Internal logs.
- ?line File = filename:join(Dir, "n.LOG"),
- ?line No = 4,
- ?line del(File, No), % cleanup
- ?line {ok, halt} = disk_log:open([{name, halt}, {file, File}, {type, wrap},
- {size, {100, No}}]),
- ?line ok = disk_log:block(halt, true),
- ?line eof = disk_log:chunk(halt, start),
- ?line Error2 = {error, end_of_log} = disk_log:chunk_step(halt, start, 1),
- ?line "An attempt" ++ _ = format_error(Error2),
- ?line {error, {blocked_log, halt}} = disk_log:log(halt, B),
- ?line {error, {blocked_log, halt}} = disk_log:inc_wrap_file(halt),
- ?line ok = disk_log:unblock(halt),
- ?line ok = disk_log:block(halt, false),
- ?line {error, {blocked_log, halt}} = disk_log:log(halt, B),
- ?line {error, {blocked_log, halt}} = disk_log:inc_wrap_file(halt),
- ?line Parent = self(),
- ?line Pid =
+ {error, {blocked_log, halt}} = disk_log:reopen(halt, "foo"),
+
+ ok = disk_log:unblock(halt),
+ ok = disk_log:close(halt),
+ file:delete(Halt),
+
+ %% Internal logs.
+ File = filename:join(Dir, "n.LOG"),
+ No = 4,
+ del(File, No), % cleanup
+ {ok, halt} = disk_log:open([{name, halt}, {file, File}, {type, wrap},
+ {size, {100, No}}]),
+ ok = disk_log:block(halt, true),
+ eof = disk_log:chunk(halt, start),
+ Error2 = {error, end_of_log} = disk_log:chunk_step(halt, start, 1),
+ "An attempt" ++ _ = format_error(Error2),
+ {error, {blocked_log, halt}} = disk_log:log(halt, B),
+ {error, {blocked_log, halt}} = disk_log:inc_wrap_file(halt),
+ ok = disk_log:unblock(halt),
+ ok = disk_log:block(halt, false),
+ {error, {blocked_log, halt}} = disk_log:log(halt, B),
+ {error, {blocked_log, halt}} = disk_log:inc_wrap_file(halt),
+ Parent = self(),
+ Pid =
spawn_link(fun() ->
{error, {blocked_log, halt}} =
disk_log:chunk(halt, start),
@@ -1661,109 +1608,107 @@ block_blocked(Conf) when is_list(Conf) ->
disk_log:chunk_step(halt, start, 1),
Parent ! {self(), stopped}
end),
- ?line receive {Pid,stopped} -> ok end,
- ?line ok = disk_log:close(halt),
- ?line del(File, No).
+ receive {Pid,stopped} -> ok end,
+ ok = disk_log:close(halt),
+ del(File, No).
-block_queue(suite) -> [];
-block_queue(doc) ->
- ["Run commands from the queue by unblocking."];
+%% Run commands from the queue by unblocking.
block_queue(Conf) when is_list(Conf) ->
Dir = ?privdir(Conf),
- ?line Q = qlen(),
- ?line File = filename:join(Dir, "n.LOG"),
- ?line No = 4,
- ?line del(File, No), % cleanup
- ?line B = mk_bytes(60),
-
- ?line Pid = spawn_link(?MODULE, lserv, [n]),
- ?line {ok, n} = sync_do(Pid, {open, File}),
-
- ?line ok = disk_log:block(n, true),
- ?line async_do(Pid, {blog, B}),
- ?line ok = disk_log:unblock(n),
- ?line ok = get_reply(),
- ?line 1 = no_written_items(n),
- ?line Error1 = {error,{not_blocked,n}} = disk_log:unblock(n),
- ?line "The disk log" ++ _ = format_error(Error1),
-
- ?line ok = disk_log:block(n, true),
- ?line async_do(Pid, {balog, "one string"}),
- ?line ok = disk_log:unblock(n),
- ?line ok = get_reply(),
- ?line 2 = no_written_items(n),
-
- ?line ok = disk_log:block(n, true),
- ?line async_do(Pid, sync),
- ?line ok = disk_log:unblock(n),
- ?line ok = get_reply(),
-
- ?line ok = disk_log:block(n, true),
- ?line async_do(Pid, truncate),
- ?line ok = disk_log:unblock(n),
- ?line ok = get_reply(),
- ?line 0 = no_items(n),
-
- ?line ok = disk_log:block(n, true),
- ?line async_do(Pid, {block, false}),
- ?line ok = disk_log:unblock(n),
- ?line ok = get_reply(),
- ?line {error, {blocked_log, _}} = disk_log:blog(n, B),
- ?line ok = sync_do(Pid, unblock),
-
- ?line ok = disk_log:block(n, true),
- ?line async_do(Pid, {change_notify, Pid, true}),
- ?line ok = disk_log:unblock(n),
- ?line ok = get_reply(),
- ?line [{_, true}] = owners(n),
-
- ?line ok = disk_log:block(n, true),
- ?line async_do(Pid, {change_notify, Pid, false}),
- ?line ok = disk_log:unblock(n),
- ?line ok = get_reply(),
- ?line [{_, false}] = owners(n),
-
- ?line ok = disk_log:block(n, true),
- ?line async_do(Pid, {change_header, {head, header}}),
- ?line ok = disk_log:unblock(n),
- ?line {error, {badarg, head}} = get_reply(),
-
- ?line ok = disk_log:block(n, true),
- ?line async_do(Pid, {change_size, 17}),
- ?line ok = disk_log:unblock(n),
- ?line {error, {badarg, size}} = get_reply(),
-
- ?line ok = disk_log:block(n, true),
- ?line async_do(Pid, inc_wrap_file),
- ?line ok = disk_log:unblock(n),
- ?line ok = get_reply(),
-
- ?line ok = sync_do(Pid, close),
- ?line del(File, No),
-
- ?line _Pid2 = spawn_link(?MODULE, lserv, [n]),
- ?line {ok, n} = sync_do(Pid, {int_open, File}),
-
- ?line ok = disk_log:block(n, true),
- ?line async_do(Pid, {chunk, start}),
- ?line ok = disk_log:unblock(n),
- ?line eof = get_reply(),
-
- ?line ok = disk_log:block(n, true),
- ?line async_do(Pid, {chunk_step, start, 100}),
- ?line ok = disk_log:unblock(n),
- ?line {ok, _Cont} = get_reply(),
-
- ?line ok = disk_log:block(n, true),
- ?line async_do(Pid, {log,a_term}),
- ?line ok = disk_log:unblock(n),
- ?line ok = get_reply(),
- ?line 1 = no_written_items(n),
-
- ?line ok = sync_do(Pid, close),
- ?line sync_do(Pid, terminate),
- ?line del(File, No),
+ Q = qlen(),
+ File = filename:join(Dir, "n.LOG"),
+ No = 4,
+ del(File, No), % cleanup
+ B = mk_bytes(60),
+
+ Pid = spawn_link(?MODULE, lserv, [n]),
+ {ok, n} = sync_do(Pid, {open, File}),
+
+ ok = disk_log:block(n, true),
+ async_do(Pid, {blog, B}),
+ ok = disk_log:unblock(n),
+ ok = get_reply(),
+ 1 = no_written_items(n),
+ Error1 = {error,{not_blocked,n}} = disk_log:unblock(n),
+ "The disk log" ++ _ = format_error(Error1),
+
+ ok = disk_log:block(n, true),
+ async_do(Pid, {balog, "one string"}),
+ ok = disk_log:unblock(n),
+ ok = get_reply(),
+ 2 = no_written_items(n),
+
+ ok = disk_log:block(n, true),
+ async_do(Pid, sync),
+ ok = disk_log:unblock(n),
+ ok = get_reply(),
+
+ ok = disk_log:block(n, true),
+ async_do(Pid, truncate),
+ ok = disk_log:unblock(n),
+ ok = get_reply(),
+ 0 = no_items(n),
+
+ ok = disk_log:block(n, true),
+ async_do(Pid, {block, false}),
+ ok = disk_log:unblock(n),
+ ok = get_reply(),
+ {error, {blocked_log, _}} = disk_log:blog(n, B),
+ ok = sync_do(Pid, unblock),
+
+ ok = disk_log:block(n, true),
+ async_do(Pid, {change_notify, Pid, true}),
+ ok = disk_log:unblock(n),
+ ok = get_reply(),
+ [{_, true}] = owners(n),
+
+ ok = disk_log:block(n, true),
+ async_do(Pid, {change_notify, Pid, false}),
+ ok = disk_log:unblock(n),
+ ok = get_reply(),
+ [{_, false}] = owners(n),
+
+ ok = disk_log:block(n, true),
+ async_do(Pid, {change_header, {head, header}}),
+ ok = disk_log:unblock(n),
+ {error, {badarg, head}} = get_reply(),
+
+ ok = disk_log:block(n, true),
+ async_do(Pid, {change_size, 17}),
+ ok = disk_log:unblock(n),
+ {error, {badarg, size}} = get_reply(),
+
+ ok = disk_log:block(n, true),
+ async_do(Pid, inc_wrap_file),
+ ok = disk_log:unblock(n),
+ ok = get_reply(),
+
+ ok = sync_do(Pid, close),
+ del(File, No),
+
+ _Pid2 = spawn_link(?MODULE, lserv, [n]),
+ {ok, n} = sync_do(Pid, {int_open, File}),
+
+ ok = disk_log:block(n, true),
+ async_do(Pid, {chunk, start}),
+ ok = disk_log:unblock(n),
+ eof = get_reply(),
+
+ ok = disk_log:block(n, true),
+ async_do(Pid, {chunk_step, start, 100}),
+ ok = disk_log:unblock(n),
+ {ok, _Cont} = get_reply(),
+
+ ok = disk_log:block(n, true),
+ async_do(Pid, {log,a_term}),
+ ok = disk_log:unblock(n),
+ ok = get_reply(),
+ 1 = no_written_items(n),
+
+ ok = sync_do(Pid, close),
+ sync_do(Pid, terminate),
+ del(File, No),
%% Test of the queue. Three processes involved here. Pid1's block
%% request is queued. Pid2's log requests are put in the queue.
@@ -1771,171 +1716,165 @@ block_queue(Conf) when is_list(Conf) ->
%% Pid2's log requests are executed when Pid1 unblocks.
%% (This example should show that the pair 'queue' and 'messages'
%% in State does the trick - one does not need a "real" queue.)
- ?line P0 = pps(),
+ P0 = pps(),
Name = n,
- ?line Pid1 = spawn_link(?MODULE, lserv, [Name]),
- ?line {ok, Name} = sync_do(Pid1, {int_open, File, {1000,2}}),
- ?line Pid2 = spawn_link(?MODULE, lserv, [Name]),
- ?line {ok, Name} = sync_do(Pid2, {int_open, File, {1000,2}}),
- ?line ok = disk_log:block(Name),
- ?line async_do(Pid1, {alog,{1,a}}),
- ?line ok = get_reply(),
- ?line async_do(Pid1, {alog,{2,b}}),
- ?line ok = get_reply(),
- ?line async_do(Pid1, {alog,{3,c}}),
- ?line ok = get_reply(),
- ?line async_do(Pid1, {alog,{4,d}}),
- ?line ok = get_reply(),
- ?line async_do(Pid1, block),
- ?line async_do(Pid2, {alog,{5,e}}),
- ?line ok = get_reply(),
- ?line async_do(Pid2, {alog,{6,f}}),
- ?line ok = get_reply(),
- ?line ok = disk_log:unblock(Name),
- ?line ok = get_reply(),
- ?line async_do(Pid2, {alog,{7,g}}),
- ?line ok = get_reply(),
- ?line async_do(Pid2, {alog,{8,h}}),
- ?line ok = get_reply(),
- ?line async_do(Pid1, unblock),
- ?line ok = get_reply(),
- ?line ok = sync_do(Pid1, close),
- ?line ok = sync_do(Pid2, close),
- ?line sync_do(Pid1, terminate),
- ?line sync_do(Pid2, terminate),
+ Pid1 = spawn_link(?MODULE, lserv, [Name]),
+ {ok, Name} = sync_do(Pid1, {int_open, File, {1000,2}}),
+ Pid2 = spawn_link(?MODULE, lserv, [Name]),
+ {ok, Name} = sync_do(Pid2, {int_open, File, {1000,2}}),
+ ok = disk_log:block(Name),
+ async_do(Pid1, {alog,{1,a}}),
+ ok = get_reply(),
+ async_do(Pid1, {alog,{2,b}}),
+ ok = get_reply(),
+ async_do(Pid1, {alog,{3,c}}),
+ ok = get_reply(),
+ async_do(Pid1, {alog,{4,d}}),
+ ok = get_reply(),
+ async_do(Pid1, block),
+ async_do(Pid2, {alog,{5,e}}),
+ ok = get_reply(),
+ async_do(Pid2, {alog,{6,f}}),
+ ok = get_reply(),
+ ok = disk_log:unblock(Name),
+ ok = get_reply(),
+ async_do(Pid2, {alog,{7,g}}),
+ ok = get_reply(),
+ async_do(Pid2, {alog,{8,h}}),
+ ok = get_reply(),
+ async_do(Pid1, unblock),
+ ok = get_reply(),
+ ok = sync_do(Pid1, close),
+ ok = sync_do(Pid2, close),
+ sync_do(Pid1, terminate),
+ sync_do(Pid2, terminate),
Terms = get_all_terms(Name, File, wrap),
- ?line true = [{1,a},{2,b},{3,c},{4,d},{5,e},{6,f},{7,g},{8,h}] == Terms,
+ true = [{1,a},{2,b},{3,c},{4,d},{5,e},{6,f},{7,g},{8,h}] == Terms,
del(File, 2),
- ?line Q = qlen(),
- ?line true = (P0 == pps()),
+ Q = qlen(),
+ true = (P0 == pps()),
ok.
-block_queue2(suite) -> [];
-block_queue2(doc) ->
- ["OTP-4880. Blocked processes did not get disk_log_stopped message."];
+%% OTP-4880. Blocked processes did not get disk_log_stopped message.
block_queue2(Conf) when is_list(Conf) ->
- ?line Q = qlen(),
- ?line P0 = pps(),
+ Q = qlen(),
+ P0 = pps(),
Dir = ?privdir(Conf),
- ?line File = filename:join(Dir, "n.LOG"),
- ?line No = 4,
+ File = filename:join(Dir, "n.LOG"),
+ No = 4,
%% log requests are queued, and processed when the log is closed
- ?line Pid = spawn_link(?MODULE, lserv, [n]),
- ?line {ok, n} = sync_do(Pid, {open, File}),
- ?line ok = sync_do(Pid, block),
+ Pid = spawn_link(?MODULE, lserv, [n]),
+ {ok, n} = sync_do(Pid, {open, File}),
+ ok = sync_do(Pid, block),
%% Asynchronous stuff is ignored.
- ?line ok = disk_log:balog_terms(n, [<<"foo">>,<<"bar">>]),
- ?line ok = disk_log:balog_terms(n, [<<"more">>,<<"terms">>]),
+ ok = disk_log:balog_terms(n, [<<"foo">>,<<"bar">>]),
+ ok = disk_log:balog_terms(n, [<<"more">>,<<"terms">>]),
Parent = self(),
- ?line Fun =
+ Fun =
fun() ->
{error,no_such_log} = disk_log:sync(n),
receive {disk_log, _, {error, disk_log_stopped}} -> ok end,
Parent ! disk_log_stopped_ok
end,
- ?line spawn(Fun),
- ?line ok = sync_do(Pid, close),
- ?line receive disk_log_stopped_ok -> ok end,
- ?line sync_do(Pid, terminate),
- ?line {ok,<<>>} = file:read_file(File ++ ".1"),
- ?line del(File, No),
- ?line Q = qlen(),
- ?line true = (P0 == pps()),
+ spawn(Fun),
+ ok = sync_do(Pid, close),
+ receive disk_log_stopped_ok -> ok end,
+ sync_do(Pid, terminate),
+ {ok,<<>>} = file:read_file(File ++ ".1"),
+ del(File, No),
+ Q = qlen(),
+ true = (P0 == pps()),
ok.
-unblock(suite) -> [];
-unblock(doc) ->
- ["Test unblock/1."];
+%% Test unblock/1.
unblock(Conf) when is_list(Conf) ->
Dir = ?privdir(Conf),
File = filename:join(Dir, "n.LOG"),
No = 1,
- ?line {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
- {size, {100,No}}, {notify, true},
- {format, external}]),
- ?line ok = disk_log:block(n),
- ?line spawn_link(?MODULE, try_unblock, [n]),
- ?line timer:sleep(100),
- ?line disk_log:close(n),
- ?line del(File, No).
+ {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
+ {size, {100,No}}, {notify, true},
+ {format, external}]),
+ ok = disk_log:block(n),
+ spawn_link(?MODULE, try_unblock, [n]),
+ timer:sleep(100),
+ disk_log:close(n),
+ del(File, No).
try_unblock(Log) ->
- ?line Error = {error, {not_blocked_by_pid, n}} = disk_log:unblock(Log),
- ?line "The disk log" ++ _ = format_error(Error).
+ Error = {error, {not_blocked_by_pid, n}} = disk_log:unblock(Log),
+ "The disk log" ++ _ = format_error(Error).
-open_overwrite(suite) -> [];
-open_overwrite(doc) ->
- ["Test open/1 when old files exist."];
+%% Test open/1 when old files exist.
open_overwrite(Conf) when is_list(Conf) ->
Dir = ?privdir(Conf),
- ?line File = filename:join(Dir, "n.LOG"),
- ?line No = 4,
- ?line del(File, No), % cleanup
+ File = filename:join(Dir, "n.LOG"),
+ No = 4,
+ del(File, No), % cleanup
- % read write
- ?line First = "n.LOG.1",
- ?line make_file(Dir, First, 8),
+ %% read write
+ First = "n.LOG.1",
+ make_file(Dir, First, 8),
- ?line Error1 = {error, {not_a_log_file, _}} =
+ Error1 = {error, {not_a_log_file, _}} =
disk_log:open([{name, n}, {file, File}, {type, wrap},
{format, internal}, {size, {100, No}}]),
- ?line "The file" ++ _ = format_error(Error1),
- ?line del(File, No),
+ "The file" ++ _ = format_error(Error1),
+ del(File, No),
- ?line make_file(Dir, First, 4),
+ make_file(Dir, First, 4),
- ?line {error, {not_a_log_file, _}} =
+ {error, {not_a_log_file, _}} =
disk_log:open([{name, n}, {file, File}, {type, wrap},
{format, internal}, {size, {100, No}}]),
- ?line del(File, No),
+ del(File, No),
- ?line make_file(Dir, First, 0),
+ make_file(Dir, First, 0),
- ?line {error, {not_a_log_file, _}} =
+ {error, {not_a_log_file, _}} =
disk_log:open([{name, n}, {file, File}, {type, wrap},
{format, internal}, {size, {100, No}}]),
- % read only
- ?line make_file(Dir, First, 6),
+ %% read only
+ make_file(Dir, First, 6),
- ?line {error, {not_a_log_file, _}} =
+ {error, {not_a_log_file, _}} =
disk_log:open([{name, n}, {file, File}, {type, wrap},{mode, read_only},
{format, internal}, {size, {100, No}}]),
- ?line del(File, No),
+ del(File, No),
- ?line make_file(Dir, First, 0),
+ make_file(Dir, First, 0),
- ?line {error, {not_a_log_file, _}} =
+ {error, {not_a_log_file, _}} =
disk_log:open([{name, n}, {file, File},{type, wrap},
{mode, read_only}, {format, internal},
{size, {100, No}}]),
- ?line del(File, No),
-
- ?line {error, _} = disk_log:open([{name, n}, {file, File}, {type, wrap},
- {mode, read_only},
- {format, internal},{size, {100, No}}]),
+ del(File, No),
+
+ {error, _} = disk_log:open([{name, n}, {file, File}, {type, wrap},
+ {mode, read_only},
+ {format, internal},{size, {100, No}}]),
file:delete(File),
- ?line {ok,n} = disk_log:open([{name,n},{file,File},
- {mode,read_write},{type,halt}]),
- ?line ok = disk_log:close(n),
- ?line ok = unwritable(File),
- ?line {error, {file_error, File, _}} =
- disk_log:open([{name,n},{file,File},{mode,read_write},{type,halt}]),
- ?line ok = writable(File),
+ {ok,n} = disk_log:open([{name,n},{file,File},
+ {mode,read_write},{type,halt}]),
+ ok = disk_log:close(n),
+ ok = unwritable(File),
+ {error, {file_error, File, _}} =
+ disk_log:open([{name,n},{file,File},{mode,read_write},{type,halt}]),
+ ok = writable(File),
file:delete(File),
- ?line {ok,n} = disk_log:open([{name,n},{file,File},{format,external},
- {mode,read_write},{type,halt}]),
- ?line ok = disk_log:close(n),
- ?line ok = unwritable(File),
- ?line {error, {file_error, File, _}} =
+ {ok,n} = disk_log:open([{name,n},{file,File},{format,external},
+ {mode,read_write},{type,halt}]),
+ ok = disk_log:close(n),
+ ok = unwritable(File),
+ {error, {file_error, File, _}} =
disk_log:open([{name,n},{file,File},{format,external},
{mode,read_write},{type,halt}]),
- ?line ok = writable(File),
+ ok = writable(File),
file:delete(File),
ok.
@@ -1953,424 +1892,412 @@ make_file(Dir, File, N) ->
end,
ok = file:close(F).
-open_size(suite) -> [];
-open_size(doc) ->
- ["Test open/1 option size."];
+%% Test open/1 option size.
open_size(Conf) when is_list(Conf) ->
- ?line Dir = ?privdir(Conf),
- ?line File = filename:join(Dir, "n.LOG"),
+ Dir = ?privdir(Conf),
+ File = filename:join(Dir, "n.LOG"),
- ?line No = 4,
- ?line file:delete(File),
- ?line del(File, No), % cleanup
+ No = 4,
+ file:delete(File),
+ del(File, No), % cleanup
%% missing size option
- ?line {error, {badarg, size}} =
+ {error, {badarg, size}} =
disk_log:open([{name, n}, {file, File}, {type, wrap},
{format, internal}]),
- ?line {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
+ {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
{format, internal},{size, {100, No}}]),
- ?line B = mk_bytes(60),
- ?line ok = disk_log:log_terms(n, [B, B, B, B]),
- ?line ok = disk_log:sync(n),
- ?line ok = disk_log:block(n),
+ B = mk_bytes(60),
+ ok = disk_log:log_terms(n, [B, B, B, B]),
+ ok = disk_log:sync(n),
+ ok = disk_log:block(n),
%% size option does not match existing size file, read_only
- ?line Error1 = {error, {size_mismatch, _, _}} =
+ Error1 = {error, {size_mismatch, _, _}} =
disk_log:open([{name, nn}, {file, File}, {type, wrap},
{mode, read_only}, {format, internal},
{size, {100, No + 1}}]),
- ?line "The given size" ++ _ = format_error(Error1),
- ?line {ok, nn} = disk_log:open([{name, nn}, {file, File}, {type, wrap},
+ "The given size" ++ _ = format_error(Error1),
+ {ok, nn} = disk_log:open([{name, nn}, {file, File}, {type, wrap},
{mode, read_only},
{format, internal},{size, {100, No}}]),
- ?line [_, _, _, _] = get_all_terms1(nn, start, []),
- ?line disk_log:close(nn),
+ [_, _, _, _] = get_all_terms1(nn, start, []),
+ disk_log:close(nn),
- ?line ok = disk_log:unblock(n),
- ?line ok = disk_log:close(n),
+ ok = disk_log:unblock(n),
+ ok = disk_log:close(n),
%% size option does not match existing size file, read_write
- ?line {error, {size_mismatch, _, _}} =
+ {error, {size_mismatch, _, _}} =
disk_log:open([{name, nn}, {file, File}, {type, wrap},
{format, internal}, {size, {100, No + 1}}]),
%% size option does not match existing size file, truncating
- ?line {ok, nn} =
+ {ok, nn} =
disk_log:open([{name, nn}, {file, File}, {type, wrap},
{repair, truncate}, {format, internal},
{size, {100, No + 1}}]),
- ?line ok = disk_log:close(nn),
+ ok = disk_log:close(nn),
- ?line del(File, No),
+ del(File, No),
ok.
-open_truncate(suite) -> [];
-open_truncate(doc) ->
- ["Test open/1 with {repair, truncate}."];
+%% Test open/1 with {repair, truncate}.
open_truncate(Conf) when is_list(Conf) ->
- ?line Dir = ?privdir(Conf),
- ?line File = filename:join(Dir, "n.LOG"),
- ?line No = 4,
- ?line del(File, No), % cleanup
-
- ?line {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
- {format, internal},{size, {100, No}}]),
- ?line B = mk_bytes(60),
- ?line ok = disk_log:log_terms(n, [B, B, B, B]),
- ?line ok = disk_log:close(n),
- ?line {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
- {repair,truncate},
- {format, internal},{size, {100, No}}]),
- ?line ok = disk_log:close(n),
- ?line [] = get_all_terms(n, File, wrap),
- ?line del(File, No),
+ Dir = ?privdir(Conf),
+ File = filename:join(Dir, "n.LOG"),
+ No = 4,
+ del(File, No), % cleanup
+
+ {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
+ {format, internal},{size, {100, No}}]),
+ B = mk_bytes(60),
+ ok = disk_log:log_terms(n, [B, B, B, B]),
+ ok = disk_log:close(n),
+ {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
+ {repair,truncate},
+ {format, internal},{size, {100, No}}]),
+ ok = disk_log:close(n),
+ [] = get_all_terms(n, File, wrap),
+ del(File, No),
ok.
-
-open_error(suite) -> [];
-open_error(doc) ->
- ["Try some invalid open/1 options."];
+
+%% Try some invalid open/1 options.
open_error(Conf) when is_list(Conf) ->
- ?line Dir = ?privdir(Conf),
+ Dir = ?privdir(Conf),
- ?line File = filename:join(Dir, "n.LOG"),
- ?line No = 4,
- ?line del(File, No), % cleanup
+ File = filename:join(Dir, "n.LOG"),
+ No = 4,
+ del(File, No), % cleanup
- ?line {error, {badarg, name}} = disk_log:open([{file, File}]),
- ?line {error, {badarg, file}} = disk_log:open([{name,{foo,bar}}]),
- ?line {error, {badarg, [{foo,bar}]}} = disk_log:open([{foo,bar}]),
+ {error, {badarg, name}} = disk_log:open([{file, File}]),
+ {error, {badarg, file}} = disk_log:open([{name,{foo,bar}}]),
+ {error, {badarg, [{foo,bar}]}} = disk_log:open([{foo,bar}]),
%% external logs, read_only.
- ?line {error, {file_error, _, enoent}} =
+ {error, {file_error, _, enoent}} =
disk_log:open([{name, n}, {file, File}, {type, wrap},
{size, {100,No}},
{format, external}, {mode, read_only}]),
- ?line Error5 = {error, {file_error, _, enoent}} =
+ Error5 = {error, {file_error, _, enoent}} =
disk_log:open([{name, n}, {file, File}, {type, halt},
{size, 100},
{format, external}, {mode, read_only}]),
- ?line true = lists:prefix("\"" ++ File, format_error(Error5)),
+ true = lists:prefix("\"" ++ File, format_error(Error5)),
- ?line {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
+ {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
{format, external},{size, {100, No}}]),
%% Already owner, ignored.
- ?line {ok, n} =
+ {ok, n} =
disk_log:open([{name, n}, {file, File}, {type, wrap},
{format, external}, {size, {100, No}}]),
- ?line Error2 = {error, {name_already_open, n}} =
+ Error2 = {error, {name_already_open, n}} =
disk_log:open([{name, n}, {file, another_file}, {type, wrap},
{format, external}, {size, {100, No}}]),
- ?line "The disk log" ++ _ = format_error(Error2),
- ?line Error1 = {error, {arg_mismatch, notify, false, true}} =
+ "The disk log" ++ _ = format_error(Error2),
+ Error1 = {error, {arg_mismatch, notify, false, true}} =
disk_log:open([{name, n}, {file, File}, {type, wrap},
{format, external}, {size, {100, No}}, {notify, true}]),
- ?line "The value" ++ _ = format_error(Error1),
- ?line Error3 = {error, {open_read_write, n}} =
+ "The value" ++ _ = format_error(Error1),
+ Error3 = {error, {open_read_write, n}} =
disk_log:open([{name, n}, {file, File}, {type, wrap},
{mode, read_only},
{format, external}, {size, {100, No}}]),
- ?line "The disk log" ++ _ = format_error(Error3),
- ?line {error, {badarg, size}} =
+ "The disk log" ++ _ = format_error(Error3),
+ {error, {badarg, size}} =
disk_log:open([{name, n}, {file, File}, {type, halt},
{format, external}, {size, {100, No}}]),
- ?line {error, {arg_mismatch, type, wrap, halt}} =
+ {error, {arg_mismatch, type, wrap, halt}} =
disk_log:open([{name, n}, {file, File}, {type, halt},
{format, external}]),
- ?line {error, {arg_mismatch, format, external, internal}} =
+ {error, {arg_mismatch, format, external, internal}} =
disk_log:open([{name, n}, {file, File}, {type, wrap},
{format, internal}, {size, {100, No}}]),
- ?line {error, {arg_mismatch, repair, true, false}} =
+ {error, {arg_mismatch, repair, true, false}} =
disk_log:open([{name, n}, {file, File}, {type, wrap},
{format, external}, {repair, false}]),
- ?line {error, {size_mismatch, {100,4}, {1000,4}}} =
+ {error, {size_mismatch, {100,4}, {1000,4}}} =
disk_log:open([{name, n}, {file, File}, {type, wrap},
{format, external}, {size, {1000, No}}]),
- ?line {error, {arg_mismatch, head, none, _}} =
+ {error, {arg_mismatch, head, none, _}} =
disk_log:open([{name, n}, {file, File}, {type, wrap},
{head, "header"},
{format, external}, {size, {100, No}}]),
- ?line {error, {badarg, size}} =
+ {error, {badarg, size}} =
disk_log:open([{name, n}, {file, File}, {type, wrap},
{format, external}, {size, 100}]),
- ?line ok = disk_log:close(n),
+ ok = disk_log:close(n),
- ?line {ok, n} =
+ {ok, n} =
disk_log:open([{name, n}, {file, File}, {type, wrap},
{mode, read_only},
{format, external}, {size, {100, No}}]),
- ?line Error4 = {error, {open_read_only, n}} =
+ Error4 = {error, {open_read_only, n}} =
disk_log:open([{name, n}, {file, File}, {type, wrap},
{mode, read_write},
{format, external}, {size, {100, No}}]),
- ?line "The disk log" ++ _ = format_error(Error4),
- ?line ok = disk_log:close(n),
+ "The disk log" ++ _ = format_error(Error4),
+ ok = disk_log:close(n),
- ?line del(File, No).
+ del(File, No).
-close_race(suite) -> [];
-close_race(doc) ->
- ["Do something quickly after close/1"];
+%% Do something quickly after close/1.
close_race(Conf) when is_list(Conf) ->
Dir = ?privdir(Conf),
- ?line File = filename:join(Dir, "n.LOG"),
- ?line No = 1,
- ?line del(File, No), % cleanup
- ?line {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
- {size, {100,No}}, {notify, true},
- {format, internal}]),
- ?line ok = disk_log:close(n),
- ?line Error1 = {error, no_such_log} = disk_log:close(n),
- ?line "There is no disk" ++ _ = format_error(Error1),
-
- % Pid1 blocks, Pid2 closes without being suspended.
- ?line Pid1 = spawn_link(?MODULE, lserv, [n]),
- ?line Pid2 = spawn_link(?MODULE, lserv, [n]),
- ?line {ok, n} = sync_do(Pid1, {open, File}),
- ?line {ok, n} = sync_do(Pid2, {open, File}),
- ?line ok = sync_do(Pid1, block),
- ?line [{_, false}, {_, false}] = sync_do(Pid1, owners),
- ?line ok = sync_do(Pid2, close),
- ?line [{_, false}] = sync_do(Pid1, owners),
- ?line ok = sync_do(Pid1, close),
- ?line sync_do(Pid1, terminate),
- ?line sync_do(Pid2, terminate),
- ?line {error, no_such_log} = disk_log:info(n),
-
- % Pid3 blocks, Pid3 closes. Pid4 should still be ablo to use log.
- ?line Pid3 = spawn_link(?MODULE, lserv, [n]),
- ?line Pid4 = spawn_link(?MODULE, lserv, [n]),
- ?line {ok, n} = sync_do(Pid3, {open, File}),
- ?line {ok, n} = sync_do(Pid4, {open, File}),
- ?line ok = sync_do(Pid3, block),
- ?line ok = sync_do(Pid3, close),
- ?line [{_Pid4, false}] = sync_do(Pid4, owners),
- ?line sync_do(Pid3, terminate),
- ?line sync_do(Pid4, terminate),
- ?line {error, no_such_log} = disk_log:info(n),
-
- % Pid5 blocks, Pid5 terminates. Pid6 should still be ablo to use log.
- ?line Pid5 = spawn_link(?MODULE, lserv, [n]),
- ?line Pid6 = spawn_link(?MODULE, lserv, [n]),
- ?line {ok, n} = sync_do(Pid5, {open, File}),
- ?line {ok, n} = sync_do(Pid6, {open, File}),
- ?line ok = sync_do(Pid5, block),
- ?line sync_do(Pid5, terminate),
- ?line [{_Pid6, false}] = sync_do(Pid6, owners),
- ?line sync_do(Pid6, terminate),
- ?line {error, no_such_log} = disk_log:info(n),
- ?line del(File, No), % cleanup
+ File = filename:join(Dir, "n.LOG"),
+ No = 1,
+ del(File, No), % cleanup
+ {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
+ {size, {100,No}}, {notify, true},
+ {format, internal}]),
+ ok = disk_log:close(n),
+ Error1 = {error, no_such_log} = disk_log:close(n),
+ "There is no disk" ++ _ = format_error(Error1),
+
+ %% Pid1 blocks, Pid2 closes without being suspended.
+ Pid1 = spawn_link(?MODULE, lserv, [n]),
+ Pid2 = spawn_link(?MODULE, lserv, [n]),
+ {ok, n} = sync_do(Pid1, {open, File}),
+ {ok, n} = sync_do(Pid2, {open, File}),
+ ok = sync_do(Pid1, block),
+ [{_, false}, {_, false}] = sync_do(Pid1, owners),
+ ok = sync_do(Pid2, close),
+ [{_, false}] = sync_do(Pid1, owners),
+ ok = sync_do(Pid1, close),
+ sync_do(Pid1, terminate),
+ sync_do(Pid2, terminate),
+ {error, no_such_log} = disk_log:info(n),
+
+ %% Pid3 blocks, Pid3 closes. Pid4 should still be ablo to use log.
+ Pid3 = spawn_link(?MODULE, lserv, [n]),
+ Pid4 = spawn_link(?MODULE, lserv, [n]),
+ {ok, n} = sync_do(Pid3, {open, File}),
+ {ok, n} = sync_do(Pid4, {open, File}),
+ ok = sync_do(Pid3, block),
+ ok = sync_do(Pid3, close),
+ [{_Pid4, false}] = sync_do(Pid4, owners),
+ sync_do(Pid3, terminate),
+ sync_do(Pid4, terminate),
+ {error, no_such_log} = disk_log:info(n),
+
+ %% Pid5 blocks, Pid5 terminates. Pid6 should still be ablo to use log.
+ Pid5 = spawn_link(?MODULE, lserv, [n]),
+ Pid6 = spawn_link(?MODULE, lserv, [n]),
+ {ok, n} = sync_do(Pid5, {open, File}),
+ {ok, n} = sync_do(Pid6, {open, File}),
+ ok = sync_do(Pid5, block),
+ sync_do(Pid5, terminate),
+ [{_Pid6, false}] = sync_do(Pid6, owners),
+ sync_do(Pid6, terminate),
+ {error, no_such_log} = disk_log:info(n),
+ del(File, No), % cleanup
ok.
-close_block(suite) -> [];
-close_block(doc) ->
- ["Block, unblock, close, terminate."];
+%% Block, unblock, close, terminate.
close_block(Conf) when is_list(Conf) ->
Dir = ?privdir(Conf),
- ?line File = filename:join(Dir, "n.LOG"),
+ File = filename:join(Dir, "n.LOG"),
No = 1,
del(File, No), % cleanup
P0 = pps(),
%% One of two owners terminates.
- ?line Pid1 = spawn_link(?MODULE, lserv, [n]),
- ?line Pid2 = spawn_link(?MODULE, lserv, [n]),
- ?line {ok, n} = sync_do(Pid1, {open, File}),
- ?line {ok, n} = sync_do(Pid2, {open, File}),
- ?line [_, _] = sync_do(Pid1, owners),
- ?line [_, _] = sync_do(Pid2, owners),
- ?line 0 = sync_do(Pid1, users),
- ?line 0 = sync_do(Pid2, users),
- ?line sync_do(Pid1, terminate),
- ?line [_] = sync_do(Pid2, owners),
- ?line 0 = sync_do(Pid2, users),
- ?line sync_do(Pid2, terminate),
- ?line {error, no_such_log} = disk_log:info(n),
- ?line true = (P0 == pps()),
+ Pid1 = spawn_link(?MODULE, lserv, [n]),
+ Pid2 = spawn_link(?MODULE, lserv, [n]),
+ {ok, n} = sync_do(Pid1, {open, File}),
+ {ok, n} = sync_do(Pid2, {open, File}),
+ [_, _] = sync_do(Pid1, owners),
+ [_, _] = sync_do(Pid2, owners),
+ 0 = sync_do(Pid1, users),
+ 0 = sync_do(Pid2, users),
+ sync_do(Pid1, terminate),
+ [_] = sync_do(Pid2, owners),
+ 0 = sync_do(Pid2, users),
+ sync_do(Pid2, terminate),
+ {error, no_such_log} = disk_log:info(n),
+ true = (P0 == pps()),
%% Users terminate (no link...).
- ?line Pid3 = spawn_link(?MODULE, lserv, [n]),
- ?line Pid4 = spawn_link(?MODULE, lserv, [n]),
- ?line {ok, n} = sync_do(Pid3, {open, File, none}),
- ?line {ok, n} = sync_do(Pid4, {open, File, none}),
- ?line [] = sync_do(Pid3, owners),
- ?line [] = sync_do(Pid4, owners),
- ?line 2 = sync_do(Pid3, users),
- ?line 2 = sync_do(Pid4, users),
- ?line sync_do(Pid3, terminate),
- ?line [] = sync_do(Pid4, owners),
- ?line 2 = sync_do(Pid4, users),
- ?line sync_do(Pid4, terminate),
- ?line disk_log:close(n),
- ?line disk_log:close(n),
- ?line {error, no_such_log} = disk_log:info(n),
- ?line true = (P0 == pps()),
-
- % Blocking owner terminates.
- ?line Pid5 = spawn_link(?MODULE, lserv, [n]),
- ?line {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
- {linkto, none},{size, {100,No}},
- {format, external}]),
- ?line {ok, n} = sync_do(Pid5, {open, File}),
- ?line ok = sync_do(Pid5, block),
- ?line {blocked, true} = status(n),
- ?line [_] = owners(n),
- ?line sync_do(Pid5, terminate),
- ?line ok = status(n),
- ?line [] = owners(n),
- ?line 1 = users(n),
- ?line ok = disk_log:close(n),
- ?line {error, no_such_log} = disk_log:info(n),
- ?line true = (P0 == pps()),
-
- % Blocking user terminates.
- ?line Pid6 = spawn_link(?MODULE, lserv, [n]),
- ?line {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
- {size, {100,No}}, {format, external}]),
- ?line {ok, n} = sync_do(Pid6, {open, File, none}),
- ?line ok = sync_do(Pid6, block),
- ?line {blocked, true} = status(n),
- ?line [_] = owners(n),
- ?line 1 = users(n),
- ?line sync_do(Pid6, terminate), % very silently...
- ?line ok = status(n),
- ?line [_] = owners(n),
- ?line 1 = users(n),
- ?line ok = disk_log:close(n),
- ?line [] = owners(n),
- ?line 1 = users(n),
- ?line ok = disk_log:close(n),
- ?line {error, no_such_log} = disk_log:info(n),
- ?line true = (P0 == pps()),
-
- % Blocking owner terminates.
- ?line Pid7 = spawn_link(?MODULE, lserv, [n]),
- ?line {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
- {linkto, none},
- {size, {100,No}}, {format, external}]),
- ?line {ok, n} = sync_do(Pid7, {open, File}),
- ?line ok = sync_do(Pid7, block),
- ?line {blocked, true} = status(n),
- ?line [_] = owners(n),
- ?line 1 = users(n),
- ?line sync_do(Pid7, terminate),
- ?line ok = status(n),
- ?line [] = owners(n),
- ?line 1 = users(n),
- ?line ok = disk_log:close(n),
- ?line {error, no_such_log} = disk_log:info(n),
- ?line true = (P0 == pps()),
+ Pid3 = spawn_link(?MODULE, lserv, [n]),
+ Pid4 = spawn_link(?MODULE, lserv, [n]),
+ {ok, n} = sync_do(Pid3, {open, File, none}),
+ {ok, n} = sync_do(Pid4, {open, File, none}),
+ [] = sync_do(Pid3, owners),
+ [] = sync_do(Pid4, owners),
+ 2 = sync_do(Pid3, users),
+ 2 = sync_do(Pid4, users),
+ sync_do(Pid3, terminate),
+ [] = sync_do(Pid4, owners),
+ 2 = sync_do(Pid4, users),
+ sync_do(Pid4, terminate),
+ disk_log:close(n),
+ disk_log:close(n),
+ {error, no_such_log} = disk_log:info(n),
+ true = (P0 == pps()),
+
+ %% Blocking owner terminates.
+ Pid5 = spawn_link(?MODULE, lserv, [n]),
+ {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
+ {linkto, none},{size, {100,No}},
+ {format, external}]),
+ {ok, n} = sync_do(Pid5, {open, File}),
+ ok = sync_do(Pid5, block),
+ {blocked, true} = status(n),
+ [_] = owners(n),
+ sync_do(Pid5, terminate),
+ ok = status(n),
+ [] = owners(n),
+ 1 = users(n),
+ ok = disk_log:close(n),
+ {error, no_such_log} = disk_log:info(n),
+ true = (P0 == pps()),
+
+ %% Blocking user terminates.
+ Pid6 = spawn_link(?MODULE, lserv, [n]),
+ {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
+ {size, {100,No}}, {format, external}]),
+ {ok, n} = sync_do(Pid6, {open, File, none}),
+ ok = sync_do(Pid6, block),
+ {blocked, true} = status(n),
+ [_] = owners(n),
+ 1 = users(n),
+ sync_do(Pid6, terminate), % very silently...
+ ok = status(n),
+ [_] = owners(n),
+ 1 = users(n),
+ ok = disk_log:close(n),
+ [] = owners(n),
+ 1 = users(n),
+ ok = disk_log:close(n),
+ {error, no_such_log} = disk_log:info(n),
+ true = (P0 == pps()),
+
+ %% Blocking owner terminates.
+ Pid7 = spawn_link(?MODULE, lserv, [n]),
+ {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
+ {linkto, none},
+ {size, {100,No}}, {format, external}]),
+ {ok, n} = sync_do(Pid7, {open, File}),
+ ok = sync_do(Pid7, block),
+ {blocked, true} = status(n),
+ [_] = owners(n),
+ 1 = users(n),
+ sync_do(Pid7, terminate),
+ ok = status(n),
+ [] = owners(n),
+ 1 = users(n),
+ ok = disk_log:close(n),
+ {error, no_such_log} = disk_log:info(n),
+ true = (P0 == pps()),
%% Two owners, the blocking one terminates.
- ?line Pid8 = spawn_link(?MODULE, lserv, [n]),
- ?line Pid9 = spawn_link(?MODULE, lserv, [n]),
- ?line {ok, n} = sync_do(Pid8, {open, File}),
- ?line {ok, n} = sync_do(Pid9, {open, File}),
- ?line ok = sync_do(Pid8, block),
- ?line {blocked, true} = status(n),
- ?line sync_do(Pid8, terminate),
- ?line ok = status(n),
- ?line [_] = sync_do(Pid9, owners),
- ?line 0 = sync_do(Pid9, users),
- ?line sync_do(Pid9, terminate),
- ?line {error, no_such_log} = disk_log:info(n),
- ?line true = (P0 == pps()),
-
- % Blocking user closes.
- ?line Pid10 = spawn_link(?MODULE, lserv, [n]),
- ?line {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
- {size, {100,No}}, {format, external}]),
- ?line {ok, n} = sync_do(Pid10, {open, File, none}),
- ?line ok = sync_do(Pid10, block),
- ?line {blocked, true} = status(n),
- ?line [_] = owners(n),
- ?line 1 = users(n),
- ?line ok = sync_do(Pid10, close),
- ?line ok = status(n),
- ?line [_] = owners(n),
- ?line 0 = users(n),
- ?line ok = disk_log:close(n),
- ?line sync_do(Pid10, terminate),
- ?line {error, no_such_log} = disk_log:info(n),
- ?line true = (P0 == pps()),
-
- % Blocking user unblocks and closes.
- ?line Pid11 = spawn_link(?MODULE, lserv, [n]),
- ?line {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
- {size, {100,No}}, {format, external}]),
- ?line {ok, n} = sync_do(Pid11, {open, File, none}),
- ?line ok = sync_do(Pid11, block),
- ?line {blocked, true} = status(n),
- ?line [_] = owners(n),
- ?line 1 = users(n),
- ?line ok = sync_do(Pid11, unblock),
- ?line ok = sync_do(Pid11, close),
- ?line ok = status(n),
- ?line [_] = owners(n),
- ?line 0 = users(n),
- ?line ok = disk_log:close(n),
- ?line {error, no_such_log} = disk_log:info(n),
- ?line sync_do(Pid11, terminate),
- ?line true = (P0 == pps()),
-
- % Blocking owner closes.
- ?line Pid12 = spawn_link(?MODULE, lserv, [n]),
- ?line {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
- {linkto, none},
- {size, {100,No}}, {format, external}]),
- ?line {ok, n} = sync_do(Pid12, {open, File}),
- ?line ok = sync_do(Pid12, block),
- ?line {blocked, true} = status(n),
- ?line [_] = owners(n),
- ?line 1 = users(n),
- ?line ok = sync_do(Pid12, close),
- ?line ok = status(n),
- ?line [] = owners(n),
- ?line 1 = users(n),
- ?line ok = disk_log:close(n),
- ?line {error, no_such_log} = disk_log:info(n),
- ?line sync_do(Pid12, terminate),
- ?line true = (P0 == pps()),
-
- % Blocking owner unblocks and closes.
- ?line Pid13 = spawn_link(?MODULE, lserv, [n]),
- ?line {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
- {linkto, none},
- {size, {100,No}}, {format, external}]),
- ?line {ok, n} = sync_do(Pid13, {open, File}),
- ?line ok = sync_do(Pid13, block),
- ?line {blocked, true} = status(n),
- ?line [_] = owners(n),
- ?line 1 = users(n),
- ?line ok = sync_do(Pid13, unblock),
- ?line ok = sync_do(Pid13, close),
- ?line ok = status(n),
- ?line [] = owners(n),
- ?line 1 = users(n),
- ?line ok = disk_log:close(n),
- ?line {error, no_such_log} = disk_log:info(n),
- ?line sync_do(Pid13, terminate),
- ?line true = (P0 == pps()),
+ Pid8 = spawn_link(?MODULE, lserv, [n]),
+ Pid9 = spawn_link(?MODULE, lserv, [n]),
+ {ok, n} = sync_do(Pid8, {open, File}),
+ {ok, n} = sync_do(Pid9, {open, File}),
+ ok = sync_do(Pid8, block),
+ {blocked, true} = status(n),
+ sync_do(Pid8, terminate),
+ ok = status(n),
+ [_] = sync_do(Pid9, owners),
+ 0 = sync_do(Pid9, users),
+ sync_do(Pid9, terminate),
+ {error, no_such_log} = disk_log:info(n),
+ true = (P0 == pps()),
+
+ %% Blocking user closes.
+ Pid10 = spawn_link(?MODULE, lserv, [n]),
+ {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
+ {size, {100,No}}, {format, external}]),
+ {ok, n} = sync_do(Pid10, {open, File, none}),
+ ok = sync_do(Pid10, block),
+ {blocked, true} = status(n),
+ [_] = owners(n),
+ 1 = users(n),
+ ok = sync_do(Pid10, close),
+ ok = status(n),
+ [_] = owners(n),
+ 0 = users(n),
+ ok = disk_log:close(n),
+ sync_do(Pid10, terminate),
+ {error, no_such_log} = disk_log:info(n),
+ true = (P0 == pps()),
+
+ %% Blocking user unblocks and closes.
+ Pid11 = spawn_link(?MODULE, lserv, [n]),
+ {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
+ {size, {100,No}}, {format, external}]),
+ {ok, n} = sync_do(Pid11, {open, File, none}),
+ ok = sync_do(Pid11, block),
+ {blocked, true} = status(n),
+ [_] = owners(n),
+ 1 = users(n),
+ ok = sync_do(Pid11, unblock),
+ ok = sync_do(Pid11, close),
+ ok = status(n),
+ [_] = owners(n),
+ 0 = users(n),
+ ok = disk_log:close(n),
+ {error, no_such_log} = disk_log:info(n),
+ sync_do(Pid11, terminate),
+ true = (P0 == pps()),
+
+ %% Blocking owner closes.
+ Pid12 = spawn_link(?MODULE, lserv, [n]),
+ {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
+ {linkto, none},
+ {size, {100,No}}, {format, external}]),
+ {ok, n} = sync_do(Pid12, {open, File}),
+ ok = sync_do(Pid12, block),
+ {blocked, true} = status(n),
+ [_] = owners(n),
+ 1 = users(n),
+ ok = sync_do(Pid12, close),
+ ok = status(n),
+ [] = owners(n),
+ 1 = users(n),
+ ok = disk_log:close(n),
+ {error, no_such_log} = disk_log:info(n),
+ sync_do(Pid12, terminate),
+ true = (P0 == pps()),
+
+ %% Blocking owner unblocks and closes.
+ Pid13 = spawn_link(?MODULE, lserv, [n]),
+ {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
+ {linkto, none},
+ {size, {100,No}}, {format, external}]),
+ {ok, n} = sync_do(Pid13, {open, File}),
+ ok = sync_do(Pid13, block),
+ {blocked, true} = status(n),
+ [_] = owners(n),
+ 1 = users(n),
+ ok = sync_do(Pid13, unblock),
+ ok = sync_do(Pid13, close),
+ ok = status(n),
+ [] = owners(n),
+ 1 = users(n),
+ ok = disk_log:close(n),
+ {error, no_such_log} = disk_log:info(n),
+ sync_do(Pid13, terminate),
+ true = (P0 == pps()),
del(File, No), % cleanup
ok.
-close_deadlock(suite) -> [];
-close_deadlock(doc) ->
- ["OTP-4745. Deadlock with just an ordinary log could happen."];
+%% OTP-4745. Deadlock with just an ordinary log could happen.
close_deadlock(Conf) when is_list(Conf) ->
- ?line true = is_alive(),
+ true = is_alive(),
- ?line PrivDir = ?privdir(Conf),
+ PrivDir = ?privdir(Conf),
- ?line F1 = filename:join(PrivDir, "a.LOG"),
- ?line file:delete(F1),
+ F1 = filename:join(PrivDir, "a.LOG"),
+ file:delete(F1),
Self = self(),
%% One process opens the log at the same time as another process
@@ -2378,11 +2305,11 @@ close_deadlock(Conf) when is_list(Conf) ->
Name = a,
Fun = fun() -> open_close(Self, Name, F1) end,
P = spawn(Fun),
- ?line receive {P, Name} -> ok end,
- ?line {ok, L} = disk_log:open([{name,Name},{file,F1}]),
- ?line ok = disk_log:close(L),
- ?line receive {P, done} -> ok end,
- ?line file:delete(F1),
+ receive {P, Name} -> ok end,
+ {ok, L} = disk_log:open([{name,Name},{file,F1}]),
+ ok = disk_log:close(L),
+ receive {P, done} -> ok end,
+ file:delete(F1),
%% One process opens the log at the same time as another process
%% closes the log due to file error while truncating.
@@ -2390,38 +2317,38 @@ close_deadlock(Conf) when is_list(Conf) ->
%% "work". When it works, as it seems to do right now :), the
%% disk_log_server gets {error, no_such_log}, receives the EXIT
%% message caused by truncate, and tries to open the log again.
- ?line No = 4,
- ?line LDir = F1 ++ ".2",
- ?line file:del_dir(LDir),
- ?line del(F1, No),
- ?line ok = file:make_dir(LDir),
+ No = 4,
+ LDir = F1 ++ ".2",
+ file:del_dir(LDir),
+ del(F1, No),
+ ok = file:make_dir(LDir),
Fun2 = fun() -> open_truncate(Self, Name, F1, No) end,
P2 = spawn(Fun2),
- ?line receive {P2, Name} -> ok end,
- ?line {ok, L} = disk_log:open([{name, Name}, {file, F1}, {type, wrap},
- {format, external}]),
+ receive {P2, Name} -> ok end,
+ {ok, L} = disk_log:open([{name, Name}, {file, F1}, {type, wrap},
+ {format, external}]),
%% Note: truncate causes the disk log process to terminate. One
%% cannot say if open above happened before, after, or during the
%% termination. The link to the owner is removed before termination.
- ?line case disk_log:close(L) of
- ok -> ok;
- {error,no_such_log} ->
- ok
- end,
- ?line receive {P2, done} -> ok end,
- ?line del(F1, No),
- ?line file:del_dir(LDir),
+ case disk_log:close(L) of
+ ok -> ok;
+ {error,no_such_log} ->
+ ok
+ end,
+ receive {P2, done} -> ok end,
+ del(F1, No),
+ file:del_dir(LDir),
%% To the same thing, this time using distributed logs.
%% (Does not seem to work very well, unfortunately.)
FunD = fun() -> open_close_dist(Self, Name, F1) end,
PD = spawn(FunD),
receive {PD, Name} -> ok end,
- ?line {[_], []} = disk_log:open([{name,Name},{file,F1},
- {distributed,[node()]}]),
- ?line ok = disk_log:close(L),
+ {[_], []} = disk_log:open([{name,Name},{file,F1},
+ {distributed,[node()]}]),
+ ok = disk_log:close(L),
receive {PD, done} -> ok end,
- ?line file:delete(F1),
+ file:delete(F1),
ok.
@@ -2467,7 +2394,7 @@ sync_do(Pid, Req) ->
end.
lserv(Log) ->
- ?line receive
+ receive
{From, {open, File}} ->
From ! disk_log:open([{name, Log}, {file, File}, {type, wrap},
{size, {100,1}}, {format, external}]);
@@ -2534,664 +2461,652 @@ lserv(Log) ->
lserv(Log).
-error_repair(suite) -> [];
-error_repair(doc) ->
- ["Error while repairing."];
+%% Error while repairing.
error_repair(Conf) when is_list(Conf) ->
- % not all error situations are covered by this test
+ %% not all error situations are covered by this test
DataDir = ?datadir(Conf),
PrivDir = ?privdir(Conf),
- ?line File = filename:join(PrivDir, "n.LOG"),
- ?line No = 4,
- ?line file:delete(File),
- ?line del(File, No), % cleanup
+ File = filename:join(PrivDir, "n.LOG"),
+ No = 4,
+ file:delete(File),
+ del(File, No), % cleanup
- % kurt.LOG is not closed and has four logged items, one is recovered
- ?line copy_wrap_log("kurt.LOG", "n.LOG", No, DataDir, PrivDir),
- ?line {repaired,n,{recovered,1},{badbytes,0}} =
+ %% kurt.LOG is not closed and has four logged items, one is recovered
+ copy_wrap_log("kurt.LOG", "n.LOG", No, DataDir, PrivDir),
+ {repaired,n,{recovered,1},{badbytes,0}} =
disk_log:open([{name, n}, {file, File}, {type, wrap}, {size,{40,No}}]),
- ?line 1 = cur_cnt(n),
- ?line 53 = curb(n),
- ?line 4 = no_items(n),
- ?line ok = disk_log:close(n),
-
- % temporary repair file cannot be created
- ?line copy_wrap_log("kurt.LOG", "n.LOG", No, DataDir, PrivDir),
- ?line Dir = File ++ ".4" ++ ".TMP",
- ?line ok = file:make_dir(Dir),
- ?line P0 = pps(),
- ?line {error, {file_error, _, _}} =
+ 1 = cur_cnt(n),
+ 53 = curb(n),
+ 4 = no_items(n),
+ ok = disk_log:close(n),
+
+ %% temporary repair file cannot be created
+ copy_wrap_log("kurt.LOG", "n.LOG", No, DataDir, PrivDir),
+ Dir = File ++ ".4" ++ ".TMP",
+ ok = file:make_dir(Dir),
+ P0 = pps(),
+ {error, {file_error, _, _}} =
disk_log:open([{name, n}, {file, File}, {type, wrap}, {size,{40,4}}]),
- ?line true = (P0 == pps()),
- ?line del(File, No),
- ?line ok = file:del_dir(Dir),
+ true = (P0 == pps()),
+ del(File, No),
+ ok = file:del_dir(Dir),
%% repair a file
- ?line P1 = pps(),
- ?line {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
- {format, internal}, {size, {40,No}}]),
- ?line ok = disk_log:log_terms(n, [{this,is}]), % first file full
- ?line ok = disk_log:log_terms(n, [{some,terms}]), % second file full
- ?line ok = disk_log:close(n),
- ?line BadFile = add_ext(File, 2), % current file
- ?line set_opened(BadFile),
- ?line crash(BadFile, 28), % the binary is now invalid
- ?line {repaired,n,{recovered,0},{badbytes,26}} =
- disk_log:open([{name, n}, {file, File}, {type, wrap},
- {format, internal}, {size, {40,No}}]),
- ?line ok = disk_log:close(n),
- ?line true = (P1 == pps()),
- ?line del(File, No),
+ P1 = pps(),
+ {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
+ {format, internal}, {size, {40,No}}]),
+ ok = disk_log:log_terms(n, [{this,is}]), % first file full
+ ok = disk_log:log_terms(n, [{some,terms}]), % second file full
+ ok = disk_log:close(n),
+ BadFile = add_ext(File, 2), % current file
+ set_opened(BadFile),
+ crash(BadFile, 28), % the binary is now invalid
+ {repaired,n,{recovered,0},{badbytes,26}} =
+ disk_log:open([{name, n}, {file, File}, {type, wrap},
+ {format, internal}, {size, {40,No}}]),
+ ok = disk_log:close(n),
+ true = (P1 == pps()),
+ del(File, No),
%% yet another repair
- ?line P2 = pps(),
- ?line {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
- {format, internal}, {size, {4000,No}}]),
- ?line ok = disk_log:log_terms(n, [{this,is},{some,terms}]),
- ?line ok = disk_log:close(n),
- ?line BadFile2 = add_ext(File, 1), % current file
- ?line set_opened(BadFile2),
- ?line crash(BadFile2, 51), % the second binary is now invalid
- ?line {repaired,n,{recovered,1},{badbytes,26}} =
+ P2 = pps(),
+ {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
+ {format, internal}, {size, {4000,No}}]),
+ ok = disk_log:log_terms(n, [{this,is},{some,terms}]),
+ ok = disk_log:close(n),
+ BadFile2 = add_ext(File, 1), % current file
+ set_opened(BadFile2),
+ crash(BadFile2, 51), % the second binary is now invalid
+ {repaired,n,{recovered,1},{badbytes,26}} =
disk_log:open([{name, n}, {file, File}, {type, wrap},
{format, internal}, {size, {4000,No}}]),
- ?line ok = disk_log:close(n),
- ?line true = (P2 == pps()),
- ?line del(File, No),
+ ok = disk_log:close(n),
+ true = (P2 == pps()),
+ del(File, No),
%% Repair, large term
- ?line Big = term_to_binary(lists:duplicate(66000,$a)),
- ?line {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
- {format, internal}, {size, {40,No}}]),
- ?line ok = disk_log:log_terms(n, [Big]),
- ?line ok = disk_log:close(n),
- ?line set_opened(add_ext(File, 1)),
- ?line {repaired,n,{recovered,1},{badbytes,0}} =
+ Big = term_to_binary(lists:duplicate(66000,$a)),
+ {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
+ {format, internal}, {size, {40,No}}]),
+ ok = disk_log:log_terms(n, [Big]),
+ ok = disk_log:close(n),
+ set_opened(add_ext(File, 1)),
+ {repaired,n,{recovered,1},{badbytes,0}} =
disk_log:open([{name, n}, {file, File}, {type, wrap},
{format, internal}, {size, {40,No}}]),
- ?line {_, [Got]} = disk_log:chunk(n, start),
- ?line ok = disk_log:close(n),
- ?line Got = Big,
- ?line del(File, No),
+ {_, [Got]} = disk_log:chunk(n, start),
+ ok = disk_log:close(n),
+ Got = Big,
+ del(File, No),
%% A term a little smaller than a chunk, then big terms.
- ?line BigSmall = mk_bytes(1024*64-8-12),
- ?line file:delete(File),
- ?line {ok, n} = disk_log:open([{name, n}, {file, File}, {type, halt},
- {format, internal}]),
- ?line ok = disk_log:log_terms(n, [BigSmall, Big, Big]),
- ?line ok = disk_log:close(n),
- ?line set_opened(File),
- ?line FileSize = file_size(File),
- ?line crash(File, FileSize-byte_size(Big)-4),
- ?line Error1 = {error, {need_repair, _}} =
+ BigSmall = mk_bytes(1024*64-8-12),
+ file:delete(File),
+ {ok, n} = disk_log:open([{name, n}, {file, File}, {type, halt},
+ {format, internal}]),
+ ok = disk_log:log_terms(n, [BigSmall, Big, Big]),
+ ok = disk_log:close(n),
+ set_opened(File),
+ FileSize = file_size(File),
+ crash(File, FileSize-byte_size(Big)-4),
+ Error1 = {error, {need_repair, _}} =
disk_log:open([{name, n}, {file, File}, {repair, false},
{type, halt}, {format, internal}]),
- ?line "The disk log" ++ _ = format_error(Error1),
- ?line {repaired,n,{recovered,2},{badbytes,132013}} =
+ "The disk log" ++ _ = format_error(Error1),
+ {repaired,n,{recovered,2},{badbytes,132013}} =
disk_log:open([{name, n}, {file, File}, {repair, true},
{type, halt}, {format, internal}]),
- ?line ok = disk_log:close(n),
- ?line file:delete(File),
+ ok = disk_log:close(n),
+ file:delete(File),
%% The header is recovered.
- ?line {ok,n} =
+ {ok,n} =
disk_log:open([{name, n}, {file, File}, {type, halt},
{format, internal},
{head_func, {?MODULE, head_fun, [{ok,"head"}]}}]),
- ?line ok = disk_log:log_terms(n, [list,'of',terms]),
- ?line ["head",list,'of',terms] = get_all_terms(n),
- ?line ok = disk_log:close(n),
- ?line set_opened(File),
- ?line crash(File, 30),
- ?line {repaired,n,{recovered,3},{badbytes,16}} =
+ ok = disk_log:log_terms(n, [list,'of',terms]),
+ ["head",list,'of',terms] = get_all_terms(n),
+ ok = disk_log:close(n),
+ set_opened(File),
+ crash(File, 30),
+ {repaired,n,{recovered,3},{badbytes,16}} =
disk_log:open([{name, n}, {file, File}, {type, halt},
{format, internal},{repair,true},
{head_func, {?MODULE, head_fun, [{ok,"head"}]}}]),
- ?line ["head",'of',terms] = get_all_terms(n),
- ?line ok = disk_log:close(n),
+ ["head",'of',terms] = get_all_terms(n),
+ ok = disk_log:close(n),
file:delete(File),
ok.
-
+
set_opened(File) ->
{ok, Fd} = file:open(File, [raw, binary, read, write]),
ok = file:write(Fd, [?LOGMAGIC, ?OPENED]),
ok = file:close(Fd).
-error_log(suite) -> [];
-error_log(doc) ->
- ["Error while repairing."];
+%% Error while repairing.
error_log(Conf) when is_list(Conf) ->
- ?line Dir = ?privdir(Conf),
-
- ?line File = filename:join(Dir, "n.LOG"),
- ?line No = 4,
- ?line file:delete(File),
- ?line del(File, No), % cleanup
- ?line LDir = File ++ ".2",
-
- ?line Q = qlen(),
- % dummy just to get all processes "above" disk_log going
- ?line {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
- {format, external},{size, {100, No}}]),
- ?line ok = disk_log:close(n),
- ?line del(File, No),
-
- % inc_wrap_file fails, the external log is not terminated
- ?line P0 = pps(),
- ?line {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
- {format, external},{size, {100, No}}]),
- ?line ok = file:make_dir(LDir),
- ?line {error, {file_error, _, _}} = disk_log:inc_wrap_file(n),
- ?line timer:sleep(500),
- ?line ok = disk_log:close(n),
- ?line del(File, No),
-
- % inc_wrap_file fails, the internal log is not terminated, ./File.2/ exists
- ?line {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
- {format, internal},{size, {100, No}}]),
- ?line {error, {file_error, _, _}} = disk_log:inc_wrap_file(n),
- ?line ok = disk_log:close(n),
- ?line del(File, No),
-
- % truncate fails, the log is terminated, ./File.2/ exists
- ?line {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
- {format, external},{size, {100, No}}]),
- ?line {error, {file_error, _, _}} = disk_log:truncate(n),
- ?line true = (P0 == pps()),
- ?line del(File, No),
+ Dir = ?privdir(Conf),
+
+ File = filename:join(Dir, "n.LOG"),
+ No = 4,
+ file:delete(File),
+ del(File, No), % cleanup
+ LDir = File ++ ".2",
+
+ Q = qlen(),
+ %% dummy just to get all processes "above" disk_log going
+ {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
+ {format, external},{size, {100, No}}]),
+ ok = disk_log:close(n),
+ del(File, No),
+
+ %% inc_wrap_file fails, the external log is not terminated
+ P0 = pps(),
+ {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
+ {format, external},{size, {100, No}}]),
+ ok = file:make_dir(LDir),
+ {error, {file_error, _, _}} = disk_log:inc_wrap_file(n),
+ timer:sleep(500),
+ ok = disk_log:close(n),
+ del(File, No),
+
+ %% inc_wrap_file fails, the internal log is not terminated, ./File.2/ exists
+ {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
+ {format, internal},{size, {100, No}}]),
+ {error, {file_error, _, _}} = disk_log:inc_wrap_file(n),
+ ok = disk_log:close(n),
+ del(File, No),
+
+ %% truncate fails, the log is terminated, ./File.2/ exists
+ {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
+ {format, external},{size, {100, No}}]),
+ {error, {file_error, _, _}} = disk_log:truncate(n),
+ true = (P0 == pps()),
+ del(File, No),
%% OTP-4880.
- % reopen (rename) fails, the log is terminated, ./File.2/ exists
- ?line {ok, n} = disk_log:open([{name, n}, {file, File}, {type, halt},
- {format, external},{size, 100000}]),
- ?line {error, {file_error, _, eisdir}} = disk_log:reopen(n, LDir),
- ?line true = (P0 == pps()),
- ?line file:delete(File),
+ %% reopen (rename) fails, the log is terminated, ./File.2/ exists
+ {ok, n} = disk_log:open([{name, n}, {file, File}, {type, halt},
+ {format, external},{size, 100000}]),
+ {error, {file_error, _, eisdir}} = disk_log:reopen(n, LDir),
+ true = (P0 == pps()),
+ file:delete(File),
- ?line B = mk_bytes(60),
+ B = mk_bytes(60),
%% OTP-4880. reopen a wrap log, rename fails
- ?line File2 = filename:join(Dir, "n.LOG2"),
- ?line {ok, n} = disk_log:open([{name, n}, {file, File2}, {type, wrap},
- {format, external},{size, {100, No}}]),
- ?line ok = disk_log:blog_terms(n, [B,B,B]),
- ?line {error, {file_error, _, eisdir}} = disk_log:reopen(n, File),
- ?line {error, no_such_log} = disk_log:close(n),
- ?line del(File2, No),
- ?line del(File, No),
-
- % log, external wrap log, ./File.2/ exists
- ?line {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
- {format, external},{size, {100, No}}]),
- ?line {error, {file_error, _, _}} = disk_log:blog_terms(n, [B,B,B]),
- ?line ok = disk_log:close(n),
- ?line del(File, No),
-
- % log, internal wrap log, ./File.2/ exists
- ?line {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
- {format, internal},{size, {100, No}}]),
- ?line {error, {file_error, _, _}} = disk_log:log_terms(n, [B,B,B]),
- ?line ok = disk_log:close(n),
- ?line del(File, No),
-
- ?line ok = file:del_dir(LDir),
-
- % can't remove file when changing size
- ?line {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
- {format, internal},{size, {100, No}}]),
- ?line ok = disk_log:log_terms(n, [B,B,B,B]),
- ?line ok = disk_log:change_size(n, {100, No-2}),
- ?line Three = File ++ ".3",
- ?line ok = file:delete(Three),
- ?line ok = file:make_dir(Three),
- ?line {error, {file_error, _, _}} = disk_log:log_terms(n, [B,B,B]),
- ?line timer:sleep(500),
- ?line ok = disk_log:close(n),
- ?line ok = file:del_dir(Three),
- ?line del(File, No),
- ?line Q = qlen(),
+ File2 = filename:join(Dir, "n.LOG2"),
+ {ok, n} = disk_log:open([{name, n}, {file, File2}, {type, wrap},
+ {format, external},{size, {100, No}}]),
+ ok = disk_log:blog_terms(n, [B,B,B]),
+ {error, {file_error, _, eisdir}} = disk_log:reopen(n, File),
+ {error, no_such_log} = disk_log:close(n),
+ del(File2, No),
+ del(File, No),
+
+ %% log, external wrap log, ./File.2/ exists
+ {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
+ {format, external},{size, {100, No}}]),
+ {error, {file_error, _, _}} = disk_log:blog_terms(n, [B,B,B]),
+ ok = disk_log:close(n),
+ del(File, No),
+
+ %% log, internal wrap log, ./File.2/ exists
+ {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
+ {format, internal},{size, {100, No}}]),
+ {error, {file_error, _, _}} = disk_log:log_terms(n, [B,B,B]),
+ ok = disk_log:close(n),
+ del(File, No),
+
+ ok = file:del_dir(LDir),
+
+ %% can't remove file when changing size
+ {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
+ {format, internal},{size, {100, No}}]),
+ ok = disk_log:log_terms(n, [B,B,B,B]),
+ ok = disk_log:change_size(n, {100, No-2}),
+ Three = File ++ ".3",
+ ok = file:delete(Three),
+ ok = file:make_dir(Three),
+ {error, {file_error, _, _}} = disk_log:log_terms(n, [B,B,B]),
+ timer:sleep(500),
+ ok = disk_log:close(n),
+ ok = file:del_dir(Three),
+ del(File, No),
+ Q = qlen(),
ok.
-
-chunk(suite) -> [];
-chunk(doc) ->
- ["Test chunk and chunk_step."];
+
+%% Test chunk and chunk_step.
chunk(Conf) when is_list(Conf) ->
%% See also halt_ro_crash/1 above.
Dir = ?privdir(Conf),
- ?line File = filename:join(Dir, "n.LOG"),
+ File = filename:join(Dir, "n.LOG"),
No = 4,
- ?line B = mk_bytes(60),
- ?line BB = mk_bytes(64000), % 64 kB chunks
- ?line del(File, No),% cleanup
+ B = mk_bytes(60),
+ BB = mk_bytes(64000), % 64 kB chunks
+ del(File, No),% cleanup
%% Make sure chunk_step skips the rest of the binary.
%% OTP-3716. This was a bug...
- ?line {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
- {format, internal}, {size, {50,No}}]),
+ {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
+ {format, internal}, {size, {50,No}}]),
%% 1, 2 and 3 on file one, 4 on file two.
- ?line ok = disk_log:log_terms(n, [1,2,3,4]),
- ?line {I1, [1]} = disk_log:chunk(n, start, 1),
- ?line [{node,Node}] = disk_log:chunk_info(I1),
- ?line Node = node(),
- ?line Error1 = {error, {no_continuation, foobar}} =
+ ok = disk_log:log_terms(n, [1,2,3,4]),
+ {I1, [1]} = disk_log:chunk(n, start, 1),
+ [{node,Node}] = disk_log:chunk_info(I1),
+ Node = node(),
+ Error1 = {error, {no_continuation, foobar}} =
disk_log:chunk_info(foobar),
- ?line "The term" ++ _ = format_error(Error1),
- ?line {ok, I2} = disk_log:chunk_step(n, I1, 1),
- ?line {error, {badarg, continuation}} = disk_log:chunk_step(n, foobar, 1),
- ?line {I3, [4]} = disk_log:chunk(n, I2, 1),
- ?line {ok, I4} = disk_log:chunk_step(n, I3, -1),
- ?line {_, [1]} = disk_log:chunk(n, I4, 1),
- ?line {error, {badarg, continuation}} = disk_log:bchunk(n, 'begin'),
- ?line {Ib1, [Bin1,Bin2]} = disk_log:bchunk(n, start, 2),
- ?line 1 = binary_to_term(Bin1),
- ?line 2 = binary_to_term(Bin2),
- ?line {ok, Ib2} = disk_log:chunk_step(n, Ib1, 1),
- ?line {Ib3, [Bin3]} = disk_log:bchunk(n, Ib2, 1),
- ?line 4 = binary_to_term(Bin3),
- ?line {ok, Ib4} = disk_log:chunk_step(n, Ib3, -1),
- ?line {_, [Bin4]} = disk_log:bchunk(n, Ib4, 1),
- ?line 1 = binary_to_term(Bin4),
- ?line {Ib5, [Bin1, Bin2, Bin17]} = disk_log:bchunk(n, start),
- ?line 3 = binary_to_term(Bin17),
- ?line {Ib6, [Bin3]} = disk_log:bchunk(n, Ib5, infinity),
- ?line eof = disk_log:bchunk(n, Ib6, infinity),
- ?line ok = disk_log:close(n),
- ?line del(File, No), % cleanup
+ "The term" ++ _ = format_error(Error1),
+ {ok, I2} = disk_log:chunk_step(n, I1, 1),
+ {error, {badarg, continuation}} = disk_log:chunk_step(n, foobar, 1),
+ {I3, [4]} = disk_log:chunk(n, I2, 1),
+ {ok, I4} = disk_log:chunk_step(n, I3, -1),
+ {_, [1]} = disk_log:chunk(n, I4, 1),
+ {error, {badarg, continuation}} = disk_log:bchunk(n, 'begin'),
+ {Ib1, [Bin1,Bin2]} = disk_log:bchunk(n, start, 2),
+ 1 = binary_to_term(Bin1),
+ 2 = binary_to_term(Bin2),
+ {ok, Ib2} = disk_log:chunk_step(n, Ib1, 1),
+ {Ib3, [Bin3]} = disk_log:bchunk(n, Ib2, 1),
+ 4 = binary_to_term(Bin3),
+ {ok, Ib4} = disk_log:chunk_step(n, Ib3, -1),
+ {_, [Bin4]} = disk_log:bchunk(n, Ib4, 1),
+ 1 = binary_to_term(Bin4),
+ {Ib5, [Bin1, Bin2, Bin17]} = disk_log:bchunk(n, start),
+ 3 = binary_to_term(Bin17),
+ {Ib6, [Bin3]} = disk_log:bchunk(n, Ib5, infinity),
+ eof = disk_log:bchunk(n, Ib6, infinity),
+ ok = disk_log:close(n),
+ del(File, No), % cleanup
%% external log, cannot read chunks
- ?line {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
- {format, external}, {size, {100,No}}]),
- ?line {error, {badarg, continuation}} = disk_log:chunk(n, 'begin'),
- ?line {error, {format_external, n}} = disk_log:chunk(n, start),
- ?line Error2 = {error, {not_internal_wrap, n}} =
+ {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
+ {format, external}, {size, {100,No}}]),
+ {error, {badarg, continuation}} = disk_log:chunk(n, 'begin'),
+ {error, {format_external, n}} = disk_log:chunk(n, start),
+ Error2 = {error, {not_internal_wrap, n}} =
disk_log:chunk_step(n, start, 1),
- ?line "The requested" ++ _ = format_error(Error2),
- ?line ok = disk_log:close(n),
- ?line del(File, No),
+ "The requested" ++ _ = format_error(Error2),
+ ok = disk_log:close(n),
+ del(File, No),
%% wrap, read_write
- ?line {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
- {format, internal}, {size, {100,No}}]),
- ?line ok = disk_log:log_terms(n, [B,B,B,B]),
- ?line {C1, [_]} = disk_log:chunk(n, start),
- ?line {C2, [_]} = disk_log:chunk(n, C1),
- ?line {C3, [_]} = disk_log:chunk(n, C2),
- ?line {C4, [_]} = disk_log:chunk(n, C3, 1),
- ?line eof = disk_log:chunk(n, C4),
- ?line {C5, [_]} = disk_log:chunk(n, start),
- ?line {ok, C6} = disk_log:chunk_step(n, C5, 1),
- ?line {C7, [_]} = disk_log:chunk(n, C6),
- ?line {ok, C8} = disk_log:chunk_step(n, C7, 1),
- ?line {_, [_]} = disk_log:chunk(n, C8),
- ?line ok = disk_log:close(n),
+ {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
+ {format, internal}, {size, {100,No}}]),
+ ok = disk_log:log_terms(n, [B,B,B,B]),
+ {C1, [_]} = disk_log:chunk(n, start),
+ {C2, [_]} = disk_log:chunk(n, C1),
+ {C3, [_]} = disk_log:chunk(n, C2),
+ {C4, [_]} = disk_log:chunk(n, C3, 1),
+ eof = disk_log:chunk(n, C4),
+ {C5, [_]} = disk_log:chunk(n, start),
+ {ok, C6} = disk_log:chunk_step(n, C5, 1),
+ {C7, [_]} = disk_log:chunk(n, C6),
+ {ok, C8} = disk_log:chunk_step(n, C7, 1),
+ {_, [_]} = disk_log:chunk(n, C8),
+ ok = disk_log:close(n),
%% wrap, read_only
- ?line {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
- {mode, read_only},
- {format, internal}, {size, {100,No}}]),
- ?line {CC1, [_]} = disk_log:chunk(n, start),
- ?line {CC2, [_]} = disk_log:chunk(n, CC1),
- ?line {CC3, [_]} = disk_log:chunk(n, CC2),
- ?line {CC4, [_]} = disk_log:chunk(n, CC3, 1),
- ?line eof = disk_log:chunk(n, CC4),
- ?line {CC5, [_]} = disk_log:chunk(n, start),
- ?line {ok, CC6} = disk_log:chunk_step(n, CC5, 1),
- ?line {CC7, [_]} = disk_log:chunk(n, CC6),
- ?line {ok, CC8} = disk_log:chunk_step(n, CC7, 1),
- ?line {_, [_]} = disk_log:chunk(n, CC8),
- ?line ok = disk_log:close(n),
+ {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
+ {mode, read_only},
+ {format, internal}, {size, {100,No}}]),
+ {CC1, [_]} = disk_log:chunk(n, start),
+ {CC2, [_]} = disk_log:chunk(n, CC1),
+ {CC3, [_]} = disk_log:chunk(n, CC2),
+ {CC4, [_]} = disk_log:chunk(n, CC3, 1),
+ eof = disk_log:chunk(n, CC4),
+ {CC5, [_]} = disk_log:chunk(n, start),
+ {ok, CC6} = disk_log:chunk_step(n, CC5, 1),
+ {CC7, [_]} = disk_log:chunk(n, CC6),
+ {ok, CC8} = disk_log:chunk_step(n, CC7, 1),
+ {_, [_]} = disk_log:chunk(n, CC8),
+ ok = disk_log:close(n),
%% OTP-3716. A bug: {Error, List} and {Error, List, Bad} could be
%% returned from chunk/2.
%% Magic bytes not OK.
%% File header (8 bytes) OK, item header not OK.
- ?line InvalidFile = add_ext(File, 1),
- ?line crash(InvalidFile, 15),
- ?line {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
- {mode, read_only},
- {format, internal}, {size, {100,No}}]),
- ?line {_, [], 61} = disk_log:chunk(n, start),
- ?line ok = disk_log:close(n),
+ InvalidFile = add_ext(File, 1),
+ crash(InvalidFile, 15),
+ {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
+ {mode, read_only},
+ {format, internal}, {size, {100,No}}]),
+ {_, [], 61} = disk_log:chunk(n, start),
+ ok = disk_log:close(n),
%% read_write...
- ?line {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
- {format, internal}, {size, {100,No}}]),
- ?line Error3 = {error, {corrupt_log_file, Culprit}} =
+ {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
+ {format, internal}, {size, {100,No}}]),
+ Error3 = {error, {corrupt_log_file, Culprit}} =
disk_log:chunk(n, start),
- ?line "The disk log file" ++ _ = format_error(Error3),
- ?line Culprit = InvalidFile,
- ?line ok = disk_log:close(n),
- ?line del(File, No),
+ "The disk log file" ++ _ = format_error(Error3),
+ Culprit = InvalidFile,
+ ok = disk_log:close(n),
+ del(File, No),
%% Two wrap log files, writing the second one, then reading the first
%% one, where a bogus term resides.
- ?line {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
- {format, internal}, {size, {40,No}}]),
- ?line ok = disk_log:log_terms(n, [{this,is}]), % first file full
- ?line ok = disk_log:log_terms(n, [{some,terms}]), % second file full
- ?line 2 = curf(n),
- ?line BadFile = add_ext(File, 1),
- ?line crash(BadFile, 28), % the _binary_ is now invalid
- ?line {error, {corrupt_log_file, BFile}} = disk_log:chunk(n, start, 1),
- ?line BadFile = BFile,
- ?line ok = disk_log:close(n),
+ {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
+ {format, internal}, {size, {40,No}}]),
+ ok = disk_log:log_terms(n, [{this,is}]), % first file full
+ ok = disk_log:log_terms(n, [{some,terms}]), % second file full
+ 2 = curf(n),
+ BadFile = add_ext(File, 1),
+ crash(BadFile, 28), % the _binary_ is now invalid
+ {error, {corrupt_log_file, BFile}} = disk_log:chunk(n, start, 1),
+ BadFile = BFile,
+ ok = disk_log:close(n),
%% The same, with a halt log.
- ?line file:delete(File), % cleanup
- ?line {ok, n} = disk_log:open([{name, n}, {file, File}, {type, halt},
- {format, internal}]),
- ?line ok = disk_log:log_terms(n, [{this,is}]),
- ?line ok = disk_log:sync(n),
- ?line crash(File, 28), % the _binary_ is now invalid
- ?line {error, {corrupt_log_file, File2}} = disk_log:chunk(n, start, 1),
- ?line crash(File, 10),
- ?line {error,{corrupt_log_file,_}} = disk_log:bchunk(n, start, 1),
- ?line true = File == File2,
- ?line ok = disk_log:close(n),
- ?line del(File, No),
+ file:delete(File), % cleanup
+ {ok, n} = disk_log:open([{name, n}, {file, File}, {type, halt},
+ {format, internal}]),
+ ok = disk_log:log_terms(n, [{this,is}]),
+ ok = disk_log:sync(n),
+ crash(File, 28), % the _binary_ is now invalid
+ {error, {corrupt_log_file, File2}} = disk_log:chunk(n, start, 1),
+ crash(File, 10),
+ {error,{corrupt_log_file,_}} = disk_log:bchunk(n, start, 1),
+ true = File == File2,
+ ok = disk_log:close(n),
+ del(File, No),
%% halt, read_write
- ?line file:delete(File), % cleanup
- ?line {ok, n} = disk_log:open([{name, n}, {file, File}, {type, halt},
- {format, internal}]),
- ?line ok = disk_log:log_terms(n, [BB,BB,BB,BB]),
- ?line {D1, [Ch1]} = disk_log:chunk(n, start, 1),
- ?line Ch1 = BB,
- ?line {D2, [Ch2]} = disk_log:chunk(n, D1, 1),
- ?line Ch2 = BB,
- ?line {D3, [Ch3]} = disk_log:chunk(n, D2, 1),
- ?line Ch3 = BB,
- ?line {D4, [Ch4]} = disk_log:chunk(n, D3, 1),
- ?line Ch4 = BB,
- ?line eof = disk_log:chunk(n, D4),
- ?line ok = disk_log:close(n),
+ file:delete(File), % cleanup
+ {ok, n} = disk_log:open([{name, n}, {file, File}, {type, halt},
+ {format, internal}]),
+ ok = disk_log:log_terms(n, [BB,BB,BB,BB]),
+ {D1, [Ch1]} = disk_log:chunk(n, start, 1),
+ Ch1 = BB,
+ {D2, [Ch2]} = disk_log:chunk(n, D1, 1),
+ Ch2 = BB,
+ {D3, [Ch3]} = disk_log:chunk(n, D2, 1),
+ Ch3 = BB,
+ {D4, [Ch4]} = disk_log:chunk(n, D3, 1),
+ Ch4 = BB,
+ eof = disk_log:chunk(n, D4),
+ ok = disk_log:close(n),
%% halt, read_only
- ?line {ok, n} = disk_log:open([{name, n}, {file, File}, {type, halt},
- {format, internal},{mode,read_only}]),
- ?line {E1, [Ch5]} = disk_log:chunk(n, start, 1),
- ?line Ch5 = BB,
- ?line {E2, [Ch6]} = disk_log:chunk(n, E1, 1),
- ?line Ch6 = BB,
- ?line {E3, [Ch7]} = disk_log:chunk(n, E2, 1),
- ?line Ch7 = BB,
- ?line {E4, [Ch8]} = disk_log:chunk(n, E3, 1),
- ?line Ch8 = BB,
- ?line eof = disk_log:chunk(n, E4),
- ?line ok = disk_log:close(n),
- ?line file:delete(File), % cleanup
+ {ok, n} = disk_log:open([{name, n}, {file, File}, {type, halt},
+ {format, internal},{mode,read_only}]),
+ {E1, [Ch5]} = disk_log:chunk(n, start, 1),
+ Ch5 = BB,
+ {E2, [Ch6]} = disk_log:chunk(n, E1, 1),
+ Ch6 = BB,
+ {E3, [Ch7]} = disk_log:chunk(n, E2, 1),
+ Ch7 = BB,
+ {E4, [Ch8]} = disk_log:chunk(n, E3, 1),
+ Ch8 = BB,
+ eof = disk_log:chunk(n, E4),
+ ok = disk_log:close(n),
+ file:delete(File), % cleanup
%% More than 64 kB term.
- ?line BBB = term_to_binary(lists:duplicate(66000,$a)),
- ?line {ok, n} = disk_log:open([{name, n}, {file, File}, {type, halt},
- {format, internal}]),
- ?line ok = disk_log:log_terms(n, [BBB]),
- ?line {F1, [BBB1]} = disk_log:chunk(n, start),
- ?line BBB1 = BBB,
- ?line eof = disk_log:chunk(n, F1),
- ?line ok = disk_log:close(n),
- ?line {ok, n} = disk_log:open([{name, n}, {file, File}, {type, halt},
- {format, internal}, {mode, read_only}]),
- ?line {F1r, [BBB2]} = disk_log:chunk(n, start),
- ?line BBB2 = BBB,
- ?line eof = disk_log:chunk(n, F1r),
- ?line ok = disk_log:close(n),
-
- ?line truncate(File, 8192),
- ?line {ok, n} = disk_log:open([{name, n}, {file, File}, {type, halt},
- {format, internal}]),
- ?line {error, {corrupt_log_file, _}} = disk_log:chunk(n, start),
- ?line ok = disk_log:close(n),
- ?line {ok, n} = disk_log:open([{name, n}, {file, File}, {type, halt},
- {format, internal}, {mode, read_only}]),
- ?line {K1, [], 8176} = disk_log:chunk(n, start),
- ?line eof = disk_log:chunk(n, K1),
- ?line ok = disk_log:close(n),
- ?line file:delete(File), % cleanup
+ BBB = term_to_binary(lists:duplicate(66000,$a)),
+ {ok, n} = disk_log:open([{name, n}, {file, File}, {type, halt},
+ {format, internal}]),
+ ok = disk_log:log_terms(n, [BBB]),
+ {F1, [BBB1]} = disk_log:chunk(n, start),
+ BBB1 = BBB,
+ eof = disk_log:chunk(n, F1),
+ ok = disk_log:close(n),
+ {ok, n} = disk_log:open([{name, n}, {file, File}, {type, halt},
+ {format, internal}, {mode, read_only}]),
+ {F1r, [BBB2]} = disk_log:chunk(n, start),
+ BBB2 = BBB,
+ eof = disk_log:chunk(n, F1r),
+ ok = disk_log:close(n),
+
+ truncate(File, 8192),
+ {ok, n} = disk_log:open([{name, n}, {file, File}, {type, halt},
+ {format, internal}]),
+ {error, {corrupt_log_file, _}} = disk_log:chunk(n, start),
+ ok = disk_log:close(n),
+ {ok, n} = disk_log:open([{name, n}, {file, File}, {type, halt},
+ {format, internal}, {mode, read_only}]),
+ {K1, [], 8176} = disk_log:chunk(n, start),
+ eof = disk_log:chunk(n, K1),
+ ok = disk_log:close(n),
+ file:delete(File), % cleanup
%% OTP-3716. A bug: eof in the middle of the last element is not ok.
- ?line {ok, n} = disk_log:open([{name, n}, {file, File}, {type, halt},
- {format, internal}]),
- ?line ok = disk_log:log_terms(n, [B,BB]),
- ?line ok = disk_log:close(n),
- ?line truncate(File, 80),
- ?line {ok, n} = disk_log:open([{name, n}, {file, File}, {type, halt},
- {format, internal}]),
- ?line {G1, [_]} = disk_log:chunk(n, start, 1),
- ?line {error, {corrupt_log_file, _}} = disk_log:chunk(n, G1, 1),
- ?line ok = disk_log:close(n),
- ?line {ok, n} = disk_log:open([{name, n}, {file, File}, {type, halt},
- {format, internal}, {mode, read_only}]),
- ?line {G1r, [_]} = disk_log:chunk(n, start, 1),
- ?line {_, [], 4} = disk_log:chunk(n, G1r, 1),
- ?line ok = disk_log:close(n),
- ?line file:delete(File), % cleanup
+ {ok, n} = disk_log:open([{name, n}, {file, File}, {type, halt},
+ {format, internal}]),
+ ok = disk_log:log_terms(n, [B,BB]),
+ ok = disk_log:close(n),
+ truncate(File, 80),
+ {ok, n} = disk_log:open([{name, n}, {file, File}, {type, halt},
+ {format, internal}]),
+ {G1, [_]} = disk_log:chunk(n, start, 1),
+ {error, {corrupt_log_file, _}} = disk_log:chunk(n, G1, 1),
+ ok = disk_log:close(n),
+ {ok, n} = disk_log:open([{name, n}, {file, File}, {type, halt},
+ {format, internal}, {mode, read_only}]),
+ {G1r, [_]} = disk_log:chunk(n, start, 1),
+ {_, [], 4} = disk_log:chunk(n, G1r, 1),
+ ok = disk_log:close(n),
+ file:delete(File), % cleanup
%% Opening a wrap log read-only. The second of four terms is destroyed.
- ?line {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
- {format, internal}, {size, {4000,No}}]),
- ?line ok = disk_log:log_terms(n,
- [{this,is},{some,terms},{on,a},{wrap,file}]),
- ?line ok = disk_log:close(n),
- ?line {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
- {format, internal}, {mode, read_only}]),
- ?line CrashFile = add_ext(File, 1),
- ?line crash(CrashFile, 51), % the binary term {some,terms} is now bad
- ?line {H1, [{this,is}], 18} = disk_log:chunk(n, start, 10),
- ?line {H2, [{on,a},{wrap,file}]} = disk_log:chunk(n, H1),
- ?line eof = disk_log:chunk(n, H2),
- ?line ok = disk_log:close(n),
- ?line del(File, No),
+ {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
+ {format, internal}, {size, {4000,No}}]),
+ ok = disk_log:log_terms(n,
+ [{this,is},{some,terms},{on,a},{wrap,file}]),
+ ok = disk_log:close(n),
+ {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
+ {format, internal}, {mode, read_only}]),
+ CrashFile = add_ext(File, 1),
+ crash(CrashFile, 51), % the binary term {some,terms} is now bad
+ {H1, [{this,is}], 18} = disk_log:chunk(n, start, 10),
+ {H2, [{on,a},{wrap,file}]} = disk_log:chunk(n, H1),
+ eof = disk_log:chunk(n, H2),
+ ok = disk_log:close(n),
+ del(File, No),
%% The same as last, but with a halt log.
- ?line {ok, n} = disk_log:open([{name, n}, {file, File}, {type, halt},
- {format, internal}, {mode, read_write}]),
- ?line ok = disk_log:alog_terms(n, [{this,is},{some,terms}]),
- ?line ok = disk_log:log_terms(n, [{on,a},{halt,file}]),
- ?line ok = disk_log:close(n),
- ?line {ok, n} = disk_log:open([{name, n}, {file, File}, {type, halt},
- {format, internal}, {mode, read_only}]),
- ?line crash(File, 51), % the binary term {some,terms} is now bad
- ?line {J1, [{this,is}], 18} = disk_log:chunk(n, start, 10),
- ?line {J2, [{on,a},{halt,file}]} = disk_log:chunk(n, J1),
- ?line eof = disk_log:chunk(n, J2),
- ?line ok = disk_log:close(n),
- ?line file:delete(File),
+ {ok, n} = disk_log:open([{name, n}, {file, File}, {type, halt},
+ {format, internal}, {mode, read_write}]),
+ ok = disk_log:alog_terms(n, [{this,is},{some,terms}]),
+ ok = disk_log:log_terms(n, [{on,a},{halt,file}]),
+ ok = disk_log:close(n),
+ {ok, n} = disk_log:open([{name, n}, {file, File}, {type, halt},
+ {format, internal}, {mode, read_only}]),
+ crash(File, 51), % the binary term {some,terms} is now bad
+ {J1, [{this,is}], 18} = disk_log:chunk(n, start, 10),
+ {J2, [{on,a},{halt,file}]} = disk_log:chunk(n, J1),
+ eof = disk_log:chunk(n, J2),
+ ok = disk_log:close(n),
+ file:delete(File),
%% OTP-7641. Same as last one, but the size of the bad term is
%% less than ?HEADERSz (8) bytes.
- ?line {ok, n} = disk_log:open([{name, n}, {file, File}, {type, halt},
- {format, internal}, {mode, read_write}]),
- ?line ok = disk_log:alog_terms(n, [{this,is},{s}]),
- ?line ok = disk_log:log_terms(n, [{on,a},{halt,file}]),
- ?line ok = disk_log:close(n),
- ?line {ok, n} = disk_log:open([{name, n}, {file, File}, {type, halt},
- {format, internal}, {mode, read_only}]),
- ?line crash(File, 44), % the binary term {s} is now bad
- ?line {J11, [{this,is}], 7} = disk_log:chunk(n, start, 10),
- ?line {J21, [{on,a},{halt,file}]} = disk_log:chunk(n, J11),
- ?line eof = disk_log:chunk(n, J21),
- ?line ok = disk_log:close(n),
- ?line file:delete(File),
+ {ok, n} = disk_log:open([{name, n}, {file, File}, {type, halt},
+ {format, internal}, {mode, read_write}]),
+ ok = disk_log:alog_terms(n, [{this,is},{s}]),
+ ok = disk_log:log_terms(n, [{on,a},{halt,file}]),
+ ok = disk_log:close(n),
+ {ok, n} = disk_log:open([{name, n}, {file, File}, {type, halt},
+ {format, internal}, {mode, read_only}]),
+ crash(File, 44), % the binary term {s} is now bad
+ {J11, [{this,is}], 7} = disk_log:chunk(n, start, 10),
+ {J21, [{on,a},{halt,file}]} = disk_log:chunk(n, J11),
+ eof = disk_log:chunk(n, J21),
+ ok = disk_log:close(n),
+ file:delete(File),
%% Minimal MD5-proctected term, and maximal unprotected term.
%% A chunk ends in the middle of the MD5-sum.
- ?line MD5term = mk_bytes(64*1024-8),
- ?line NotMD5term = mk_bytes((64*1024-8)-1),
- ?line Term2 = mk_bytes((64*1024-8)-16),
- ?line MD5L = [MD5term,NotMD5term,Term2,MD5term,MD5term,NotMD5term],
- ?line {ok, n} = disk_log:open([{name, n}, {file, File}, {type, halt},
- {format, internal}]),
- ?line ok = disk_log:log_terms(n, MD5L),
- ?line true = MD5L == get_all_terms(n),
- ?line ok = disk_log:close(n),
- ?line true = MD5L == get_all_terms(n, File, halt),
- ?line crash(File, 21), % the MD5-sum of the first term is now bad
- ?line true = {tl(MD5L),64*1024-8} == get_all_terms_and_bad(n, File, halt),
- ?line {_,64*1024-8} = get_all_binary_terms_and_bad(n, File, halt),
- ?line {ok, n} = disk_log:open([{name, n}, {file, File}, {type, halt},
- {format, internal}]),
- ?line {error, {corrupt_log_file, _}} = disk_log:chunk(n, start),
- ?line ok = disk_log:close(n),
- ?line file:delete(File),
+ MD5term = mk_bytes(64*1024-8),
+ NotMD5term = mk_bytes((64*1024-8)-1),
+ Term2 = mk_bytes((64*1024-8)-16),
+ MD5L = [MD5term,NotMD5term,Term2,MD5term,MD5term,NotMD5term],
+ {ok, n} = disk_log:open([{name, n}, {file, File}, {type, halt},
+ {format, internal}]),
+ ok = disk_log:log_terms(n, MD5L),
+ true = MD5L == get_all_terms(n),
+ ok = disk_log:close(n),
+ true = MD5L == get_all_terms(n, File, halt),
+ crash(File, 21), % the MD5-sum of the first term is now bad
+ true = {tl(MD5L),64*1024-8} == get_all_terms_and_bad(n, File, halt),
+ {_,64*1024-8} = get_all_binary_terms_and_bad(n, File, halt),
+ {ok, n} = disk_log:open([{name, n}, {file, File}, {type, halt},
+ {format, internal}]),
+ {error, {corrupt_log_file, _}} = disk_log:chunk(n, start),
+ ok = disk_log:close(n),
+ file:delete(File),
%% A file with "old" terms (magic word is MAGICINT).
DataDir = ?datadir(Conf),
OldTermsFileOrig = filename:join(DataDir, "old_terms.LOG"),
OldTermsFile = filename:join(Dir, "old_terms.LOG"),
- ?line copy_file(OldTermsFileOrig, OldTermsFile),
- ?line {[_,_,_,_],0} = get_all_terms_and_bad(n, OldTermsFile, halt),
- ?line {ok, n} = disk_log:open([{name, n}, {file, OldTermsFile},
- {type, halt}, {format, internal}]),
- ?line [_,_,_,_] = get_all_terms(n),
- ?line ok = disk_log:close(n),
- ?line file:delete(OldTermsFile),
+ copy_file(OldTermsFileOrig, OldTermsFile),
+ {[_,_,_,_],0} = get_all_terms_and_bad(n, OldTermsFile, halt),
+ {ok, n} = disk_log:open([{name, n}, {file, OldTermsFile},
+ {type, halt}, {format, internal}]),
+ [_,_,_,_] = get_all_terms(n),
+ ok = disk_log:close(n),
+ file:delete(OldTermsFile),
ok.
-error_index(suite) -> [];
-error_index(doc) ->
- ["OTP-5558. Keep the contents of index files after disk crash."];
+%% OTP-5558. Keep the contents of index files after disk crash.
error_index(Conf) when is_list(Conf) ->
- ?line Dir = ?privdir(Conf),
+ Dir = ?privdir(Conf),
- ?line File = filename:join(Dir, "n.LOG"),
- ?line IdxFile = File ++ ".idx",
- ?line No = 4,
- ?line file:delete(File),
- ?line del(File, No), % cleanup
+ File = filename:join(Dir, "n.LOG"),
+ IdxFile = File ++ ".idx",
+ No = 4,
+ file:delete(File),
+ del(File, No), % cleanup
Args = [{name,n},{type,wrap},{size,{100,No}},{file,File}],
- ?line {ok, n} = disk_log:open(Args),
- ?line ok = disk_log:close(n),
- ?line Q = qlen(),
+ {ok, n} = disk_log:open(Args),
+ ok = disk_log:close(n),
+ Q = qlen(),
P0 = pps(),
- ?line ok = file:write_file(IdxFile, <<"abc">>),
- ?line {error, {invalid_index_file, _}} = disk_log:open(Args),
- ?line {error, {invalid_index_file, _}} = disk_log:open(Args),
- ?line {error, {invalid_index_file, _}} = disk_log:open(Args),
-
- ?line del(File, No),
- ?line true = (P0 == pps()),
- ?line true = (Q == qlen()),
+ ok = file:write_file(IdxFile, <<"abc">>),
+ {error, {invalid_index_file, _}} = disk_log:open(Args),
+ {error, {invalid_index_file, _}} = disk_log:open(Args),
+ {error, {invalid_index_file, _}} = disk_log:open(Args),
+
+ del(File, No),
+ true = (P0 == pps()),
+ true = (Q == qlen()),
ok.
-
-truncate(suite) -> [];
-truncate(doc) ->
- ["Test truncate/1 on halt and wrap logs."];
+
+%% Test truncate/1 on halt and wrap logs.
truncate(Conf) when is_list(Conf) ->
Dir = ?privdir(Conf),
- ?line Q = qlen(),
+ Q = qlen(),
Halt = join(Dir, "halt.LOG"),
- % Halt logs.
-
- ?line file:delete(Halt), % cleanup
- ?line {ok, halt} = disk_log:open([{name, halt}, {type, halt}, {file, Halt},
- {head, header}, {notify, true}]),
- ?line infinity = sz(halt),
- ?line ok = disk_log:truncate(halt, tjohej),
- ?line rec(1, {disk_log, node(), halt, {truncated, 1}}),
- ?line ok = disk_log:change_size(halt, 10000),
- ?line 10000 = sz(halt),
- ?line disk_log:close(halt),
- ?line [tjohej] = get_all_terms(halt, Halt, halt),
- ?line file:delete(Halt),
-
- ?line {ok, halt} = disk_log:open([{name, halt}, {type, halt}, {file, Halt},
- {head, header}, {notify, true}]),
- ?line ok = disk_log:truncate(halt),
- ?line rec(1, {disk_log, node(), halt, {truncated, 1}}),
- ?line disk_log:close(halt),
- ?line [header] = get_all_terms(halt, Halt, halt),
- ?line file:delete(Halt),
-
- ?line {ok, halt} = disk_log:open([{name, halt}, {type, halt},
- {file, Halt}, {format, external},
- {head, "header"}, {notify, false}]),
- ?line ok = disk_log:btruncate(halt, "apa"),
- ?line disk_log:close(halt),
- ?line 3 = file_size(Halt),
- ?line file:delete(Halt),
-
+ %% Halt logs.
+
+ file:delete(Halt), % cleanup
+ {ok, halt} = disk_log:open([{name, halt}, {type, halt}, {file, Halt},
+ {head, header}, {notify, true}]),
+ infinity = sz(halt),
+ ok = disk_log:truncate(halt, tjohej),
+ rec(1, {disk_log, node(), halt, {truncated, 1}}),
+ ok = disk_log:change_size(halt, 10000),
+ 10000 = sz(halt),
+ disk_log:close(halt),
+ [tjohej] = get_all_terms(halt, Halt, halt),
+ file:delete(Halt),
+
+ {ok, halt} = disk_log:open([{name, halt}, {type, halt}, {file, Halt},
+ {head, header}, {notify, true}]),
+ ok = disk_log:truncate(halt),
+ rec(1, {disk_log, node(), halt, {truncated, 1}}),
+ disk_log:close(halt),
+ [header] = get_all_terms(halt, Halt, halt),
+ file:delete(Halt),
+
+ {ok, halt} = disk_log:open([{name, halt}, {type, halt},
+ {file, Halt}, {format, external},
+ {head, "header"}, {notify, false}]),
+ ok = disk_log:btruncate(halt, "apa"),
+ disk_log:close(halt),
+ 3 = file_size(Halt),
+ file:delete(Halt),
+
%% Wrap logs.
- ?line File = filename:join(Dir, "n.LOG"),
- ?line No = 4,
- ?line B = mk_bytes(60),
- ?line del(File, No), % cleanup
+ File = filename:join(Dir, "n.LOG"),
+ No = 4,
+ B = mk_bytes(60),
+ del(File, No), % cleanup
%% Internal with header.
- ?line Size = {100, No},
- ?line {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
- {head, header}, {notify, true},
- {size, Size}]),
- ?line ok = disk_log:log_terms(n, [B,B,B]),
+ Size = {100, No},
+ {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
+ {head, header}, {notify, true},
+ {size, Size}]),
+ ok = disk_log:log_terms(n, [B,B,B]),
%% Used to be one message, but now one per wrapped file.
- ?line rec(2, {disk_log, node(), n, {wrap, 0}}),
- ?line ok = disk_log:truncate(n, apa),
- ?line rec(1, {disk_log, node(), n, {truncated, 6}}),
- ?line {0, 0} = no_overflows(n),
- ?line 23 = curb(n),
- ?line 1 = curf(n),
- ?line 1 = cur_cnt(n),
- ?line true = (Size == sz(n)),
-
- ?line ok = disk_log:log_terms(n, [B, B]),
- ?line rec(1, {disk_log, node(), n, {wrap, 0}}),
- ?line ok = disk_log:close(n),
- ?line [apa, _, header, _] = get_all_terms(n, File, wrap),
- ?line del(File, No),
-
+ rec(2, {disk_log, node(), n, {wrap, 0}}),
+ ok = disk_log:truncate(n, apa),
+ rec(1, {disk_log, node(), n, {truncated, 6}}),
+ {0, 0} = no_overflows(n),
+ 23 = curb(n),
+ 1 = curf(n),
+ 1 = cur_cnt(n),
+ true = (Size == sz(n)),
+
+ ok = disk_log:log_terms(n, [B, B]),
+ rec(1, {disk_log, node(), n, {wrap, 0}}),
+ ok = disk_log:close(n),
+ [apa, _, header, _] = get_all_terms(n, File, wrap),
+ del(File, No),
+
%% Internal without general header.
- ?line {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
- {notify, true},
- {size, {100, No}}]),
- ?line ok = disk_log:log_terms(n, [B,B,B]),
- ?line rec(2, {disk_log, node(), n, {wrap, 0}}),
- ?line ok = disk_log:truncate(n, apa),
- ?line rec(1, {disk_log, node(), n, {truncated, 3}}),
- ?line {0, 0} = no_overflows(n),
- ?line 23 = curb(n),
- ?line 1 = curf(n),
- ?line 1 = cur_cnt(n),
- ?line true = (Size == sz(n)),
-
- ?line ok = disk_log:log_terms(n, [B, B]),
- ?line rec(1, {disk_log, node(), n, {wrap, 0}}),
- ?line ok = disk_log:close(n),
- ?line [apa, _, _] = get_all_terms(n, File, wrap),
- ?line del(File, No),
+ {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
+ {notify, true},
+ {size, {100, No}}]),
+ ok = disk_log:log_terms(n, [B,B,B]),
+ rec(2, {disk_log, node(), n, {wrap, 0}}),
+ ok = disk_log:truncate(n, apa),
+ rec(1, {disk_log, node(), n, {truncated, 3}}),
+ {0, 0} = no_overflows(n),
+ 23 = curb(n),
+ 1 = curf(n),
+ 1 = cur_cnt(n),
+ true = (Size == sz(n)),
+
+ ok = disk_log:log_terms(n, [B, B]),
+ rec(1, {disk_log, node(), n, {wrap, 0}}),
+ ok = disk_log:close(n),
+ [apa, _, _] = get_all_terms(n, File, wrap),
+ del(File, No),
%% Internal without any header.
- ?line {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
- {notify, true},
- {size, {100, No}}]),
- ?line ok = disk_log:log_terms(n, [B,B,B]),
- ?line rec(2, {disk_log, node(), n, {wrap, 0}}),
- ?line ok = disk_log:truncate(n),
- ?line rec(1, {disk_log, node(), n, {truncated, 3}}),
- ?line {0, 0} = no_overflows(n),
- ?line 8 = curb(n),
- ?line 1 = curf(n),
- ?line 0 = cur_cnt(n),
- ?line true = (Size == sz(n)),
-
- ?line ok = disk_log:log_terms(n, [B, B]),
- ?line rec(1, {disk_log, node(), n, {wrap, 0}}),
- ?line ok = disk_log:close(n),
- ?line [_, _] = get_all_terms(n, File, wrap),
- ?line del(File, No),
- ?line Q = qlen(),
+ {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
+ {notify, true},
+ {size, {100, No}}]),
+ ok = disk_log:log_terms(n, [B,B,B]),
+ rec(2, {disk_log, node(), n, {wrap, 0}}),
+ ok = disk_log:truncate(n),
+ rec(1, {disk_log, node(), n, {truncated, 3}}),
+ {0, 0} = no_overflows(n),
+ 8 = curb(n),
+ 1 = curf(n),
+ 0 = cur_cnt(n),
+ true = (Size == sz(n)),
+
+ ok = disk_log:log_terms(n, [B, B]),
+ rec(1, {disk_log, node(), n, {wrap, 0}}),
+ ok = disk_log:close(n),
+ [_, _] = get_all_terms(n, File, wrap),
+ del(File, No),
+ Q = qlen(),
ok.
-many_users(suite) -> [];
-many_users(doc) ->
- ["Test many users logging and sync:ing at the same time."];
+%% Test many users logging and sync:ing at the same time.
many_users(Conf) when is_list(Conf) ->
Dir = ?privdir(Conf),
N = 100,
@@ -3199,32 +3114,32 @@ many_users(Conf) when is_list(Conf) ->
Fun1 = fun(Name, Pid, I) -> disk_log:log(Name, {Pid, I}) end,
Fun2 = fun(Name, Pid, I) -> ok = disk_log:log(Name, {Pid, I}),
disk_log:sync(Name) end,
- ?line {C1, T1} = many(Fun2, NoClients, N, halt, internal, infinity, Dir),
- ?line true = lists:duplicate(NoClients, ok) == C1,
- ?line true = length(T1) == N*NoClients,
- ?line {C2, T2} = many(Fun1, NoClients, N, halt, internal, 1000, Dir),
- ?line true = lists:duplicate(NoClients, {error, {full,"log.LOG"}}) == C2,
- ?line true = length(T2) > 0,
- ?line {C3, T3} = many(Fun2, NoClients, N, wrap, internal,
- {300*NoClients,200}, Dir),
- ?line true = lists:duplicate(NoClients, ok) == C3,
- ?line true = length(T3) == N*NoClients,
+ {C1, T1} = many(Fun2, NoClients, N, halt, internal, infinity, Dir),
+ true = lists:duplicate(NoClients, ok) == C1,
+ true = length(T1) == N*NoClients,
+ {C2, T2} = many(Fun1, NoClients, N, halt, internal, 1000, Dir),
+ true = lists:duplicate(NoClients, {error, {full,"log.LOG"}}) == C2,
+ true = length(T2) > 0,
+ {C3, T3} = many(Fun2, NoClients, N, wrap, internal,
+ {300*NoClients,200}, Dir),
+ true = lists:duplicate(NoClients, ok) == C3,
+ true = length(T3) == N*NoClients,
ok.
many(Fun, NoClients, N, Type, Format, Size, Dir) ->
Name = "log.LOG",
File = filename:join(Dir, Name),
del_files(Size, File),
- ?line Q = qlen(),
- ?line {ok, _} = disk_log:open([{name,Name}, {type,Type}, {size,Size},
- {format,Format}, {file,File}]),
- ?line Pids = spawn_clients(NoClients, client, [self(), Name, N, Fun]),
- ?line Checked = check_clients(Pids),
- ?line ok = disk_log:close(Name),
- ?line Terms = get_all_terms(Name, File, Type),
- ?line del_files(Size, File),
- ?line Q = qlen(),
- ?line {Checked, Terms}.
+ Q = qlen(),
+ {ok, _} = disk_log:open([{name,Name}, {type,Type}, {size,Size},
+ {format,Format}, {file,File}]),
+ Pids = spawn_clients(NoClients, client, [self(), Name, N, Fun]),
+ Checked = check_clients(Pids),
+ ok = disk_log:close(Name),
+ Terms = get_all_terms(Name, File, Type),
+ del_files(Size, File),
+ Q = qlen(),
+ {Checked, Terms}.
spawn_clients(0, _F, _A) ->
[];
@@ -3251,211 +3166,208 @@ del_files(_Size, File) ->
-info_current(suite) -> [];
-info_current(doc) ->
- ["Test no_current_{bytes, items} as returned by info/0."];
+%% Test no_current_{bytes, items} as returned by info/0.
info_current(Conf) when is_list(Conf) ->
Dir = ?privdir(Conf),
- ?line File = filename:join(Dir, "n.LOG"),
+ File = filename:join(Dir, "n.LOG"),
No = 4,
B = mk_bytes(60),
BB = mk_bytes(160), % bigger than a single wrap log file
SB = mk_bytes(10), % much smaller than a single wrap log file
- ?line del(File, No),% cleanup
+ del(File, No),% cleanup
- ?line Q = qlen(),
+ Q = qlen(),
%% Internal with header.
- ?line {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
- {head, header}, {size, {100,No}}]),
- ?line {26, 1} = {curb(n), cur_cnt(n)},
- ?line {1, 1} = {no_written_items(n), no_items(n)},
- ?line ok = disk_log:log(n, B),
- ?line {94, 2} = {curb(n), cur_cnt(n)},
- ?line {2, 2} = {no_written_items(n), no_items(n)},
- ?line ok = disk_log:close(n),
- ?line {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
- {notify, true},
- {head, header}, {size, {100,No}}]),
- ?line {94, 2} = {curb(n), cur_cnt(n)},
- ?line {0, 2} = {no_written_items(n), no_items(n)},
- ?line ok = disk_log:log(n, B),
- ?line rec(1, {disk_log, node(), n, {wrap, 0}}),
- ?line {94, 2} = {curb(n), cur_cnt(n)},
- ?line {2, 4} = {no_written_items(n), no_items(n)},
- ?line disk_log:inc_wrap_file(n),
- ?line rec(1, {disk_log, node(), n, {wrap, 0}}),
- ?line {26, 1} = {curb(n), cur_cnt(n)},
- ?line {3, 4} = {no_written_items(n), no_items(n)},
- ?line ok = disk_log:log_terms(n, [B,B,B]),
+ {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
+ {head, header}, {size, {100,No}}]),
+ {26, 1} = {curb(n), cur_cnt(n)},
+ {1, 1} = {no_written_items(n), no_items(n)},
+ ok = disk_log:log(n, B),
+ {94, 2} = {curb(n), cur_cnt(n)},
+ {2, 2} = {no_written_items(n), no_items(n)},
+ ok = disk_log:close(n),
+ {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
+ {notify, true},
+ {head, header}, {size, {100,No}}]),
+ {94, 2} = {curb(n), cur_cnt(n)},
+ {0, 2} = {no_written_items(n), no_items(n)},
+ ok = disk_log:log(n, B),
+ rec(1, {disk_log, node(), n, {wrap, 0}}),
+ {94, 2} = {curb(n), cur_cnt(n)},
+ {2, 4} = {no_written_items(n), no_items(n)},
+ disk_log:inc_wrap_file(n),
+ rec(1, {disk_log, node(), n, {wrap, 0}}),
+ {26, 1} = {curb(n), cur_cnt(n)},
+ {3, 4} = {no_written_items(n), no_items(n)},
+ ok = disk_log:log_terms(n, [B,B,B]),
%% Used to be one message, but now one per wrapped file.
- ?line rec(1, {disk_log, node(), n, {wrap, 0}}),
- ?line rec(1, {disk_log, node(), n, {wrap, 2}}),
- ?line {94, 2} = {curb(n), cur_cnt(n)},
- ?line {8, 7} = {no_written_items(n), no_items(n)},
- ?line ok = disk_log:log_terms(n, [B]),
- ?line rec(1, {disk_log, node(), n, {wrap, 2}}),
- ?line ok = disk_log:log_terms(n, [B]),
- ?line rec(1, {disk_log, node(), n, {wrap, 2}}),
- ?line {94, 2} = {curb(n), cur_cnt(n)},
- ?line {12, 7} = {no_written_items(n), no_items(n)},
- ?line ok = disk_log:log_terms(n, [BB,BB]),
+ rec(1, {disk_log, node(), n, {wrap, 0}}),
+ rec(1, {disk_log, node(), n, {wrap, 2}}),
+ {94, 2} = {curb(n), cur_cnt(n)},
+ {8, 7} = {no_written_items(n), no_items(n)},
+ ok = disk_log:log_terms(n, [B]),
+ rec(1, {disk_log, node(), n, {wrap, 2}}),
+ ok = disk_log:log_terms(n, [B]),
+ rec(1, {disk_log, node(), n, {wrap, 2}}),
+ {94, 2} = {curb(n), cur_cnt(n)},
+ {12, 7} = {no_written_items(n), no_items(n)},
+ ok = disk_log:log_terms(n, [BB,BB]),
%% Used to be one message, but now one per wrapped file.
- ?line rec(2, {disk_log, node(), n, {wrap, 2}}),
- ?line {194, 2} = {curb(n), cur_cnt(n)},
- ?line {16, 7} = {no_written_items(n), no_items(n)},
- ?line ok = disk_log:log_terms(n, [SB,SB,SB]),
- ?line rec(1, {disk_log, node(), n, {wrap, 2}}),
- ?line {80, 4} = {curb(n), cur_cnt(n)},
- ?line {20, 9} = {no_written_items(n), no_items(n)},
- ?line ok = disk_log:close(n),
- ?line del(File, No),
+ rec(2, {disk_log, node(), n, {wrap, 2}}),
+ {194, 2} = {curb(n), cur_cnt(n)},
+ {16, 7} = {no_written_items(n), no_items(n)},
+ ok = disk_log:log_terms(n, [SB,SB,SB]),
+ rec(1, {disk_log, node(), n, {wrap, 2}}),
+ {80, 4} = {curb(n), cur_cnt(n)},
+ {20, 9} = {no_written_items(n), no_items(n)},
+ ok = disk_log:close(n),
+ del(File, No),
%% Internal without header.
- ?line {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
- {size, {100,No}}]),
- ?line {8, 0} = {curb(n), cur_cnt(n)},
- ?line {0, 0} = {no_written_items(n), no_items(n)},
- ?line ok = disk_log:log(n, B),
- ?line {76, 1} = {curb(n), cur_cnt(n)},
- ?line {1, 1} = {no_written_items(n), no_items(n)},
- ?line ok = disk_log:close(n),
- ?line {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
- {notify, true}, {size, {100,No}}]),
- ?line {76, 1} = {curb(n), cur_cnt(n)},
- ?line {0, 1} = {no_written_items(n), no_items(n)},
- ?line ok = disk_log:log(n, B),
- ?line rec(1, {disk_log, node(), n, {wrap, 0}}),
- ?line {76, 1} = {curb(n), cur_cnt(n)},
- ?line {1, 2} = {no_written_items(n), no_items(n)},
- ?line disk_log:inc_wrap_file(n),
- ?line rec(1, {disk_log, node(), n, {wrap, 0}}),
- ?line {8, 0} = {curb(n), cur_cnt(n)},
- ?line {1, 2} = {no_written_items(n), no_items(n)},
- ?line ok = disk_log:log_terms(n, [B,B,B]),
+ {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
+ {size, {100,No}}]),
+ {8, 0} = {curb(n), cur_cnt(n)},
+ {0, 0} = {no_written_items(n), no_items(n)},
+ ok = disk_log:log(n, B),
+ {76, 1} = {curb(n), cur_cnt(n)},
+ {1, 1} = {no_written_items(n), no_items(n)},
+ ok = disk_log:close(n),
+ {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
+ {notify, true}, {size, {100,No}}]),
+ {76, 1} = {curb(n), cur_cnt(n)},
+ {0, 1} = {no_written_items(n), no_items(n)},
+ ok = disk_log:log(n, B),
+ rec(1, {disk_log, node(), n, {wrap, 0}}),
+ {76, 1} = {curb(n), cur_cnt(n)},
+ {1, 2} = {no_written_items(n), no_items(n)},
+ disk_log:inc_wrap_file(n),
+ rec(1, {disk_log, node(), n, {wrap, 0}}),
+ {8, 0} = {curb(n), cur_cnt(n)},
+ {1, 2} = {no_written_items(n), no_items(n)},
+ ok = disk_log:log_terms(n, [B,B,B]),
%% Used to be one message, but now one per wrapped file.
- ?line rec(1, {disk_log, node(), n, {wrap, 0}}),
- ?line rec(1, {disk_log, node(), n, {wrap, 1}}),
- ?line {76, 1} = {curb(n), cur_cnt(n)},
- ?line {4, 4} = {no_written_items(n), no_items(n)},
- ?line ok = disk_log:log_terms(n, [B]),
- ?line rec(1, {disk_log, node(), n, {wrap, 1}}),
- ?line ok = disk_log:log_terms(n, [B]),
- ?line rec(1, {disk_log, node(), n, {wrap, 1}}),
- ?line {76, 1} = {curb(n), cur_cnt(n)},
- ?line {6, 4} = {no_written_items(n), no_items(n)},
- ?line ok = disk_log:log_terms(n, [BB,BB]),
+ rec(1, {disk_log, node(), n, {wrap, 0}}),
+ rec(1, {disk_log, node(), n, {wrap, 1}}),
+ {76, 1} = {curb(n), cur_cnt(n)},
+ {4, 4} = {no_written_items(n), no_items(n)},
+ ok = disk_log:log_terms(n, [B]),
+ rec(1, {disk_log, node(), n, {wrap, 1}}),
+ ok = disk_log:log_terms(n, [B]),
+ rec(1, {disk_log, node(), n, {wrap, 1}}),
+ {76, 1} = {curb(n), cur_cnt(n)},
+ {6, 4} = {no_written_items(n), no_items(n)},
+ ok = disk_log:log_terms(n, [BB,BB]),
%% Used to be one message, but now one per wrapped file.
- ?line rec(2, {disk_log, node(), n, {wrap, 1}}),
- ?line {176, 1} = {curb(n), cur_cnt(n)},
- ?line {8, 4} = {no_written_items(n), no_items(n)},
- ?line ok = disk_log:log_terms(n, [SB,SB,SB]),
- ?line rec(1, {disk_log, node(), n, {wrap, 1}}),
- ?line {62, 3} = {curb(n), cur_cnt(n)},
- ?line {11, 6} = {no_written_items(n), no_items(n)},
- ?line ok = disk_log:close(n),
- ?line del(File, No),
+ rec(2, {disk_log, node(), n, {wrap, 1}}),
+ {176, 1} = {curb(n), cur_cnt(n)},
+ {8, 4} = {no_written_items(n), no_items(n)},
+ ok = disk_log:log_terms(n, [SB,SB,SB]),
+ rec(1, {disk_log, node(), n, {wrap, 1}}),
+ {62, 3} = {curb(n), cur_cnt(n)},
+ {11, 6} = {no_written_items(n), no_items(n)},
+ ok = disk_log:close(n),
+ del(File, No),
%% External with header.
- ?line {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
- {format, external}, {head, "header"},
- {size, {100,No}}]),
- ?line {6, 1} = {curb(n), cur_cnt(n)},
- ?line {1, 1} = {no_written_items(n), no_items(n)},
- ?line ok = disk_log:blog(n, B),
- ?line {62, 2} = {curb(n), cur_cnt(n)},
- ?line {2, 2} = {no_written_items(n), no_items(n)},
- ?line ok = disk_log:close(n),
- ?line {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
- {format, external}, {head, "header"},
- {notify, true}, {size, {100,No}}]),
- ?line {62, 2} = {curb(n), cur_cnt(n)},
- ?line {0, 2} = {no_written_items(n), no_items(n)},
- ?line ok = disk_log:blog(n, B),
- ?line rec(1, {disk_log, node(), n, {wrap, 0}}),
- ?line {62, 2} = {curb(n), cur_cnt(n)},
- ?line {2, 4} = {no_written_items(n), no_items(n)},
- ?line disk_log:inc_wrap_file(n),
- ?line rec(1, {disk_log, node(), n, {wrap, 0}}),
- ?line {6, 1} = {curb(n), cur_cnt(n)},
- ?line {3, 4} = {no_written_items(n), no_items(n)},
- ?line ok = disk_log:blog_terms(n, [B,B,B]),
+ {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
+ {format, external}, {head, "header"},
+ {size, {100,No}}]),
+ {6, 1} = {curb(n), cur_cnt(n)},
+ {1, 1} = {no_written_items(n), no_items(n)},
+ ok = disk_log:blog(n, B),
+ {62, 2} = {curb(n), cur_cnt(n)},
+ {2, 2} = {no_written_items(n), no_items(n)},
+ ok = disk_log:close(n),
+ {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
+ {format, external}, {head, "header"},
+ {notify, true}, {size, {100,No}}]),
+ {62, 2} = {curb(n), cur_cnt(n)},
+ {0, 2} = {no_written_items(n), no_items(n)},
+ ok = disk_log:blog(n, B),
+ rec(1, {disk_log, node(), n, {wrap, 0}}),
+ {62, 2} = {curb(n), cur_cnt(n)},
+ {2, 4} = {no_written_items(n), no_items(n)},
+ disk_log:inc_wrap_file(n),
+ rec(1, {disk_log, node(), n, {wrap, 0}}),
+ {6, 1} = {curb(n), cur_cnt(n)},
+ {3, 4} = {no_written_items(n), no_items(n)},
+ ok = disk_log:blog_terms(n, [B,B,B]),
%% Used to be one message, but now one per wrapped file.
- ?line rec(1, {disk_log, node(), n, {wrap, 0}}),
- ?line rec(1, {disk_log, node(), n, {wrap, 2}}),
- ?line {62, 2} = {curb(n), cur_cnt(n)},
- ?line {8, 7} = {no_written_items(n), no_items(n)},
- ?line ok = disk_log:blog_terms(n, [B]),
- ?line rec(1, {disk_log, node(), n, {wrap, 2}}),
- ?line ok = disk_log:blog_terms(n, [B]),
- ?line rec(1, {disk_log, node(), n, {wrap, 2}}),
- ?line {62, 2} = {curb(n), cur_cnt(n)},
- ?line {12, 7} = {no_written_items(n), no_items(n)},
- ?line ok = disk_log:blog_terms(n, [BB,BB]),
+ rec(1, {disk_log, node(), n, {wrap, 0}}),
+ rec(1, {disk_log, node(), n, {wrap, 2}}),
+ {62, 2} = {curb(n), cur_cnt(n)},
+ {8, 7} = {no_written_items(n), no_items(n)},
+ ok = disk_log:blog_terms(n, [B]),
+ rec(1, {disk_log, node(), n, {wrap, 2}}),
+ ok = disk_log:blog_terms(n, [B]),
+ rec(1, {disk_log, node(), n, {wrap, 2}}),
+ {62, 2} = {curb(n), cur_cnt(n)},
+ {12, 7} = {no_written_items(n), no_items(n)},
+ ok = disk_log:blog_terms(n, [BB,BB]),
%% Used to be one message, but now one per wrapped file.
- ?line rec(2, {disk_log, node(), n, {wrap, 2}}),
- ?line {162, 2} = {curb(n), cur_cnt(n)},
- ?line {16, 7} = {no_written_items(n), no_items(n)},
- ?line ok = disk_log:blog_terms(n, [SB,SB,SB]),
-
- ?line rec(1, {disk_log, node(), n, {wrap, 2}}),
- ?line {24, 4} = {curb(n), cur_cnt(n)},
- ?line {20, 9} = {no_written_items(n), no_items(n)},
- ?line ok = disk_log:close(n),
- ?line del(File, No),
+ rec(2, {disk_log, node(), n, {wrap, 2}}),
+ {162, 2} = {curb(n), cur_cnt(n)},
+ {16, 7} = {no_written_items(n), no_items(n)},
+ ok = disk_log:blog_terms(n, [SB,SB,SB]),
+
+ rec(1, {disk_log, node(), n, {wrap, 2}}),
+ {24, 4} = {curb(n), cur_cnt(n)},
+ {20, 9} = {no_written_items(n), no_items(n)},
+ ok = disk_log:close(n),
+ del(File, No),
%% External without header.
- ?line {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
- {format, external}, {size, {100,No}}]),
- ?line {0, 0} = {curb(n), cur_cnt(n)},
- ?line {0, 0} = {no_written_items(n), no_items(n)},
- ?line ok = disk_log:blog(n, B),
- ?line {56, 1} = {curb(n), cur_cnt(n)},
- ?line {1, 1} = {no_written_items(n), no_items(n)},
- ?line ok = disk_log:close(n),
- ?line {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
- {notify, true},
- {format, external}, {size, {100,No}}]),
- ?line {56, 1} = {curb(n), cur_cnt(n)},
- ?line {0, 1} = {no_written_items(n), no_items(n)},
- ?line ok = disk_log:blog(n, B),
- ?line rec(1, {disk_log, node(), n, {wrap, 0}}),
- ?line {56, 1} = {curb(n), cur_cnt(n)},
- ?line {1, 2} = {no_written_items(n), no_items(n)},
- ?line disk_log:inc_wrap_file(n),
- ?line rec(1, {disk_log, node(), n, {wrap, 0}}),
- ?line {0, 0} = {curb(n), cur_cnt(n)},
- ?line {1, 2} = {no_written_items(n), no_items(n)},
- ?line ok = disk_log:blog_terms(n, [B,B,B]),
+ {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
+ {format, external}, {size, {100,No}}]),
+ {0, 0} = {curb(n), cur_cnt(n)},
+ {0, 0} = {no_written_items(n), no_items(n)},
+ ok = disk_log:blog(n, B),
+ {56, 1} = {curb(n), cur_cnt(n)},
+ {1, 1} = {no_written_items(n), no_items(n)},
+ ok = disk_log:close(n),
+ {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
+ {notify, true},
+ {format, external}, {size, {100,No}}]),
+ {56, 1} = {curb(n), cur_cnt(n)},
+ {0, 1} = {no_written_items(n), no_items(n)},
+ ok = disk_log:blog(n, B),
+ rec(1, {disk_log, node(), n, {wrap, 0}}),
+ {56, 1} = {curb(n), cur_cnt(n)},
+ {1, 2} = {no_written_items(n), no_items(n)},
+ disk_log:inc_wrap_file(n),
+ rec(1, {disk_log, node(), n, {wrap, 0}}),
+ {0, 0} = {curb(n), cur_cnt(n)},
+ {1, 2} = {no_written_items(n), no_items(n)},
+ ok = disk_log:blog_terms(n, [B,B,B]),
%% Used to be one message, but now one per wrapped file.
- ?line rec(1, {disk_log, node(), n, {wrap, 0}}),
- ?line rec(1, {disk_log, node(), n, {wrap, 1}}),
- ?line {56, 1} = {curb(n), cur_cnt(n)},
- ?line {4, 4} = {no_written_items(n), no_items(n)},
- ?line ok = disk_log:blog_terms(n, [B]),
- ?line rec(1, {disk_log, node(), n, {wrap, 1}}),
- ?line ok = disk_log:blog_terms(n, [B]),
- ?line rec(1, {disk_log, node(), n, {wrap, 1}}),
- ?line {56, 1} = {curb(n), cur_cnt(n)},
- ?line {6, 4} = {no_written_items(n), no_items(n)},
- ?line ok = disk_log:blog_terms(n, [BB,BB]),
+ rec(1, {disk_log, node(), n, {wrap, 0}}),
+ rec(1, {disk_log, node(), n, {wrap, 1}}),
+ {56, 1} = {curb(n), cur_cnt(n)},
+ {4, 4} = {no_written_items(n), no_items(n)},
+ ok = disk_log:blog_terms(n, [B]),
+ rec(1, {disk_log, node(), n, {wrap, 1}}),
+ ok = disk_log:blog_terms(n, [B]),
+ rec(1, {disk_log, node(), n, {wrap, 1}}),
+ {56, 1} = {curb(n), cur_cnt(n)},
+ {6, 4} = {no_written_items(n), no_items(n)},
+ ok = disk_log:blog_terms(n, [BB,BB]),
%% Used to be one message, but now one per wrapped file.
- ?line rec(2, {disk_log, node(), n, {wrap, 1}}),
- ?line {156, 1} = {curb(n), cur_cnt(n)},
- ?line {8, 4} = {no_written_items(n), no_items(n)},
- ?line ok = disk_log:blog_terms(n, [SB,SB,SB]),
- ?line rec(1, {disk_log, node(), n, {wrap, 1}}),
- ?line {18, 3} = {curb(n), cur_cnt(n)},
- ?line {11, 6} = {no_written_items(n), no_items(n)},
- ?line ok = disk_log:close(n),
- ?line del(File, No),
-
- ?line Q = qlen(),
+ rec(2, {disk_log, node(), n, {wrap, 1}}),
+ {156, 1} = {curb(n), cur_cnt(n)},
+ {8, 4} = {no_written_items(n), no_items(n)},
+ ok = disk_log:blog_terms(n, [SB,SB,SB]),
+ rec(1, {disk_log, node(), n, {wrap, 1}}),
+ {18, 3} = {curb(n), cur_cnt(n)},
+ {11, 6} = {no_written_items(n), no_items(n)},
+ ok = disk_log:close(n),
+ del(File, No),
+
+ Q = qlen(),
ok.
-change_size_before(suite) -> [];
change_size_before(doc) ->
["Change size of a wrap log file before we have reached "
"to the file index corresponding to the new size"];
@@ -3478,138 +3390,136 @@ change_size_before(Conf) when is_list(Conf) ->
Dir = ?privdir(Conf),
File = filename:join(Dir, "a.LOG"),
del(File, 5),
- ?line {ok, a} = disk_log:open([{name,a}, {file, File},
- {type, wrap}, {size, {100,5}}]),
- ?line disk_log:log(a, Log_1_1),
- ?line disk_log:log(a, Log_1_2),
- ?line disk_log:log(a, Log_2_1),
- ?line disk_log:log(a, Log_2_2),
- ?line disk_log:change_size(a, {100, 3}),
- ?line [Log_1_1, Log_1_2,
- Log_2_1, Log_2_2] = get_all_terms(a),
- ?line disk_log:log(a, Log_3_1),
- ?line disk_log:log(a, Log_3_2),
- ?line disk_log:log(a, Log_1_2_1),
- ?line disk_log:log(a, Log_1_2_2),
- ?line [Log_2_1, Log_2_2,
- Log_3_1, Log_3_2,
- Log_1_2_1, Log_1_2_2] = get_all_terms(a),
-
- ?line disk_log:close(a),
- ?line {ok, a} = disk_log:open([{name,a}, {file, File}, {type, wrap},
- {size, {100,3}}]),
- ?line [Log_2_1, Log_2_2,
- Log_3_1, Log_3_2,
- Log_1_2_1, Log_1_2_2] = get_all_terms(a),
+ {ok, a} = disk_log:open([{name,a}, {file, File},
+ {type, wrap}, {size, {100,5}}]),
+ disk_log:log(a, Log_1_1),
+ disk_log:log(a, Log_1_2),
+ disk_log:log(a, Log_2_1),
+ disk_log:log(a, Log_2_2),
+ disk_log:change_size(a, {100, 3}),
+ [Log_1_1, Log_1_2,
+ Log_2_1, Log_2_2] = get_all_terms(a),
+ disk_log:log(a, Log_3_1),
+ disk_log:log(a, Log_3_2),
+ disk_log:log(a, Log_1_2_1),
+ disk_log:log(a, Log_1_2_2),
+ [Log_2_1, Log_2_2,
+ Log_3_1, Log_3_2,
+ Log_1_2_1, Log_1_2_2] = get_all_terms(a),
+
+ disk_log:close(a),
+ {ok, a} = disk_log:open([{name,a}, {file, File}, {type, wrap},
+ {size, {100,3}}]),
+ [Log_2_1, Log_2_2,
+ Log_3_1, Log_3_2,
+ Log_1_2_1, Log_1_2_2] = get_all_terms(a),
disk_log:close(a),
del(File, 5),
- ?line {ok, a} = disk_log:open([{name,a}, {file, File}, {type, wrap},
- {size, {60,5}}, {format, external}]),
- ?line disk_log:blog(a, Log_1_1),
- ?line disk_log:blog(a, Log_1_2),
- ?line disk_log:blog(a, Log_2_1),
- ?line disk_log:blog(a, Log_2_2),
- ?line disk_log:change_size(a, {60, 3}),
- ?line ok = disk_log:sync(a),
- ?line {ok, Fd1} = file:open(File ++ ".1", [read]),
- ?line Log11_12 = Log_1_1 ++ Log_1_2,
- ?line {ok,Log11_12} = file:read(Fd1, 200),
- ?line ok = file:close(Fd1),
- ?line {ok, Fd2} = file:open(File ++ ".2", [read]),
-% ?t:format(0, "~p~n",[file:read(Fd2, 200)]),
- ?line Log21_22 = Log_2_1 ++ Log_2_2,
- ?line {ok,Log21_22} = file:read(Fd2, 200),
- ?line ok = file:close(Fd2),
- ?line disk_log:blog(a, Log_3_1),
- ?line disk_log:blog(a, Log_3_2),
- ?line disk_log:blog(a, Log_1_2_1),
- ?line disk_log:blog(a, Log_1_2_2),
- ?line ok = disk_log:sync(a),
- ?line {ok, Fd2a} = file:open(File ++ ".2", [read]),
- ?line {ok,Log21_22} = file:read(Fd2a, 200),
- ?line ok = file:close(Fd2a),
- ?line {ok, Fd3a} = file:open(File ++ ".3", [read]),
- ?line Log31_32 = Log_3_1 ++ Log_3_2,
- ?line {ok,Log31_32} = file:read(Fd3a, 200),
- ?line ok = file:close(Fd3a),
- ?line {ok, Fd1a} = file:open(File ++ ".1", [read]),
- ?line Log121_122 = Log_1_2_1 ++ Log_1_2_2,
- ?line {ok,Log121_122} = file:read(Fd1a, 200),
- ?line ok = file:close(Fd1a),
-
- ?line disk_log:close(a),
- ?line {ok, a} = disk_log:open([{name,a}, {file, File}, {type, wrap},
- {size, {60,3}}, {format, external}]),
- ?line {ok, Fd2b} = file:open(File ++ ".2", [read]),
- ?line {ok,Log21_22} = file:read(Fd2b, 200),
- ?line ok = file:close(Fd2b),
- ?line {ok, Fd3b} = file:open(File ++ ".3", [read]),
- ?line {ok,Log31_32} = file:read(Fd3b, 200),
- ?line ok = file:close(Fd3b),
- ?line {ok, Fd1b} = file:open(File ++ ".1", [read]),
- ?line {ok,Log121_122} = file:read(Fd1b, 200),
- ?line ok = file:close(Fd1b),
+ {ok, a} = disk_log:open([{name,a}, {file, File}, {type, wrap},
+ {size, {60,5}}, {format, external}]),
+ disk_log:blog(a, Log_1_1),
+ disk_log:blog(a, Log_1_2),
+ disk_log:blog(a, Log_2_1),
+ disk_log:blog(a, Log_2_2),
+ disk_log:change_size(a, {60, 3}),
+ ok = disk_log:sync(a),
+ {ok, Fd1} = file:open(File ++ ".1", [read]),
+ Log11_12 = Log_1_1 ++ Log_1_2,
+ {ok,Log11_12} = file:read(Fd1, 200),
+ ok = file:close(Fd1),
+ {ok, Fd2} = file:open(File ++ ".2", [read]),
+ Log21_22 = Log_2_1 ++ Log_2_2,
+ {ok,Log21_22} = file:read(Fd2, 200),
+ ok = file:close(Fd2),
+ disk_log:blog(a, Log_3_1),
+ disk_log:blog(a, Log_3_2),
+ disk_log:blog(a, Log_1_2_1),
+ disk_log:blog(a, Log_1_2_2),
+ ok = disk_log:sync(a),
+ {ok, Fd2a} = file:open(File ++ ".2", [read]),
+ {ok,Log21_22} = file:read(Fd2a, 200),
+ ok = file:close(Fd2a),
+ {ok, Fd3a} = file:open(File ++ ".3", [read]),
+ Log31_32 = Log_3_1 ++ Log_3_2,
+ {ok,Log31_32} = file:read(Fd3a, 200),
+ ok = file:close(Fd3a),
+ {ok, Fd1a} = file:open(File ++ ".1", [read]),
+ Log121_122 = Log_1_2_1 ++ Log_1_2_2,
+ {ok,Log121_122} = file:read(Fd1a, 200),
+ ok = file:close(Fd1a),
+
+ disk_log:close(a),
+ {ok, a} = disk_log:open([{name,a}, {file, File}, {type, wrap},
+ {size, {60,3}}, {format, external}]),
+ {ok, Fd2b} = file:open(File ++ ".2", [read]),
+ {ok,Log21_22} = file:read(Fd2b, 200),
+ ok = file:close(Fd2b),
+ {ok, Fd3b} = file:open(File ++ ".3", [read]),
+ {ok,Log31_32} = file:read(Fd3b, 200),
+ ok = file:close(Fd3b),
+ {ok, Fd1b} = file:open(File ++ ".1", [read]),
+ {ok,Log121_122} = file:read(Fd1b, 200),
+ ok = file:close(Fd1b),
disk_log:close(a),
del(File, 5),
- ?line {ok, a} = disk_log:open([{name,a}, {file, File}, {type, wrap}, {size, {100,5}}]),
- ?line disk_log:log(a, Log_1_1),
- ?line disk_log:log(a, Log_1_2),
- ?line disk_log:log(a, Log_2_1),
- ?line disk_log:log(a, Log_2_2),
- ?line disk_log:change_size(a, {60, 3}),
- ?line [Log_1_1, Log_1_2,
- Log_2_1, Log_2_2] = get_all_terms(a),
- ?line disk_log:log(a, Log_3_1),
- ?line disk_log:log(a, Log_1_2_1),
- ?line [Log_2_1, Log_2_2,
- Log_3_1,
- Log_1_2_1] = get_all_terms(a),
-
- ?line disk_log:close(a),
- ?line {ok, a} = disk_log:open([{name,a}, {file, File}, {type, wrap}, {size, {60,3}}]),
- ?line [Log_2_1, Log_2_2,
- Log_3_1,
- Log_1_2_1] = get_all_terms(a),
+ {ok, a} = disk_log:open([{name,a}, {file, File}, {type, wrap}, {size, {100,5}}]),
+ disk_log:log(a, Log_1_1),
+ disk_log:log(a, Log_1_2),
+ disk_log:log(a, Log_2_1),
+ disk_log:log(a, Log_2_2),
+ disk_log:change_size(a, {60, 3}),
+ [Log_1_1, Log_1_2,
+ Log_2_1, Log_2_2] = get_all_terms(a),
+ disk_log:log(a, Log_3_1),
+ disk_log:log(a, Log_1_2_1),
+ [Log_2_1, Log_2_2,
+ Log_3_1,
+ Log_1_2_1] = get_all_terms(a),
+
+ disk_log:close(a),
+ {ok, a} = disk_log:open([{name,a}, {file, File}, {type, wrap}, {size, {60,3}}]),
+ [Log_2_1, Log_2_2,
+ Log_3_1,
+ Log_1_2_1] = get_all_terms(a),
disk_log:close(a),
del(File, 5),
- ?line {ok, a} = disk_log:open([{name,a}, {file, File}, {type, wrap}, {size, {60, 3}}]),
- ?line disk_log:log(a, Log_1_1),
- ?line disk_log:log(a, Log_2_1),
- ?line disk_log:change_size(a, {100, 5}),
- ?line [Log_1_1,
- Log_2_1] = get_all_terms(a),
- ?line disk_log:log(a, Log_2_2),
- ?line disk_log:log(a, Log_3_1),
- ?line disk_log:log(a, Log_3_2),
- ?line disk_log:log(a, Log_4_1),
- ?line disk_log:log(a, Log_4_2),
- ?line disk_log:log(a, Log_5_1),
- ?line disk_log:log(a, Log_5_2),
- ?line disk_log:log(a, Log_1_2_1),
- ?line [Log_2_1, Log_2_2,
- Log_3_1, Log_3_2,
- Log_4_1, Log_4_2,
- Log_5_1, Log_5_2,
- Log_1_2_1] = get_all_terms(a),
-
- ?line disk_log:close(a),
- ?line {ok, a} = disk_log:open([{name,a}, {file, File}, {type, wrap}, {size, {100, 5}}]),
- ?line [Log_2_1, Log_2_2,
- Log_3_1, Log_3_2,
- Log_4_1, Log_4_2,
- Log_5_1, Log_5_2,
- Log_1_2_1] = get_all_terms(a),
+ {ok, a} = disk_log:open([{name,a}, {file, File}, {type, wrap}, {size, {60, 3}}]),
+ disk_log:log(a, Log_1_1),
+ disk_log:log(a, Log_2_1),
+ disk_log:change_size(a, {100, 5}),
+ [Log_1_1,
+ Log_2_1] = get_all_terms(a),
+ disk_log:log(a, Log_2_2),
+ disk_log:log(a, Log_3_1),
+ disk_log:log(a, Log_3_2),
+ disk_log:log(a, Log_4_1),
+ disk_log:log(a, Log_4_2),
+ disk_log:log(a, Log_5_1),
+ disk_log:log(a, Log_5_2),
+ disk_log:log(a, Log_1_2_1),
+ [Log_2_1, Log_2_2,
+ Log_3_1, Log_3_2,
+ Log_4_1, Log_4_2,
+ Log_5_1, Log_5_2,
+ Log_1_2_1] = get_all_terms(a),
+
+ disk_log:close(a),
+ {ok, a} = disk_log:open([{name,a}, {file, File}, {type, wrap}, {size, {100, 5}}]),
+ [Log_2_1, Log_2_2,
+ Log_3_1, Log_3_2,
+ Log_4_1, Log_4_2,
+ Log_5_1, Log_5_2,
+ Log_1_2_1] = get_all_terms(a),
disk_log:close(a),
del(File, 5).
-change_size_during(suite) -> [];
-change_size_during(doc) -> ["Change size of a wrap log file while logging "
- "to a file index between the old and the new size"];
+%% Change size of a wrap log file while logging to a file index
+%% between the old and the new size.
change_size_during(Conf) when is_list(Conf) ->
Log_1_1 = "first log first message",
@@ -3633,114 +3543,111 @@ change_size_during(Conf) when is_list(Conf) ->
Dir = ?privdir(Conf),
File = filename:join(Dir, "a.LOG"),
- ?line {ok, a} = disk_log:open([{name,a}, {file, File}, {type, wrap}, {size, {100,5}}]),
- ?line disk_log:log(a, Log_1_1),
- ?line disk_log:log(a, Log_1_2),
- ?line disk_log:log(a, Log_2_1),
- ?line disk_log:log(a, Log_2_2),
- ?line disk_log:log(a, Log_3_1),
- ?line disk_log:log(a, Log_3_2),
- ?line disk_log:log(a, Log_4_1),
- ?line disk_log:log(a, Log_4_2),
- ?line disk_log:log(a, Log_5_1),
- ?line disk_log:log(a, Log_5_2),
- ?line disk_log:log(a, Log_1_1),
- ?line disk_log:log(a, Log_1_2),
- ?line disk_log:log(a, Log_2_1),
- ?line disk_log:log(a, Log_2_2),
- ?line disk_log:log(a, Log_3_1),
- ?line disk_log:log(a, Log_3_2),
- ?line disk_log:log(a, Log_4_1),
- ?line disk_log:log(a, Log_4_2),
- ?line disk_log:change_size(a, {100, 3}),
- ?line [Log_5_1, Log_5_2,
- Log_1_1, Log_1_2,
- Log_2_1, Log_2_2,
- Log_3_1, Log_3_2,
- Log_4_1, Log_4_2] = get_all_terms(a),
- ?line disk_log:log(a, Log_1_2_1),
- ?line disk_log:log(a, Log_1_2_2),
- ?line [Log_2_1, Log_2_2,
- Log_3_1, Log_3_2,
- Log_4_1, Log_4_2,
- Log_1_2_1, Log_1_2_2] = get_all_terms(a),
-
- ?line disk_log:close(a),
- ?line {ok, a} = disk_log:open([{name,a}, {file, File}, {type, wrap}, {size, {100,3}}]),
- ?line [Log_2_1, Log_2_2,
- Log_3_1, Log_3_2,
- Log_4_1, Log_4_2,
- Log_1_2_1, Log_1_2_2] = get_all_terms(a),
- ?line disk_log:log(a, Log_2_2_1),
- ?line disk_log:log(a, Log_2_2_2),
- ?line disk_log:log(a, Log_3_2_1),
- ?line disk_log:log(a, Log_3_2_2),
- ?line disk_log:log(a, Log_1_3_1),
- ?line disk_log:log(a, Log_1_3_2),
- ?line [Log_2_2_1, Log_2_2_2,
- Log_3_2_1, Log_3_2_2,
- Log_1_3_1, Log_1_3_2] = get_all_terms(a),
+ {ok, a} = disk_log:open([{name,a}, {file, File}, {type, wrap}, {size, {100,5}}]),
+ disk_log:log(a, Log_1_1),
+ disk_log:log(a, Log_1_2),
+ disk_log:log(a, Log_2_1),
+ disk_log:log(a, Log_2_2),
+ disk_log:log(a, Log_3_1),
+ disk_log:log(a, Log_3_2),
+ disk_log:log(a, Log_4_1),
+ disk_log:log(a, Log_4_2),
+ disk_log:log(a, Log_5_1),
+ disk_log:log(a, Log_5_2),
+ disk_log:log(a, Log_1_1),
+ disk_log:log(a, Log_1_2),
+ disk_log:log(a, Log_2_1),
+ disk_log:log(a, Log_2_2),
+ disk_log:log(a, Log_3_1),
+ disk_log:log(a, Log_3_2),
+ disk_log:log(a, Log_4_1),
+ disk_log:log(a, Log_4_2),
+ disk_log:change_size(a, {100, 3}),
+ [Log_5_1, Log_5_2,
+ Log_1_1, Log_1_2,
+ Log_2_1, Log_2_2,
+ Log_3_1, Log_3_2,
+ Log_4_1, Log_4_2] = get_all_terms(a),
+ disk_log:log(a, Log_1_2_1),
+ disk_log:log(a, Log_1_2_2),
+ [Log_2_1, Log_2_2,
+ Log_3_1, Log_3_2,
+ Log_4_1, Log_4_2,
+ Log_1_2_1, Log_1_2_2] = get_all_terms(a),
+
disk_log:close(a),
- ?line {ok, a} = disk_log:open([{name,a}, {file, File}, {type, wrap}, {size, {100,3}}]),
- ?line [Log_2_2_1, Log_2_2_2,
- Log_3_2_1, Log_3_2_2,
- Log_1_3_1, Log_1_3_2] = get_all_terms(a),
+ {ok, a} = disk_log:open([{name,a}, {file, File}, {type, wrap}, {size, {100,3}}]),
+ [Log_2_1, Log_2_2,
+ Log_3_1, Log_3_2,
+ Log_4_1, Log_4_2,
+ Log_1_2_1, Log_1_2_2] = get_all_terms(a),
+ disk_log:log(a, Log_2_2_1),
+ disk_log:log(a, Log_2_2_2),
+ disk_log:log(a, Log_3_2_1),
+ disk_log:log(a, Log_3_2_2),
+ disk_log:log(a, Log_1_3_1),
+ disk_log:log(a, Log_1_3_2),
+ [Log_2_2_1, Log_2_2_2,
+ Log_3_2_1, Log_3_2_2,
+ Log_1_3_1, Log_1_3_2] = get_all_terms(a),
+ disk_log:close(a),
+ {ok, a} = disk_log:open([{name,a}, {file, File}, {type, wrap}, {size, {100,3}}]),
+ [Log_2_2_1, Log_2_2_2,
+ Log_3_2_1, Log_3_2_2,
+ Log_1_3_1, Log_1_3_2] = get_all_terms(a),
disk_log:close(a),
del(File, 5),
- ?line {ok, a} = disk_log:open([{name,a}, {file, File}, {type, wrap}, {size, {100,5}}]),
- ?line disk_log:log(a, Log_1_1),
- ?line disk_log:log(a, Log_1_2),
- ?line disk_log:log(a, Log_2_1),
- ?line disk_log:log(a, Log_2_2),
- ?line disk_log:log(a, Log_3_1),
- ?line disk_log:log(a, Log_3_2),
- ?line disk_log:log(a, Log_4_1),
- ?line disk_log:log(a, Log_4_2),
- ?line disk_log:log(a, Log_5_1),
- ?line disk_log:log(a, Log_5_2),
- ?line disk_log:log(a, Log_1_1),
- ?line disk_log:log(a, Log_1_2),
- ?line disk_log:log(a, Log_2_1),
- ?line disk_log:log(a, Log_2_2),
- ?line disk_log:log(a, Log_3_1),
- ?line disk_log:log(a, Log_3_2),
- ?line disk_log:log(a, Log_4_1),
- ?line disk_log:log(a, Log_4_2),
- ?line disk_log:log(a, Log_5_1),
- ?line disk_log:log(a, Log_5_2),
- ?line disk_log:change_size(a, {100, 3}),
- ?line [Log_1_1, Log_1_2,
- Log_2_1, Log_2_2,
- Log_3_1, Log_3_2,
- Log_4_1, Log_4_2,
- Log_5_1, Log_5_2] = get_all_terms(a),
- ?line disk_log:log(a, Log_1_2_1),
- ?line disk_log:log(a, Log_1_2_2),
- ?line disk_log:log(a, Log_2_2_1),
- ?line disk_log:log(a, Log_2_2_2),
- ?line disk_log:log(a, Log_3_2_1),
- ?line disk_log:log(a, Log_3_2_2),
- ?line disk_log:log(a, Log_1_3_1),
- ?line disk_log:log(a, Log_1_3_2),
- ?line [Log_2_2_1, Log_2_2_2,
- Log_3_2_1, Log_3_2_2,
- Log_1_3_1, Log_1_3_2] = get_all_terms(a),
-
- ?line disk_log:close(a),
- ?line {ok, a} = disk_log:open([{name,a}, {file, File}, {type, wrap}, {size, {100,3}}]),
- ?line [Log_2_2_1, Log_2_2_2,
- Log_3_2_1, Log_3_2_2,
- Log_1_3_1, Log_1_3_2] = get_all_terms(a),
+ {ok, a} = disk_log:open([{name,a}, {file, File}, {type, wrap}, {size, {100,5}}]),
+ disk_log:log(a, Log_1_1),
+ disk_log:log(a, Log_1_2),
+ disk_log:log(a, Log_2_1),
+ disk_log:log(a, Log_2_2),
+ disk_log:log(a, Log_3_1),
+ disk_log:log(a, Log_3_2),
+ disk_log:log(a, Log_4_1),
+ disk_log:log(a, Log_4_2),
+ disk_log:log(a, Log_5_1),
+ disk_log:log(a, Log_5_2),
+ disk_log:log(a, Log_1_1),
+ disk_log:log(a, Log_1_2),
+ disk_log:log(a, Log_2_1),
+ disk_log:log(a, Log_2_2),
+ disk_log:log(a, Log_3_1),
+ disk_log:log(a, Log_3_2),
+ disk_log:log(a, Log_4_1),
+ disk_log:log(a, Log_4_2),
+ disk_log:log(a, Log_5_1),
+ disk_log:log(a, Log_5_2),
+ disk_log:change_size(a, {100, 3}),
+ [Log_1_1, Log_1_2,
+ Log_2_1, Log_2_2,
+ Log_3_1, Log_3_2,
+ Log_4_1, Log_4_2,
+ Log_5_1, Log_5_2] = get_all_terms(a),
+ disk_log:log(a, Log_1_2_1),
+ disk_log:log(a, Log_1_2_2),
+ disk_log:log(a, Log_2_2_1),
+ disk_log:log(a, Log_2_2_2),
+ disk_log:log(a, Log_3_2_1),
+ disk_log:log(a, Log_3_2_2),
+ disk_log:log(a, Log_1_3_1),
+ disk_log:log(a, Log_1_3_2),
+ [Log_2_2_1, Log_2_2_2,
+ Log_3_2_1, Log_3_2_2,
+ Log_1_3_1, Log_1_3_2] = get_all_terms(a),
+
+ disk_log:close(a),
+ {ok, a} = disk_log:open([{name,a}, {file, File}, {type, wrap}, {size, {100,3}}]),
+ [Log_2_2_1, Log_2_2_2,
+ Log_3_2_1, Log_3_2_2,
+ Log_1_3_1, Log_1_3_2] = get_all_terms(a),
disk_log:close(a),
del(File, 5).
-change_size_after(suite) -> [];
-change_size_after(doc) ->
- ["Change size of a wrap log file before we have reached "
- "(on the second round) "
- "to the file index corresponding to the new size"];
+%% Change size of a wrap log file before we have reached (on the
+%% second round) to the file index corresponding to the new size.
change_size_after(Conf) when is_list(Conf) ->
Log_1_1 = "first log first message",
@@ -3758,172 +3665,169 @@ change_size_after(Conf) when is_list(Conf) ->
Dir = ?privdir(Conf),
File = filename:join(Dir, "a.LOG"),
- ?line {ok, a} = disk_log:open([{name,a}, {file, File}, {type, wrap},
- {size, {100,5}}]),
- ?line disk_log:log(a, Log_1_1),
- ?line disk_log:log(a, Log_1_2),
- ?line disk_log:log(a, Log_2_1),
- ?line disk_log:log(a, Log_2_2),
- ?line disk_log:log(a, Log_3_1),
- ?line disk_log:log(a, Log_3_2),
- ?line disk_log:log(a, Log_4_1),
- ?line disk_log:log(a, Log_4_2),
- ?line disk_log:log(a, Log_5_1),
- ?line disk_log:log(a, Log_5_2),
- ?line disk_log:log(a, Log_1_1),
- ?line disk_log:log(a, Log_1_2),
- ?line disk_log:log(a, Log_2_1),
- ?line disk_log:log(a, Log_2_2),
- ?line disk_log:change_size(a, {100, 3}),
- ?line [Log_3_1,Log_3_2,
- Log_4_1, Log_4_2,
- Log_5_1, Log_5_2,
- Log_1_1, Log_1_2,
- Log_2_1, Log_2_2] = get_all_terms(a),
- ?line disk_log:log(a, Log_3_1),
- ?line disk_log:log(a, Log_3_2),
- ?line disk_log:log(a, Log_1_2_1),
- ?line disk_log:log(a, Log_1_2_2),
- ?line [Log_2_1, Log_2_2,
- Log_3_1, Log_3_2,
- Log_1_2_1, Log_1_2_2] = get_all_terms(a),
-
- ?line disk_log:close(a),
- ?line {ok, a} = disk_log:open([{name,a}, {file, File}, {type, wrap},
- {size, {100,3}}]),
- ?line [Log_2_1, Log_2_2,
- Log_3_1, Log_3_2,
- Log_1_2_1, Log_1_2_2] = get_all_terms(a),
+ {ok, a} = disk_log:open([{name,a}, {file, File}, {type, wrap},
+ {size, {100,5}}]),
+ disk_log:log(a, Log_1_1),
+ disk_log:log(a, Log_1_2),
+ disk_log:log(a, Log_2_1),
+ disk_log:log(a, Log_2_2),
+ disk_log:log(a, Log_3_1),
+ disk_log:log(a, Log_3_2),
+ disk_log:log(a, Log_4_1),
+ disk_log:log(a, Log_4_2),
+ disk_log:log(a, Log_5_1),
+ disk_log:log(a, Log_5_2),
+ disk_log:log(a, Log_1_1),
+ disk_log:log(a, Log_1_2),
+ disk_log:log(a, Log_2_1),
+ disk_log:log(a, Log_2_2),
+ disk_log:change_size(a, {100, 3}),
+ [Log_3_1,Log_3_2,
+ Log_4_1, Log_4_2,
+ Log_5_1, Log_5_2,
+ Log_1_1, Log_1_2,
+ Log_2_1, Log_2_2] = get_all_terms(a),
+ disk_log:log(a, Log_3_1),
+ disk_log:log(a, Log_3_2),
+ disk_log:log(a, Log_1_2_1),
+ disk_log:log(a, Log_1_2_2),
+ [Log_2_1, Log_2_2,
+ Log_3_1, Log_3_2,
+ Log_1_2_1, Log_1_2_2] = get_all_terms(a),
+
+ disk_log:close(a),
+ {ok, a} = disk_log:open([{name,a}, {file, File}, {type, wrap},
+ {size, {100,3}}]),
+ [Log_2_1, Log_2_2,
+ Log_3_1, Log_3_2,
+ Log_1_2_1, Log_1_2_2] = get_all_terms(a),
disk_log:close(a),
del(File, 5),
- ?line {ok, a} = disk_log:open([{name,a}, {file, File}, {type, wrap},
- {size, {100,5}}]),
- ?line disk_log:log(a, Log_1_1),
- ?line disk_log:log(a, Log_1_2),
- ?line disk_log:log(a, Log_2_1),
- ?line disk_log:log(a, Log_2_2),
- ?line disk_log:log(a, Log_3_1),
- ?line disk_log:log(a, Log_3_2),
- ?line disk_log:log(a, Log_4_1),
- ?line disk_log:log(a, Log_4_2),
- ?line disk_log:log(a, Log_5_1),
- ?line disk_log:log(a, Log_5_2),
- ?line disk_log:log(a, Log_1_1),
- ?line disk_log:log(a, Log_1_2),
- ?line disk_log:log(a, Log_2_1),
- ?line disk_log:log(a, Log_2_2),
- ?line disk_log:change_size(a, {60, 3}),
- ?line [Log_3_1,Log_3_2,
- Log_4_1, Log_4_2,
- Log_5_1, Log_5_2,
- Log_1_1, Log_1_2,
- Log_2_1, Log_2_2] = get_all_terms(a),
- ?line disk_log:log(a, Log_3_1),
- ?line disk_log:log(a, Log_1_2_1),
- ?line [Log_2_1, Log_2_2,
- Log_3_1,
- Log_1_2_1] = get_all_terms(a),
-
- ?line disk_log:close(a),
- ?line {ok, a} = disk_log:open([{name,a}, {file, File}, {type, wrap},
- {size, {60,3}}]),
- ?line [Log_2_1, Log_2_2,
- Log_3_1,
- Log_1_2_1] = get_all_terms(a),
+ {ok, a} = disk_log:open([{name,a}, {file, File}, {type, wrap},
+ {size, {100,5}}]),
+ disk_log:log(a, Log_1_1),
+ disk_log:log(a, Log_1_2),
+ disk_log:log(a, Log_2_1),
+ disk_log:log(a, Log_2_2),
+ disk_log:log(a, Log_3_1),
+ disk_log:log(a, Log_3_2),
+ disk_log:log(a, Log_4_1),
+ disk_log:log(a, Log_4_2),
+ disk_log:log(a, Log_5_1),
+ disk_log:log(a, Log_5_2),
+ disk_log:log(a, Log_1_1),
+ disk_log:log(a, Log_1_2),
+ disk_log:log(a, Log_2_1),
+ disk_log:log(a, Log_2_2),
+ disk_log:change_size(a, {60, 3}),
+ [Log_3_1,Log_3_2,
+ Log_4_1, Log_4_2,
+ Log_5_1, Log_5_2,
+ Log_1_1, Log_1_2,
+ Log_2_1, Log_2_2] = get_all_terms(a),
+ disk_log:log(a, Log_3_1),
+ disk_log:log(a, Log_1_2_1),
+ [Log_2_1, Log_2_2,
+ Log_3_1,
+ Log_1_2_1] = get_all_terms(a),
+
+ disk_log:close(a),
+ {ok, a} = disk_log:open([{name,a}, {file, File}, {type, wrap},
+ {size, {60,3}}]),
+ [Log_2_1, Log_2_2,
+ Log_3_1,
+ Log_1_2_1] = get_all_terms(a),
disk_log:close(a),
del(File, 5).
-default_size(suite) -> [];
-default_size(doc) -> ["Open an existing wrap log without size option "];
+%% Open an existing wrap log without size option .
default_size(Conf) when is_list(Conf) ->
- ?line Dir = ?privdir(Conf),
- ?line File = filename:join(Dir, "a.LOG"),
- ?line {error, {badarg, size}} = disk_log:open([{name,a}, {file, File},
+ Dir = ?privdir(Conf),
+ File = filename:join(Dir, "a.LOG"),
+ {error, {badarg, size}} = disk_log:open([{name,a}, {file, File},
{type, wrap}]),
- ?line {ok, a} = disk_log:open([{name,a}, {file, File}, {type, wrap},
+ {ok, a} = disk_log:open([{name,a}, {file, File}, {type, wrap},
{size, {100,5}}]),
- ?line disk_log:close(a),
+ disk_log:close(a),
- ?line {ok, a} = disk_log:open([{name,a}, {file, File}, {type, wrap}]),
- ?line {100, 5} = disk_log_1:read_size_file(File),
- ?line ok = disk_log:close(a),
- ?line del(File, 5).
+ {ok, a} = disk_log:open([{name,a}, {file, File}, {type, wrap}]),
+ {100, 5} = disk_log_1:read_size_file(File),
+ ok = disk_log:close(a),
+ del(File, 5).
-change_size2(suite) -> [];
-change_size2(doc) -> ["Testing change_size/2 a bit more..."];
+%% Testing change_size/2 a bit more...
change_size2(Conf) when is_list(Conf) ->
Dir = ?privdir(Conf),
- ?line File = filename:join(Dir, "n.LOG"),
- ?line No = 4,
- ?line del(File, No), % cleanup
+ File = filename:join(Dir, "n.LOG"),
+ No = 4,
+ del(File, No), % cleanup
%% External halt.
- ?line {ok, n} = disk_log:open([{name, n}, {file, File}, {size, 100000},
+ {ok, n} = disk_log:open([{name, n}, {file, File}, {size, 100000},
{format, external}, {type, halt}]),
- ?line B = mk_bytes(60), % 56 actually...
- ?line ok = disk_log:blog_terms(n, [B,list_to_binary(B),B]),
- ?line Error1 = {error, {new_size_too_small,n,168}} =
+ B = mk_bytes(60), % 56 actually...
+ ok = disk_log:blog_terms(n, [B,list_to_binary(B),B]),
+ Error1 = {error, {new_size_too_small,n,168}} =
disk_log:change_size(n, 167),
- ?line "The current size" ++ _ = format_error(Error1),
- ?line ok = disk_log:change_size(n, infinity),
- ?line ok = disk_log:change_size(n, 168),
- ?line ok = disk_log:close(n),
- ?line file:delete(File), % cleanup
+ "The current size" ++ _ = format_error(Error1),
+ ok = disk_log:change_size(n, infinity),
+ ok = disk_log:change_size(n, 168),
+ ok = disk_log:close(n),
+ file:delete(File), % cleanup
%% External wrap.
- ?line {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
+ {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
{size, {100,No}}, {notify, true},
{format, external}]),
- ?line BB = mk_bytes(160),
- ?line ok = disk_log:blog_terms(n, [BB, BB, BB, BB]), % create all files
+ BB = mk_bytes(160),
+ ok = disk_log:blog_terms(n, [BB, BB, BB, BB]), % create all files
%% Used to be one message, but now one per wrapped file.
- ?line rec(3, {disk_log, node(), n, {wrap, 0}}),
- ?line ok = disk_log:blog_terms(n, [BB, BB]),
+ rec(3, {disk_log, node(), n, {wrap, 0}}),
+ ok = disk_log:blog_terms(n, [BB, BB]),
%% Used to be one message, but now one per wrapped file.
- ?line rec(2, {disk_log, node(), n, {wrap, 1}}),
- ?line ok = disk_log:change_size(n, {100, 2}),
- ?line ok = disk_log:change_size(n, {100, 2}),
- ?line {100, 2} = sz(n),
- ?line ok = disk_log:balog_terms(n, [BB, BB]),
- ?line ok = disk_log:balog_terms(n, [BB]),
- ?line ok = disk_log:blog_terms(n, [BB]),
+ rec(2, {disk_log, node(), n, {wrap, 1}}),
+ ok = disk_log:change_size(n, {100, 2}),
+ ok = disk_log:change_size(n, {100, 2}),
+ {100, 2} = sz(n),
+ ok = disk_log:balog_terms(n, [BB, BB]),
+ ok = disk_log:balog_terms(n, [BB]),
+ ok = disk_log:blog_terms(n, [BB]),
%% Used to be one message, but now one per wrapped file.
- ?line rec(4, {disk_log, node(), n, {wrap, 1}}),
- ?line ok = disk_log:change_size(n, {100, 4}),
- ?line ok = disk_log:close(n),
- ?line del(File, No),
+ rec(4, {disk_log, node(), n, {wrap, 1}}),
+ ok = disk_log:change_size(n, {100, 4}),
+ ok = disk_log:close(n),
+ del(File, No),
%% Internal wrap.
- ?line {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
+ {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
{size, {100,No}}, {notify, true},
{format, internal}]),
- ?line ok = disk_log:blog_terms(n, [BB, BB, BB, BB]), % create all files
+ ok = disk_log:blog_terms(n, [BB, BB, BB, BB]), % create all files
%% Used to be one message, but now one per wrapped file.
- ?line rec(3, {disk_log, node(), n, {wrap, 0}}),
- ?line ok = disk_log:blog_terms(n, [BB, BB]),
+ rec(3, {disk_log, node(), n, {wrap, 0}}),
+ ok = disk_log:blog_terms(n, [BB, BB]),
%% Used to be one message, but now one per wrapped file.
- ?line rec(2, {disk_log, node(), n, {wrap, 1}}),
- ?line ok = disk_log:change_size(n, {100, 2}),
- ?line {100, 2} = sz(n),
- ?line ok = disk_log:blog_terms(n, [BB, BB, BB, BB]),
+ rec(2, {disk_log, node(), n, {wrap, 1}}),
+ ok = disk_log:change_size(n, {100, 2}),
+ {100, 2} = sz(n),
+ ok = disk_log:blog_terms(n, [BB, BB, BB, BB]),
%% Used to be one message, but now one per wrapped file.
- ?line rec(4, {disk_log, node(), n, {wrap, 1}}),
- ?line ok = disk_log:close(n),
- ?line del(File, No).
+ rec(4, {disk_log, node(), n, {wrap, 1}}),
+ ok = disk_log:close(n),
+ del(File, No).
-change_size_truncate(suite) -> [];
-change_size_truncate(doc) -> ["OTP-3484: truncating index file"];
+%% OTP-3484: truncating index file.
change_size_truncate(Conf) when is_list(Conf) ->
Dir = ?privdir(Conf),
- ?line File = filename:join(Dir, "bert.LOG"),
- ?line No = 3,
- ?line B = mk_bytes(60),
+ File = filename:join(Dir, "bert.LOG"),
+ No = 3,
+ B = mk_bytes(60),
%% The problem here is truncation of the index file. One cannot easily
%% check that the index file is correctly updated, but print_index_file()
@@ -3933,541 +3837,527 @@ change_size_truncate(Conf) when is_list(Conf) ->
%% Change the size immediately after creating the log, while there
%% are no log files. This used to write stuff a negative offset
%% from the beginning of the file.
- ?line del(File, No+1),
- ?line {ok, bert} = disk_log:open([{name,bert}, {type,wrap}, {file, File},
+ del(File, No+1),
+ {ok, bert} = disk_log:open([{name,bert}, {type,wrap}, {file, File},
{notify, true}, {size,{1000,255}}]),
- ?line ok = disk_log:change_size(bert,{100,No}),
- ?line ok = disk_log:blog(bert, B),
- ?line ok = disk_log:blog(bert, B),
- ?line rec(1, {disk_log, node(), bert, {wrap, 0}}),
- ?line ok = disk_log:blog(bert, B),
- ?line rec(1, {disk_log, node(), bert, {wrap, 0}}),
- ?line 3 = curf(bert),
- ?line ok = disk_log:blog(bert, B),
- ?line rec(1, {disk_log, node(), bert, {wrap, 1}}),
- ?line 1 = curf(bert),
- ?line ok = disk_log:blog(bert, B),
- ?line rec(1, {disk_log, node(), bert, {wrap, 1}}),
- ?line ok = disk_log:blog(bert, B),
- ?line rec(1, {disk_log, node(), bert, {wrap, 1}}),
-
- ?line ok = disk_log:blog(bert, B),
- ?line rec(1, {disk_log, node(), bert, {wrap, 1}}),
- ?line ok = disk_log:blog(bert, B),
- ?line rec(1, {disk_log, node(), bert, {wrap, 1}}),
- ?line ok = disk_log:blog(bert, B),
- ?line rec(1, {disk_log, node(), bert, {wrap, 1}}),
-
- % Three items expected.
- % disk_log_1:print_index_file("bert.LOG.idx"),
- ?line 3 = curf(bert),
- ?line ok = disk_log:change_size(bert,{100,1}),
- ?line ok = disk_log:blog(bert, B),
- ?line rec(1, {disk_log, node(), bert, {wrap, 1}}),
- % Three items expected.
- % disk_log_1:print_index_file("bert.LOG.idx"),
- ?line ok = disk_log:blog(bert, B),
- ?line rec(1, {disk_log, node(), bert, {wrap, 1}}),
- ?line ok = disk_log:blog(bert, B),
- ?line rec(1, {disk_log, node(), bert, {wrap, 1}}),
- % One item expected.
- % disk_log_1:print_index_file("bert.LOG.idx"),
-
- ?line ok = disk_log:blog(bert, B),
- ?line rec(1, {disk_log, node(), bert, {wrap, 1}}),
- ?line ok = disk_log:close(bert),
- ?line del(File, No),
+ ok = disk_log:change_size(bert,{100,No}),
+ ok = disk_log:blog(bert, B),
+ ok = disk_log:blog(bert, B),
+ rec(1, {disk_log, node(), bert, {wrap, 0}}),
+ ok = disk_log:blog(bert, B),
+ rec(1, {disk_log, node(), bert, {wrap, 0}}),
+ 3 = curf(bert),
+ ok = disk_log:blog(bert, B),
+ rec(1, {disk_log, node(), bert, {wrap, 1}}),
+ 1 = curf(bert),
+ ok = disk_log:blog(bert, B),
+ rec(1, {disk_log, node(), bert, {wrap, 1}}),
+ ok = disk_log:blog(bert, B),
+ rec(1, {disk_log, node(), bert, {wrap, 1}}),
+
+ ok = disk_log:blog(bert, B),
+ rec(1, {disk_log, node(), bert, {wrap, 1}}),
+ ok = disk_log:blog(bert, B),
+ rec(1, {disk_log, node(), bert, {wrap, 1}}),
+ ok = disk_log:blog(bert, B),
+ rec(1, {disk_log, node(), bert, {wrap, 1}}),
+
+ %% Three items expected.
+ %% disk_log_1:print_index_file("bert.LOG.idx"),
+ 3 = curf(bert),
+ ok = disk_log:change_size(bert,{100,1}),
+ ok = disk_log:blog(bert, B),
+ rec(1, {disk_log, node(), bert, {wrap, 1}}),
+ %% Three items expected.
+ %% disk_log_1:print_index_file("bert.LOG.idx"),
+ ok = disk_log:blog(bert, B),
+ rec(1, {disk_log, node(), bert, {wrap, 1}}),
+ ok = disk_log:blog(bert, B),
+ rec(1, {disk_log, node(), bert, {wrap, 1}}),
+ %% One item expected.
+ %% disk_log_1:print_index_file("bert.LOG.idx"),
+
+ ok = disk_log:blog(bert, B),
+ rec(1, {disk_log, node(), bert, {wrap, 1}}),
+ ok = disk_log:close(bert),
+ del(File, No),
%% Part 2.
%% Change the size twice, the second time while the the effects of
%% the first changed have not yet been handled. Finally close before
%% the index file has been truncated.
- ?line del(File, No),
- ?line {ok, bert} = disk_log:open([{name,bert}, {type,wrap}, {file, File},
+ del(File, No),
+ {ok, bert} = disk_log:open([{name,bert}, {type,wrap}, {file, File},
{notify, true}, {size,{100,No}}]),
- ?line ok = disk_log:blog(bert, B),
- ?line ok = disk_log:blog(bert, B),
- ?line rec(1, {disk_log, node(), bert, {wrap, 0}}),
- ?line ok = disk_log:blog(bert, B),
- ?line rec(1, {disk_log, node(), bert, {wrap, 0}}),
+ ok = disk_log:blog(bert, B),
+ ok = disk_log:blog(bert, B),
+ rec(1, {disk_log, node(), bert, {wrap, 0}}),
+ ok = disk_log:blog(bert, B),
+ rec(1, {disk_log, node(), bert, {wrap, 0}}),
- ?line 3 = curf(bert),
- ?line ok = disk_log:change_size(bert,{100,No-1}),
+ 3 = curf(bert),
+ ok = disk_log:change_size(bert,{100,No-1}),
- ?line ok = disk_log:blog(bert, B),
- ?line rec(1, {disk_log, node(), bert, {wrap, 1}}),
+ ok = disk_log:blog(bert, B),
+ rec(1, {disk_log, node(), bert, {wrap, 1}}),
- ?line 1 = curf(bert),
- ?line ok = disk_log:change_size(bert,{100,No+1}),
+ 1 = curf(bert),
+ ok = disk_log:change_size(bert,{100,No+1}),
- % Three items expected.
- % disk_log_1:print_index_file("bert.LOG.idx"),
+ %% Three items expected.
+ %% disk_log_1:print_index_file("bert.LOG.idx"),
- ?line ok = disk_log:blog(bert, B),
- ?line rec(1, {disk_log, node(), bert, {wrap, 1}}),
+ ok = disk_log:blog(bert, B),
+ rec(1, {disk_log, node(), bert, {wrap, 1}}),
- % Three items expected.
- % disk_log_1:print_index_file("bert.LOG.idx"),
+ %% Three items expected.
+ %% disk_log_1:print_index_file("bert.LOG.idx"),
- ?line 2 = curf(bert),
- ?line ok = disk_log:change_size(bert,{100,1}),
+ 2 = curf(bert),
+ ok = disk_log:change_size(bert,{100,1}),
- % Three items expected.
- % disk_log_1:print_index_file("bert.LOG.idx"),
+ %% Three items expected.
+ %% disk_log_1:print_index_file("bert.LOG.idx"),
- ?line ok = disk_log:close(bert),
+ ok = disk_log:close(bert),
- % State: .siz is 1, current file is 2, index file size is 3...
+ %% State: .siz is 1, current file is 2, index file size is 3...
- ?line {ok, bert} = disk_log:open([{name,bert}, {file, File},
+ {ok, bert} = disk_log:open([{name,bert}, {file, File},
{type,wrap}, {notify, true}]),
- % Three items expected.
- % disk_log_1:print_index_file("bert.LOG.idx"),
+ %% Three items expected.
+ %% disk_log_1:print_index_file("bert.LOG.idx"),
- ?line 2 = curf(bert),
- ?line ok = disk_log:blog(bert, B),
- ?line rec(1, {disk_log, node(), bert, {wrap, 1}}),
- ?line ok = disk_log:close(bert),
+ 2 = curf(bert),
+ ok = disk_log:blog(bert, B),
+ rec(1, {disk_log, node(), bert, {wrap, 1}}),
+ ok = disk_log:close(bert),
- ?line {ok, bert} = disk_log:open([{name,bert}, {file, File},
+ {ok, bert} = disk_log:open([{name,bert}, {file, File},
{type,wrap}, {notify, true}]),
- % Two items expected.
- % disk_log_1:print_index_file("bert.LOG.idx"),
+ %% Two items expected.
+ %% disk_log_1:print_index_file("bert.LOG.idx"),
- ?line 1 = curf(bert),
- ?line ok = disk_log:blog(bert, B),
+ 1 = curf(bert),
+ ok = disk_log:blog(bert, B),
%% Expect {wrap 0}. Nothing lost now, last wrap notification
%% reported one lost item.
- ?line rec(1, {disk_log, node(), bert, {wrap, 0}}),
+ rec(1, {disk_log, node(), bert, {wrap, 0}}),
- % One item expected.
- % disk_log_1:print_index_file("bert.LOG.idx"),
- ?line ok = disk_log:close(bert),
+ %% One item expected.
+ %% disk_log_1:print_index_file("bert.LOG.idx"),
+ ok = disk_log:close(bert),
- ?line del(File, No),
+ del(File, No),
ok.
-change_attribute(suite) -> [];
-change_attribute(doc) ->
- ["Change notify and head"];
+%% Change notify and head.
change_attribute(Conf) when is_list(Conf) ->
Dir = ?privdir(Conf),
- ?line File = filename:join(Dir, "n.LOG"),
- ?line No = 4,
- ?line del(File, No), % cleanup
- ?line B = mk_bytes(60),
+ File = filename:join(Dir, "n.LOG"),
+ No = 4,
+ del(File, No), % cleanup
+ B = mk_bytes(60),
- ?line Q = qlen(),
+ Q = qlen(),
- % test change_notify
- ?line {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
+ %% test change_notify
+ {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
{size, {100,No}}]),
- ?line {ok, n} = disk_log:open([{name, n}]), % ignored...
- ?line ok = disk_log:log_terms(n, [B,B]),
- ?line {error, {badarg, notify}} = disk_log:change_notify(n, self(), wrong),
- ?line ok = disk_log:change_notify(n, self(), false),
- ?line ok = disk_log:change_notify(n, self(), true),
- ?line Error1 = {error, {not_owner, _}} =
+ {ok, n} = disk_log:open([{name, n}]), % ignored...
+ ok = disk_log:log_terms(n, [B,B]),
+ {error, {badarg, notify}} = disk_log:change_notify(n, self(), wrong),
+ ok = disk_log:change_notify(n, self(), false),
+ ok = disk_log:change_notify(n, self(), true),
+ Error1 = {error, {not_owner, _}} =
disk_log:change_notify(n, none, true),
- ?line "The pid" ++ _ = format_error(Error1),
- ?line 2 = no_written_items(n),
- ?line 0 = users(n),
- ?line Parent = self(),
- ?line Pid = spawn(fun() -> disk_log:close(n), Parent ! {self(),done} end),
- ?line receive {Pid, done} -> ok end,
- ?line 0 = users(n),
- ?line 1 = length(owners(n)),
-
- % test change_header
- ?line {error, {badarg, head}} = disk_log:change_header(n, none),
- ?line {error, {badarg, head}} =
+ "The pid" ++ _ = format_error(Error1),
+ 2 = no_written_items(n),
+ 0 = users(n),
+ Parent = self(),
+ Pid = spawn(fun() -> disk_log:close(n), Parent ! {self(),done} end),
+ receive {Pid, done} -> ok end,
+ 0 = users(n),
+ 1 = length(owners(n)),
+
+ %% test change_header
+ {error, {badarg, head}} = disk_log:change_header(n, none),
+ {error, {badarg, head}} =
disk_log:change_header(n, {head_func, {1,2,3}}),
- ?line ok = disk_log:change_header(n, {head, header}),
- ?line ok = disk_log:log(n, B),
- ?line rec(1, {disk_log, node(), n, {wrap, 0}}),
- ?line 4 = no_written_items(n),
- ?line ok = disk_log:change_header(n, {head, none}),
- ?line ok = disk_log:log(n, B),
- ?line rec(1, {disk_log, node(), n, {wrap, 0}}),
- ?line 5 = no_written_items(n),
- ?line ok = disk_log:change_header(n,
+ ok = disk_log:change_header(n, {head, header}),
+ ok = disk_log:log(n, B),
+ rec(1, {disk_log, node(), n, {wrap, 0}}),
+ 4 = no_written_items(n),
+ ok = disk_log:change_header(n, {head, none}),
+ ok = disk_log:log(n, B),
+ rec(1, {disk_log, node(), n, {wrap, 0}}),
+ 5 = no_written_items(n),
+ ok = disk_log:change_header(n,
{head_func, {?MODULE, head_fun, [{ok,header}]}}),
- ?line ok = disk_log:log(n, B),
- ?line rec(1, {disk_log, node(), n, {wrap, 1}}),
- ?line 7 = no_written_items(n),
- ?line ok = disk_log:close(n),
- ?line {error, no_such_log} = disk_log:close(n),
- ?line del(File, No),
- ?line file:delete(File), % cleanup
- ?line {ok, n} = disk_log:open([{name, n}, {file, File}, {format, external},
+ ok = disk_log:log(n, B),
+ rec(1, {disk_log, node(), n, {wrap, 1}}),
+ 7 = no_written_items(n),
+ ok = disk_log:close(n),
+ {error, no_such_log} = disk_log:close(n),
+ del(File, No),
+ file:delete(File), % cleanup
+ {ok, n} = disk_log:open([{name, n}, {file, File}, {format, external},
{type, halt}]),
- ?line {error, {badarg, head}} = disk_log:change_header(n, {head, header}),
- ?line ok = disk_log:change_header(n, {head, "header"}),
- ?line ok = disk_log:close(n),
- ?line file:delete(File),
+ {error, {badarg, head}} = disk_log:change_header(n, {head, header}),
+ ok = disk_log:change_header(n, {head, "header"}),
+ ok = disk_log:close(n),
+ file:delete(File),
- ?line {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
+ {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
{size, {100,No}}]),
- ?line {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
+ {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
{size, {100,No}}]),
- ?line ok = disk_log:change_notify(n, self(), true),
- ?line ok = disk_log:change_header(n, {head, tjolahopp}),
- ?line {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
+ ok = disk_log:change_notify(n, self(), true),
+ ok = disk_log:change_header(n, {head, tjolahopp}),
+ {ok, n} = disk_log:open([{name, n}, {file, File}, {type, wrap},
{size, {100,No}}, {notify, true}]),
- ?line ok = disk_log:close(n),
- ?line {error, no_such_log} = disk_log:info(n),
- ?line Q = qlen(),
- ?line del(File, No).
+ ok = disk_log:close(n),
+ {error, no_such_log} = disk_log:info(n),
+ Q = qlen(),
+ del(File, No).
-dist_open(suite) -> [];
-dist_open(doc) ->
- ["Open a distributed log"];
+%% Open a distributed log.
dist_open(Conf) when is_list(Conf) ->
- ?line PrivDir = ?privdir(Conf),
- ?line true = is_alive(),
-
- ?line Q = qlen(),
- ?line File = filename:join(PrivDir, "n.LOG"),
- ?line File1 = filename:join(PrivDir, "n1.LOG"),
- ?line No = 3,
- ?line file:delete(File),
- ?line del(File, No), % cleanup
- ?line del(File1, No), % cleanup
- ?line B = mk_bytes(60),
-
- ?line PA = filename:dirname(code:which(?MODULE)),
- ?line {ok, Node} = start_node(disk_log, "-pa " ++ PA),
- ?line wait_for_ready_net(),
+ PrivDir = ?privdir(Conf),
+ true = is_alive(),
+
+ Q = qlen(),
+ File = filename:join(PrivDir, "n.LOG"),
+ File1 = filename:join(PrivDir, "n1.LOG"),
+ No = 3,
+ file:delete(File),
+ del(File, No), % cleanup
+ del(File1, No), % cleanup
+ B = mk_bytes(60),
+
+ PA = filename:dirname(code:which(?MODULE)),
+ {ok, Node} = start_node(disk_log, "-pa " ++ PA),
+ wait_for_ready_net(),
%% open non-distributed on this node:
- ?line {ok,n} = disk_log:open([{name, n}, {file, File}, {type, halt},
+ {ok,n} = disk_log:open([{name, n}, {file, File}, {type, halt},
{distributed, []}]),
- ?line Error1 = {error, {halt_log, n}} = disk_log:inc_wrap_file(n),
- ?line "The halt log" ++ _ = format_error(Error1),
- ?line ok = disk_log:lclose(n),
- ?line file:delete(File),
+ Error1 = {error, {halt_log, n}} = disk_log:inc_wrap_file(n),
+ "The halt log" ++ _ = format_error(Error1),
+ ok = disk_log:lclose(n),
+ file:delete(File),
%% open distributed on this node:
- ?line {[_],[]} = disk_log:open([{name, n}, {file, File}, {type, halt},
+ {[_],[]} = disk_log:open([{name, n}, {file, File}, {type, halt},
{distributed, [node()]}]),
%% the error message is ignored:
- ?line ok = disk_log:inc_wrap_file(n),
- ?line ok = disk_log:close(n),
- ?line file:delete(File),
+ ok = disk_log:inc_wrap_file(n),
+ ok = disk_log:close(n),
+ file:delete(File),
%% open a wrap log on this node, write something on this node
- ?line {[_],[]} = disk_log:open([{name, n}, {file, File},
+ {[_],[]} = disk_log:open([{name, n}, {file, File},
{type, wrap}, {size, {50, No}},
{distributed, [node()]}]),
- ?line ok = disk_log:log(n, B),
- ?line ok = disk_log:close(n),
+ ok = disk_log:log(n, B),
+ ok = disk_log:close(n),
%% open a wrap log on this node and aother node, write something
- ?line {[_],[]} = disk_log:open([{name, n}, {file, File},
+ {[_],[]} = disk_log:open([{name, n}, {file, File},
{type, wrap}, {size, {50, No}},
{distributed, [node()]}]),
- ?line {[_],[]} = disk_log:open([{name, n}, {file, File1},
+ {[_],[]} = disk_log:open([{name, n}, {file, File1},
{type, wrap}, {size, {50, No}},
{distributed, [Node]}]),
- ?line ok = disk_log:log(n, B),
- ?line ok = rpc:call(Node, disk_log, log, [n, B]),
- ?line ok = disk_log:close(n),
- ?line del(File, No),
- ?line del(File1, No),
- ?line file:delete(File),
+ ok = disk_log:log(n, B),
+ ok = rpc:call(Node, disk_log, log, [n, B]),
+ ok = disk_log:close(n),
+ del(File, No),
+ del(File1, No),
+ file:delete(File),
%% open a wrap log on this node and another node, use lclose
- ?line {[_],[]} = disk_log:open([{name, n}, {file, File},
+ {[_],[]} = disk_log:open([{name, n}, {file, File},
{type, wrap}, {size, {50, No}},
{distributed, [node()]}]),
- ?line {[_],[]} = disk_log:open([{name, n}, {file, File},
+ {[_],[]} = disk_log:open([{name, n}, {file, File},
{type, wrap}, {size, {50, No}},
{distributed, [node()]},
{linkto,none}]),
- ?line {[_],[]} = disk_log:open([{name, n}, {file, File1},
+ {[_],[]} = disk_log:open([{name, n}, {file, File1},
{type, wrap}, {size, {50, No}},
{distributed, [Node]}]),
- ?line [_, _] = distributed(n),
- ?line ok = disk_log:lclose(n, Node),
- ?line [_] = distributed(n),
- ?line ok = disk_log:lclose(n),
- ?line ok = disk_log:lclose(n),
- ?line {error, no_such_log} = disk_log:info(n),
- ?line del(File, No),
- ?line del(File1, No),
- ?line file:delete(File),
-
- % open an invalid log file, and see how error are handled
- ?line First = "n.LOG.1",
- ?line make_file(PrivDir, First, 8),
-
- ?line {[], [_,_]} = disk_log:open([{name, n}, {file, File},
+ [_, _] = distributed(n),
+ ok = disk_log:lclose(n, Node),
+ [_] = distributed(n),
+ ok = disk_log:lclose(n),
+ ok = disk_log:lclose(n),
+ {error, no_such_log} = disk_log:info(n),
+ del(File, No),
+ del(File1, No),
+ file:delete(File),
+
+ %% open an invalid log file, and see how error are handled
+ First = "n.LOG.1",
+ make_file(PrivDir, First, 8),
+
+ {[], [_,_]} = disk_log:open([{name, n}, {file, File},
{type, wrap}, {size, {50, No}},
{distributed, [Node,node()]}]),
- ?line del(File, No),
- ?line file:delete(File),
+ del(File, No),
+ file:delete(File),
- % open a wrap on one other node (not on this node)
- ?line {[_],[]} = disk_log:open([{name, n}, {file, File},
+ %% open a wrap on one other node (not on this node)
+ {[_],[]} = disk_log:open([{name, n}, {file, File},
{type, wrap}, {size, {50, No}},
{distributed, [Node]}]),
- ?line ok = rpc:call(Node, disk_log, log, [n, B]),
- ?line {error, no_such_log} = disk_log:lclose(n),
- ?line ok = disk_log:close(n),
+ ok = rpc:call(Node, disk_log, log, [n, B]),
+ {error, no_such_log} = disk_log:lclose(n),
+ ok = disk_log:close(n),
- ?line Q = qlen(),
+ Q = qlen(),
- ?line {error, no_such_log} = disk_log:info(n),
- ?line del(File, No),
- ?line file:delete(File),
- ?line stop_node(Node),
+ {error, no_such_log} = disk_log:info(n),
+ del(File, No),
+ file:delete(File),
+ stop_node(Node),
ok.
-dist_error_open(suite) -> [];
-dist_error_open(doc) ->
- ["Open a log distributed and not distributed"];
+%% Open a log distributed and not distributed.
dist_error_open(Conf) when is_list(Conf) ->
- ?line PrivDir = ?privdir(Conf),
- ?line true = is_alive(),
-
- ?line Q = qlen(),
- ?line File = filename:join(PrivDir, "bert.LOG"),
- ?line File1 = filename:join(PrivDir, "bert1.LOG"),
- ?line No = 3,
- ?line file:delete(File),
- ?line del(File, No), % cleanup
- ?line del(File1, No), % cleanup
-
- ?line PA = filename:dirname(code:which(?MODULE)),
- ?line {ok, Node} = start_node(disk_log, "-pa " ++ PA),
- ?line wait_for_ready_net(),
-
- % open non-distributed on this node:
- ?line {ok,n} = disk_log:open([{name, n}, {file, File},
+ PrivDir = ?privdir(Conf),
+ true = is_alive(),
+
+ Q = qlen(),
+ File = filename:join(PrivDir, "bert.LOG"),
+ File1 = filename:join(PrivDir, "bert1.LOG"),
+ No = 3,
+ file:delete(File),
+ del(File, No), % cleanup
+ del(File1, No), % cleanup
+
+ PA = filename:dirname(code:which(?MODULE)),
+ {ok, Node} = start_node(disk_log, "-pa " ++ PA),
+ wait_for_ready_net(),
+
+ %% open non-distributed on this node:
+ {ok,n} = disk_log:open([{name, n}, {file, File},
{type, wrap}, {size, {50, No}}]),
- % trying to open distributed on this node (error):
- ?line {[],[Error1={ENode,{error,{node_already_open,n}}}]} =
+ %% trying to open distributed on this node (error):
+ {[],[Error1={ENode,{error,{node_already_open,n}}}]} =
disk_log:open([{name, n}, {file, File},
{type, wrap}, {size, {50, No}},
{distributed, [node()]}]),
- ?line true =
+ true =
lists:prefix(lists:flatten(io_lib:format("~p: The distribution",
[ENode])),
format_error(Error1)),
- ?line ok = disk_log:lclose(n),
+ ok = disk_log:lclose(n),
- % open distributed on this node:
- ?line {[_],[]} = disk_log:open([{name, n}, {file, File},
+ %% open distributed on this node:
+ {[_],[]} = disk_log:open([{name, n}, {file, File},
{type, wrap}, {size, {50, No}},
{distributed, [node()]}]),
- % trying to open non-distributed on this node (error):
- ?line {_,{node_already_open,n}} =
+ %% trying to open non-distributed on this node (error):
+ {_,{node_already_open,n}} =
disk_log:open([{name, n}, {file, File},
{type, wrap}, {size, {50, No}}]),
- ?line ok = disk_log:close(n),
- ?line Q = qlen(),
+ ok = disk_log:close(n),
+ Q = qlen(),
- ?line del(File, No),
- ?line del(File1, No),
- ?line file:delete(File),
- ?line stop_node(Node),
+ del(File, No),
+ del(File1, No),
+ file:delete(File),
+ stop_node(Node),
ok.
-dist_notify(suite) -> [];
-dist_notify(doc) ->
- ["Notification from other node"];
+%% Notification from other node.
dist_notify(Conf) when is_list(Conf) ->
- ?line PrivDir = ?privdir(Conf),
- ?line true = is_alive(),
+ PrivDir = ?privdir(Conf),
+ true = is_alive(),
- ?line File = filename:join(PrivDir, "bert.LOG"),
- ?line File1 = filename:join(PrivDir, "bert1.LOG"),
- ?line No = 3,
- ?line B = mk_bytes(60),
- ?line file:delete(File),
- ?line file:delete(File1),
- ?line del(File, No), % cleanup
- ?line del(File1, No),
-
- ?line PA = filename:dirname(code:which(?MODULE)),
- ?line {ok, Node} = start_node(disk_log, "-pa " ++ PA),
- ?line wait_for_ready_net(),
-
- % opening distributed on this node:
- ?line {[_],[]} = disk_log:open([{name, n}, {file, File}, {notify, false},
+ File = filename:join(PrivDir, "bert.LOG"),
+ File1 = filename:join(PrivDir, "bert1.LOG"),
+ No = 3,
+ B = mk_bytes(60),
+ file:delete(File),
+ file:delete(File1),
+ del(File, No), % cleanup
+ del(File1, No),
+
+ PA = filename:dirname(code:which(?MODULE)),
+ {ok, Node} = start_node(disk_log, "-pa " ++ PA),
+ wait_for_ready_net(),
+
+ %% opening distributed on this node:
+ {[_],[]} = disk_log:open([{name, n}, {file, File}, {notify, false},
{type, wrap}, {size, {50, No}},
{distributed, [node()]}]),
- % opening distributed on other node:
- ?line {[_],[]} = disk_log:open([{name, n}, {file, File1},
+ %% opening distributed on other node:
+ {[_],[]} = disk_log:open([{name, n}, {file, File1},
{notify, true}, {linkto, self()},
{type, wrap}, {size, {50, No}},
{distributed, [Node]}]),
- ?line disk_log:alog(n, B),
- ?line disk_log:alog(n, B),
- ?line ok = disk_log:sync(n),
- ?line rec(1, {disk_log, Node, n, {wrap, 0}}),
- ?line ok = disk_log:close(n),
-
- ?line del(File, No),
- ?line del(File1, No),
- ?line file:delete(File),
- ?line stop_node(Node),
+ disk_log:alog(n, B),
+ disk_log:alog(n, B),
+ ok = disk_log:sync(n),
+ rec(1, {disk_log, Node, n, {wrap, 0}}),
+ ok = disk_log:close(n),
+
+ del(File, No),
+ del(File1, No),
+ file:delete(File),
+ stop_node(Node),
ok.
-dist_terminate(suite) -> [];
-dist_terminate(doc) ->
- ["Terminating nodes with distributed logs"];
+%% Terminating nodes with distributed logs.
dist_terminate(Conf) when is_list(Conf) ->
- ?line Dir = ?privdir(Conf),
- ?line true = is_alive(),
+ Dir = ?privdir(Conf),
+ true = is_alive(),
- ?line File = filename:join(Dir, "n.LOG"),
- ?line File1 = filename:join(Dir, "n1.LOG"),
+ File = filename:join(Dir, "n.LOG"),
+ File1 = filename:join(Dir, "n1.LOG"),
No = 1,
del(File, No), % cleanup
del(File1, No), % cleanup
- ?line PA = filename:dirname(code:which(?MODULE)),
- ?line {ok, Node} = start_node(disk_log, "-pa " ++ PA),
- ?line wait_for_ready_net(),
+ PA = filename:dirname(code:which(?MODULE)),
+ {ok, Node} = start_node(disk_log, "-pa " ++ PA),
+ wait_for_ready_net(),
%% Distributed versions of two of the situations in close_block(/1.
%% One of two owners terminates.
- ?line Pid1 = spawn_link(?MODULE, lserv, [n]),
- ?line Pid2 = spawn_link(?MODULE, lserv, [n]),
- ?line {[{_, {ok, n}}], []} = sync_do(Pid1, {dist_open, File, node()}),
- ?line {[{_, {ok, n}}], []} = sync_do(Pid2, {dist_open, File1, Node}),
- ?line [_] = sync_do(Pid1, owners),
- ?line [_] = sync_do(Pid2, owners),
- ?line 0 = sync_do(Pid1, users),
- ?line 0 = sync_do(Pid2, users),
- ?line sync_do(Pid1, terminate),
- ?line [_] = sync_do(Pid2, owners),
- ?line 0 = sync_do(Pid2, users),
- ?line sync_do(Pid2, terminate),
- ?line {error, no_such_log} = disk_log:info(n),
+ Pid1 = spawn_link(?MODULE, lserv, [n]),
+ Pid2 = spawn_link(?MODULE, lserv, [n]),
+ {[{_, {ok, n}}], []} = sync_do(Pid1, {dist_open, File, node()}),
+ {[{_, {ok, n}}], []} = sync_do(Pid2, {dist_open, File1, Node}),
+ [_] = sync_do(Pid1, owners),
+ [_] = sync_do(Pid2, owners),
+ 0 = sync_do(Pid1, users),
+ 0 = sync_do(Pid2, users),
+ sync_do(Pid1, terminate),
+ [_] = sync_do(Pid2, owners),
+ 0 = sync_do(Pid2, users),
+ sync_do(Pid2, terminate),
+ {error, no_such_log} = disk_log:info(n),
%% Users terminate (no link...).
- ?line Pid3 = spawn_link(?MODULE, lserv, [n]),
- ?line Pid4 = spawn_link(?MODULE, lserv, [n]),
- ?line {[{_, {ok, n}}], []} =
+ Pid3 = spawn_link(?MODULE, lserv, [n]),
+ Pid4 = spawn_link(?MODULE, lserv, [n]),
+ {[{_, {ok, n}}], []} =
sync_do(Pid3, {dist_open, File, none, node()}),
- ?line {[{_, {ok, n}}], []} =
+ {[{_, {ok, n}}], []} =
sync_do(Pid4, {dist_open, File1, none, Node}),
- ?line [] = sync_do(Pid3, owners),
- ?line [] = sync_do(Pid4, owners),
- ?line 1 = sync_do(Pid3, users),
- ?line 1 = sync_do(Pid4, users),
- ?line sync_do(Pid3, terminate),
- ?line [] = sync_do(Pid4, owners),
- ?line 1 = sync_do(Pid4, users),
- ?line sync_do(Pid4, terminate),
- ?line ok = disk_log:close(n), % closing all nodes
- ?line {error, no_such_log} = disk_log:info(n),
+ [] = sync_do(Pid3, owners),
+ [] = sync_do(Pid4, owners),
+ 1 = sync_do(Pid3, users),
+ 1 = sync_do(Pid4, users),
+ sync_do(Pid3, terminate),
+ [] = sync_do(Pid4, owners),
+ 1 = sync_do(Pid4, users),
+ sync_do(Pid4, terminate),
+ ok = disk_log:close(n), % closing all nodes
+ {error, no_such_log} = disk_log:info(n),
- ?line del(File, No),
- ?line del(File1, No),
- ?line stop_node(Node),
+ del(File, No),
+ del(File1, No),
+ stop_node(Node),
ok.
-dist_accessible(suite) -> [];
-dist_accessible(doc) ->
- ["Accessible logs on nodes"];
+%% Accessible logs on nodes.
dist_accessible(Conf) when is_list(Conf) ->
- ?line PrivDir = ?privdir(Conf),
-
- ?line true = is_alive(),
-
- ?line F1 = filename:join(PrivDir, "a.LOG"),
- ?line file:delete(F1),
- ?line F2 = filename:join(PrivDir, "b.LOG"),
- ?line file:delete(F2),
- ?line F3 = filename:join(PrivDir, "c.LOG"),
- ?line file:delete(F3),
- ?line F4 = filename:join(PrivDir, "d.LOG"),
- ?line file:delete(F1),
- ?line F5 = filename:join(PrivDir, "e.LOG"),
- ?line file:delete(F2),
- ?line F6 = filename:join(PrivDir, "f.LOG"),
- ?line file:delete(F3),
-
- ?line {[],[]} = disk_log:accessible_logs(),
- ?line {ok, a} = disk_log:open([{name, a}, {type, halt}, {file, F1}]),
- ?line {[a],[]} = disk_log:accessible_logs(),
- ?line {ok, b} = disk_log:open([{name, b}, {type, halt}, {file, F2}]),
- ?line {[a,b],[]} = disk_log:accessible_logs(),
- ?line {ok, c} = disk_log:open([{name, c}, {type, halt}, {file, F3}]),
- ?line {[a,b,c],[]} = disk_log:accessible_logs(),
-
- ?line PA = filename:dirname(code:which(?MODULE)),
- ?line {ok, Node} = start_node(disk_log, "-pa " ++ PA),
- ?line wait_for_ready_net(),
-
- ?line {[_],[]} = disk_log:open([{name, a}, {file, F4}, {type, halt},
+ PrivDir = ?privdir(Conf),
+
+ true = is_alive(),
+
+ F1 = filename:join(PrivDir, "a.LOG"),
+ file:delete(F1),
+ F2 = filename:join(PrivDir, "b.LOG"),
+ file:delete(F2),
+ F3 = filename:join(PrivDir, "c.LOG"),
+ file:delete(F3),
+ F4 = filename:join(PrivDir, "d.LOG"),
+ file:delete(F1),
+ F5 = filename:join(PrivDir, "e.LOG"),
+ file:delete(F2),
+ F6 = filename:join(PrivDir, "f.LOG"),
+ file:delete(F3),
+
+ {[],[]} = disk_log:accessible_logs(),
+ {ok, a} = disk_log:open([{name, a}, {type, halt}, {file, F1}]),
+ {[a],[]} = disk_log:accessible_logs(),
+ {ok, b} = disk_log:open([{name, b}, {type, halt}, {file, F2}]),
+ {[a,b],[]} = disk_log:accessible_logs(),
+ {ok, c} = disk_log:open([{name, c}, {type, halt}, {file, F3}]),
+ {[a,b,c],[]} = disk_log:accessible_logs(),
+
+ PA = filename:dirname(code:which(?MODULE)),
+ {ok, Node} = start_node(disk_log, "-pa " ++ PA),
+ wait_for_ready_net(),
+
+ {[_],[]} = disk_log:open([{name, a}, {file, F4}, {type, halt},
{distributed, [Node]}]),
- ?line {[a,b,c],[]} = disk_log:accessible_logs(),
- ?line {[],[a]} = rpc:call(Node, disk_log, accessible_logs, []),
- ?line {[_],[]} = disk_log:open([{name, b}, {file, F5}, {type, halt},
+ {[a,b,c],[]} = disk_log:accessible_logs(),
+ {[],[a]} = rpc:call(Node, disk_log, accessible_logs, []),
+ {[_],[]} = disk_log:open([{name, b}, {file, F5}, {type, halt},
{distributed, [Node]}]),
- ?line {[],[a,b]} = rpc:call(Node, disk_log, accessible_logs, []),
- ?line {[_],[]} = disk_log:open([{name, c}, {file, F6}, {type, halt},
+ {[],[a,b]} = rpc:call(Node, disk_log, accessible_logs, []),
+ {[_],[]} = disk_log:open([{name, c}, {file, F6}, {type, halt},
{distributed, [Node]}]),
- ?line {[],[a,b,c]} = rpc:call(Node, disk_log, accessible_logs, []),
- ?line {[a,b,c],[]} = disk_log:accessible_logs(),
- ?line ok = disk_log:close(a),
- ?line {[b,c],[a]} = disk_log:accessible_logs(),
- ?line ok = disk_log:close(b),
- ?line {[c],[a,b]} = disk_log:accessible_logs(),
- ?line ok = disk_log:close(b),
- ?line {[c],[a]} = disk_log:accessible_logs(),
- ?line {[],[a,c]} = rpc:call(Node, disk_log, accessible_logs, []),
- ?line ok = disk_log:close(c),
- ?line {[],[a,c]} = disk_log:accessible_logs(),
- ?line ok = disk_log:close(c),
- ?line {[],[a]} = disk_log:accessible_logs(),
- ?line {[],[a]} = rpc:call(Node, disk_log, accessible_logs, []),
- ?line ok = disk_log:close(a),
- ?line {[],[]} = disk_log:accessible_logs(),
- ?line {[],[]} = rpc:call(Node, disk_log, accessible_logs, []),
-
- ?line file:delete(F1),
- ?line file:delete(F2),
- ?line file:delete(F3),
- ?line file:delete(F4),
- ?line file:delete(F5),
- ?line file:delete(F6),
-
- ?line stop_node(Node),
+ {[],[a,b,c]} = rpc:call(Node, disk_log, accessible_logs, []),
+ {[a,b,c],[]} = disk_log:accessible_logs(),
+ ok = disk_log:close(a),
+ {[b,c],[a]} = disk_log:accessible_logs(),
+ ok = disk_log:close(b),
+ {[c],[a,b]} = disk_log:accessible_logs(),
+ ok = disk_log:close(b),
+ {[c],[a]} = disk_log:accessible_logs(),
+ {[],[a,c]} = rpc:call(Node, disk_log, accessible_logs, []),
+ ok = disk_log:close(c),
+ {[],[a,c]} = disk_log:accessible_logs(),
+ ok = disk_log:close(c),
+ {[],[a]} = disk_log:accessible_logs(),
+ {[],[a]} = rpc:call(Node, disk_log, accessible_logs, []),
+ ok = disk_log:close(a),
+ {[],[]} = disk_log:accessible_logs(),
+ {[],[]} = rpc:call(Node, disk_log, accessible_logs, []),
+
+ file:delete(F1),
+ file:delete(F2),
+ file:delete(F3),
+ file:delete(F4),
+ file:delete(F5),
+ file:delete(F6),
+
+ stop_node(Node),
ok.
-dist_deadlock(suite) -> [];
-dist_deadlock(doc) ->
- ["OTP-4405. Deadlock between two nodes could happen."];
+%% OTP-4405. Deadlock between two nodes could happen.
dist_deadlock(Conf) when is_list(Conf) ->
- ?line PrivDir = ?privdir(Conf),
+ PrivDir = ?privdir(Conf),
- ?line true = is_alive(),
+ true = is_alive(),
- ?line F1 = filename:join(PrivDir, "a.LOG"),
- ?line file:delete(F1),
- ?line F2 = filename:join(PrivDir, "b.LOG"),
- ?line file:delete(F2),
+ F1 = filename:join(PrivDir, "a.LOG"),
+ file:delete(F1),
+ F2 = filename:join(PrivDir, "b.LOG"),
+ file:delete(F2),
- ?line PA = filename:dirname(code:which(?MODULE)),
- ?line {ok, Node1} = start_node(disk_log_node1, "-pa " ++ PA),
- ?line {ok, Node2} = start_node(disk_log_node2, "-pa " ++ PA),
- ?line wait_for_ready_net(),
+ PA = filename:dirname(code:which(?MODULE)),
+ {ok, Node1} = start_node(disk_log_node1, "-pa " ++ PA),
+ {ok, Node2} = start_node(disk_log_node2, "-pa " ++ PA),
+ wait_for_ready_net(),
Self = self(),
Fun1 = fun() -> dist_dl(Node2, a, F1, Self) end,
@@ -4477,11 +4367,11 @@ dist_deadlock(Conf) when is_list(Conf) ->
receive {P1, a} -> ok end,
receive {P2, b} -> ok end,
- ?line stop_node(Node1),
- ?line stop_node(Node2),
+ stop_node(Node1),
+ stop_node(Node2),
- ?line file:delete(F1),
- ?line file:delete(F2),
+ file:delete(F1),
+ file:delete(F2),
ok.
dist_dl(Node, Name, File, Pid) ->
@@ -4492,12 +4382,10 @@ dist_dl(Node, Name, File, Pid) ->
Pid ! {self(), Name},
ok.
-dist_open2(suite) -> [];
-dist_open2(doc) ->
- ["OTP-4480. Opening several logs simultaneously."];
+%% OTP-4480. Opening several logs simultaneously.
dist_open2(Conf) when is_list(Conf) ->
- ?line true = is_alive(),
- ?line {ok, _Pg2} = pg2:start(),
+ true = is_alive(),
+ {ok, _Pg2} = pg2:start(),
dist_open2_1(Conf, 0),
dist_open2_1(Conf, 100),
@@ -4513,9 +4401,9 @@ dist_open2(Conf) when is_list(Conf) ->
%% to open the log. The second one succeeds, and the third one is
%% attached.
P0 = pps(),
- ?line File0 = "n.LOG",
- ?line File = filename:join(PrivDir, File0),
- ?line make_file(PrivDir, File0, 8),
+ File0 = "n.LOG",
+ File = filename:join(PrivDir, File0),
+ make_file(PrivDir, File0, 8),
Parent = self(),
F1 = fun() -> R = disk_log:open([{name, Log}, {file, File},
@@ -4529,18 +4417,18 @@ dist_open2(Conf) when is_list(Conf) ->
Parent ! {self(), R},
timer:sleep(300)
end,
- ?line Pid1 = spawn(F1),
+ Pid1 = spawn(F1),
timer:sleep(10),
- ?line Pid2 = spawn(F2),
- ?line Pid3 = spawn(F2),
+ Pid2 = spawn(F2),
+ Pid3 = spawn(F2),
- ?line receive {Pid1,R1} -> {[],[_]} = R1 end,
- ?line receive {Pid2,R2} -> {[_],[]} = R2 end,
- ?line receive {Pid3,R3} -> {[_],[]} = R3 end,
+ receive {Pid1,R1} -> {[],[_]} = R1 end,
+ receive {Pid2,R2} -> {[_],[]} = R2 end,
+ receive {Pid3,R3} -> {[_],[]} = R3 end,
timer:sleep(500),
- ?line file:delete(File),
- ?line true = (P0 == pps()),
+ file:delete(File),
+ true = (P0 == pps()),
%% This time the first process has a naughty head_func. This test
%% does not add very much. Perhaps it should be removed. However,
@@ -4561,15 +4449,15 @@ dist_open2(Conf) when is_list(Conf) ->
{type,halt}]),
Parent ! {self(), R}
end,
- ?line Pid4 = spawn(F3),
+ Pid4 = spawn(F3),
timer:sleep(10),
- ?line Pid5 = spawn(F4),
- ?line Pid6 = spawn(F4),
+ Pid5 = spawn(F4),
+ Pid6 = spawn(F4),
%% The timing is crucial here.
- ?line R = case receive {Pid4,R4} -> R4 end of
+ R = case receive {Pid4,R4} -> R4 end of
{error, no_such_log} ->
- ?line R5 = receive {Pid5, R5a} -> R5a end,
- ?line R6 = receive {Pid6, R6a} -> R6a end,
+ R5 = receive {Pid5, R5a} -> R5a end,
+ R6 = receive {Pid6, R6a} -> R6a end,
case {R5, R6} of
{{repaired, _, _, _}, {ok, Log}} -> ok;
{{ok, Log}, {repaired, _, _, _}} -> ok;
@@ -4577,16 +4465,16 @@ dist_open2(Conf) when is_list(Conf) ->
end,
ok;
{ok, Log} -> % uninteresting case
- ?line receive {Pid5,_R5} -> ok end,
- ?line receive {Pid6,_R6} -> ok end,
+ receive {Pid5,_R5} -> ok end,
+ receive {Pid6,_R6} -> ok end,
{comment,
"Timing dependent test did not check anything."}
end,
timer:sleep(100),
- ?line {error, no_such_log} = disk_log:close(Log),
+ {error, no_such_log} = disk_log:close(Log),
file:delete(File),
- ?line true = (P0 == pps()),
+ true = (P0 == pps()),
No = 2,
Log2 = n2,
@@ -4598,7 +4486,7 @@ dist_open2(Conf) when is_list(Conf) ->
%% processes should be able to attach to other log without having to
%% wait.
- ?line {ok,Log} =
+ {ok,Log} =
disk_log:open([{name,Log},{file,File},{type,wrap},{size,{100,No}}]),
Pid = spawn(fun() ->
receive {HeadPid, start} -> ok end,
@@ -4607,15 +4495,15 @@ dist_open2(Conf) when is_list(Conf) ->
HeadPid ! {self(), done}
end),
HeadFunc = {?MODULE, slow_header, [Pid]},
- ?line ok = disk_log:change_header(Log, {head_func, HeadFunc}),
- ?line ok = disk_log:inc_wrap_file(Log), % header is written
+ ok = disk_log:change_header(Log, {head_func, HeadFunc}),
+ ok = disk_log:inc_wrap_file(Log), % header is written
timer:sleep(100),
- ?line ok = disk_log:close(Log),
+ ok = disk_log:close(Log),
file:delete(File2),
del(File, No),
- ?line true = (P0 == pps()),
+ true = (P0 == pps()),
R.
@@ -4625,13 +4513,13 @@ dist_open2_1(Conf, Delay) ->
Log = n,
A0 = [{name,Log},{file,File},{type,halt}],
- ?line create_opened_log(File, A0),
+ create_opened_log(File, A0),
P0 = pps(),
Log2 = log2,
File2 = "log2.LOG",
- ?line file:delete(File2),
- ?line {ok,Log2} = disk_log:open([{name,Log2},{file,File2},{type,halt}]),
+ file:delete(File2),
+ {ok,Log2} = disk_log:open([{name,Log2},{file,File2},{type,halt}]),
Parent = self(),
F = fun() ->
@@ -4639,28 +4527,28 @@ dist_open2_1(Conf, Delay) ->
timer:sleep(Delay),
Parent ! {self(), R}
end,
- ?line Pid1 = spawn(F),
+ Pid1 = spawn(F),
timer:sleep(10),
- ?line Pid2 = spawn(F),
- ?line Pid3 = spawn(F),
- ?line {error, no_such_log} = disk_log:log(Log, term), % is repairing now
- ?line 0 = qlen(),
+ Pid2 = spawn(F),
+ Pid3 = spawn(F),
+ {error, no_such_log} = disk_log:log(Log, term), % is repairing now
+ 0 = qlen(),
%% The file is already open, so this will not take long.
- ?line {ok,Log2} = disk_log:open([{name,Log2},{file,File2},{type,halt}]),
- ?line 0 = qlen(), % still repairing
- ?line ok = disk_log:close(Log2),
- ?line {error, no_such_log} = disk_log:close(Log2),
- ?line file:delete(File2),
-
- ?line receive {Pid1,R1} -> {repaired,_,_,_} = R1 end,
- ?line receive {Pid2,R2} -> {ok,_} = R2 end,
- ?line receive {Pid3,R3} -> {ok,_} = R3 end,
+ {ok,Log2} = disk_log:open([{name,Log2},{file,File2},{type,halt}]),
+ 0 = qlen(), % still repairing
+ ok = disk_log:close(Log2),
+ {error, no_such_log} = disk_log:close(Log2),
+ file:delete(File2),
+
+ receive {Pid1,R1} -> {repaired,_,_,_} = R1 end,
+ receive {Pid2,R2} -> {ok,_} = R2 end,
+ receive {Pid3,R3} -> {ok,_} = R3 end,
timer:sleep(500),
- ?line {error, no_such_log} = disk_log:info(Log),
+ {error, no_such_log} = disk_log:info(Log),
file:delete(File),
- ?line true = (P0 == pps()),
+ true = (P0 == pps()),
ok.
@@ -4669,18 +4557,18 @@ dist_open2_2(Conf, Delay) ->
File = filename:join(Dir, "n.LOG"),
Log = n,
- ?line PA = filename:dirname(code:which(?MODULE)),
- ?line {ok, Node1} = start_node(disk_log_node2, "-pa " ++ PA),
- ?line wait_for_ready_net(),
+ PA = filename:dirname(code:which(?MODULE)),
+ {ok, Node1} = start_node(disk_log_node2, "-pa " ++ PA),
+ wait_for_ready_net(),
P0 = pps(),
A0 = [{name,Log},{file,File},{type,halt}],
- ?line create_opened_log(File, A0),
+ create_opened_log(File, A0),
Log2 = log2,
File2 = "log2.LOG",
- ?line file:delete(File2),
- ?line {[{Node1,{ok,Log2}}],[]} =
+ file:delete(File2),
+ {[{Node1,{ok,Log2}}],[]} =
disk_log:open([{name,Log2},{file,File2},{type,halt},
{distributed,[Node1]}]),
@@ -4693,32 +4581,32 @@ dist_open2_2(Conf, Delay) ->
Parent ! {self(), R}
end,
%% And {priority, ...} probably has no effect either.
- ?line Pid1 = spawn_opt(F, [{priority, low}]),
- % timer:sleep(1), % no guarantee that Pid1 will return {repaired, ...}
- ?line Pid2 = spawn_opt(F, [{priority, low}]),
- ?line {error, no_such_log} =
+ Pid1 = spawn_opt(F, [{priority, low}]),
+ %% timer:sleep(1), % no guarantee that Pid1 will return {repaired, ...}
+ Pid2 = spawn_opt(F, [{priority, low}]),
+ {error, no_such_log} =
disk_log:log(Log, term), % maybe repairing now
- ?line 0 = qlen(),
+ 0 = qlen(),
%% The file is already open, so this will not take long.
- ?line {[{Node1,{ok,Log2}}],[]} =
+ {[{Node1,{ok,Log2}}],[]} =
disk_log:open([{name,Log2},{file,File2},{type,halt},
{distributed,[Node1]}]),
- ?line 0 = qlen(), % probably still repairing
- ?line ok = disk_log:close(Log2),
- ?line file:delete(File2),
+ 0 = qlen(), % probably still repairing
+ ok = disk_log:close(Log2),
+ file:delete(File2),
- ?line receive {Pid1,R1} -> R1 end,
- ?line receive {Pid2,R2} -> R2 end,
- ?line case {R1, R2} of
+ receive {Pid1,R1} -> R1 end,
+ receive {Pid2,R2} -> R2 end,
+ case {R1, R2} of
{{[{Node1,{repaired,_,_,_}}],[]},
{[{Node1,{ok,Log}}],[]}} -> ok;
{{[{Node1,{ok,Log}}],[]},
{[{Node1,{repaired,_,_,_}}],[]}} -> ok
end,
- ?line true = (P0 == pps()),
- ?line stop_node(Node1),
+ true = (P0 == pps()),
+ stop_node(Node1),
file:delete(File),
ok.
@@ -4751,38 +4639,35 @@ log_terms(Log, N) ->
ok = disk_log:log(Log, {term, N}),
log_terms(Log, N-1).
-other_groups(suite) -> [];
-other_groups(doc) ->
- ["OTP-5810. Cope with pg2 groups that are not disk logs."];
+%% OTP-5810. Cope with pg2 groups that are not disk logs.
other_groups(Conf) when is_list(Conf) ->
- ?line true = is_alive(),
- ?line PrivDir = ?privdir(Conf),
+ true = is_alive(),
+ PrivDir = ?privdir(Conf),
- ?line File = filename:join(PrivDir, "n.LOG"),
- ?line file:delete(File),
+ File = filename:join(PrivDir, "n.LOG"),
+ file:delete(File),
- ?line {[],[]} = disk_log:accessible_logs(),
- ?line {[_],[]} = disk_log:open([{name, n}, {file, File}, {type, halt},
+ {[],[]} = disk_log:accessible_logs(),
+ {[_],[]} = disk_log:open([{name, n}, {file, File}, {type, halt},
{distributed, [node()]}]),
- ?line {[],[n]} = disk_log:accessible_logs(),
+ {[],[n]} = disk_log:accessible_logs(),
Group = grupp,
- ?line pg2:create(Group),
- ?line ok = pg2:join(Group, self()),
- ?line {[],[n]} = disk_log:accessible_logs(),
- ?line [_] =
+ pg2:create(Group),
+ ok = pg2:join(Group, self()),
+ {[],[n]} = disk_log:accessible_logs(),
+ [_] =
lists:filter(fun(P) -> disk_log:pid2name(P) =/= undefined end,
erlang:processes()),
- ?line pg2:delete(Group),
- ?line {[],[n]} = disk_log:accessible_logs(),
- ?line ok = disk_log:close(n),
- ?line {[],[]} = disk_log:accessible_logs(),
- ?line file:delete(File),
+ pg2:delete(Group),
+ {[],[n]} = disk_log:accessible_logs(),
+ ok = disk_log:close(n),
+ {[],[]} = disk_log:accessible_logs(),
+ file:delete(File),
ok.
-define(MAX, 16384). % MAX in disk_log_1.erl
-evil(suite) -> [];
-evil(doc) -> ["Evil cases such as closed file descriptor port."];
+%% Evil cases such as closed file descriptor port.
evil(Conf) when is_list(Conf) ->
Dir = ?privdir(Conf),
File = filename:join(Dir, "n.LOG"),
@@ -4790,62 +4675,62 @@ evil(Conf) when is_list(Conf) ->
%% Not a very thorough test.
- ?line ok = setup_evil_filled_cache_wrap(Log, Dir),
- ?line {error, {file_error,_,einval}} = disk_log:log(Log, apa),
- ?line ok = disk_log:close(Log),
+ ok = setup_evil_filled_cache_wrap(Log, Dir),
+ {error, {file_error,_,einval}} = disk_log:log(Log, apa),
+ ok = disk_log:close(Log),
- ?line ok = setup_evil_filled_cache_halt(Log, Dir),
- ?line {error, {file_error,_,einval}} = disk_log:truncate(Log, apa),
- ?line ok = stop_evil(Log),
+ ok = setup_evil_filled_cache_halt(Log, Dir),
+ {error, {file_error,_,einval}} = disk_log:truncate(Log, apa),
+ ok = stop_evil(Log),
%% White box test.
file:delete(File),
- ?line Ports0 = erlang:ports(),
- ?line {ok, Log} = disk_log:open([{name,Log},{file,File},{type,halt},
+ Ports0 = erlang:ports(),
+ {ok, Log} = disk_log:open([{name,Log},{file,File},{type,halt},
{size,?MAX+50},{format,external}]),
- ?line [Fd] = erlang:ports() -- Ports0,
- ?line {B,_} = x_mk_bytes(30),
- ?line ok = disk_log:blog(Log, <<0:(?MAX+1)/unit:8>>),
- ?line exit(Fd, kill),
- ?line {error, {file_error,_,einval}} = disk_log:blog_terms(Log, [B,B]),
- ?line ok= disk_log:close(Log),
+ [Fd] = erlang:ports() -- Ports0,
+ {B,_} = x_mk_bytes(30),
+ ok = disk_log:blog(Log, <<0:(?MAX+1)/unit:8>>),
+ exit(Fd, kill),
+ {error, {file_error,_,einval}} = disk_log:blog_terms(Log, [B,B]),
+ ok= disk_log:close(Log),
file:delete(File),
- ?line ok = setup_evil_wrap(Log, Dir),
- ?line {error, {file_error,_,einval}} = disk_log:close(Log),
+ ok = setup_evil_wrap(Log, Dir),
+ {error, {file_error,_,einval}} = disk_log:close(Log),
- ?line ok = setup_evil_wrap(Log, Dir),
- ?line {error, {file_error,_,einval}} = disk_log:log(Log, apa),
- ?line ok = stop_evil(Log),
+ ok = setup_evil_wrap(Log, Dir),
+ {error, {file_error,_,einval}} = disk_log:log(Log, apa),
+ ok = stop_evil(Log),
- ?line ok = setup_evil_halt(Log, Dir),
- ?line {error, {file_error,_,einval}} = disk_log:log(Log, apa),
- ?line ok = stop_evil(Log),
+ ok = setup_evil_halt(Log, Dir),
+ {error, {file_error,_,einval}} = disk_log:log(Log, apa),
+ ok = stop_evil(Log),
- ?line ok = setup_evil_wrap(Log, Dir),
- ?line {error, {file_error,_,einval}} = disk_log:reopen(Log, apa),
- ?line {error, {file_error,_,einval}} = disk_log:reopen(Log, apa),
- ?line ok = stop_evil(Log),
+ ok = setup_evil_wrap(Log, Dir),
+ {error, {file_error,_,einval}} = disk_log:reopen(Log, apa),
+ {error, {file_error,_,einval}} = disk_log:reopen(Log, apa),
+ ok = stop_evil(Log),
- ?line ok = setup_evil_wrap(Log, Dir),
- ?line {error, {file_error,_,einval}} = disk_log:reopen(Log, apa),
- ?line ok = stop_evil(Log),
+ ok = setup_evil_wrap(Log, Dir),
+ {error, {file_error,_,einval}} = disk_log:reopen(Log, apa),
+ ok = stop_evil(Log),
- ?line ok = setup_evil_wrap(Log, Dir),
- ?line {error, {file_error,_,einval}} = disk_log:inc_wrap_file(Log),
- ?line ok = stop_evil(Log),
+ ok = setup_evil_wrap(Log, Dir),
+ {error, {file_error,_,einval}} = disk_log:inc_wrap_file(Log),
+ ok = stop_evil(Log),
- ?line ok = setup_evil_wrap(Log, Dir),
- ?line {error, {file_error,_,einval}} = disk_log:chunk(Log, start),
- ?line ok = stop_evil(Log),
+ ok = setup_evil_wrap(Log, Dir),
+ {error, {file_error,_,einval}} = disk_log:chunk(Log, start),
+ ok = stop_evil(Log),
- ?line ok = setup_evil_wrap(Log, Dir),
- ?line {error, {file_error,_,einval}} = disk_log:truncate(Log),
- ?line ok = stop_evil(Log),
+ ok = setup_evil_wrap(Log, Dir),
+ {error, {file_error,_,einval}} = disk_log:truncate(Log),
+ ok = stop_evil(Log),
- ?line ok = setup_evil_wrap(Log, Dir),
- ?line {error, {file_error,_,einval}} = disk_log:chunk_step(Log, start, 1),
- ?line ok = stop_evil(Log),
+ ok = setup_evil_wrap(Log, Dir),
+ {error, {file_error,_,einval}} = disk_log:chunk_step(Log, start, 1),
+ ok = stop_evil(Log),
io:format("messages: ~p~n", [erlang:process_info(self(), messages)]),
del(File, 2),
@@ -4894,25 +4779,23 @@ setup_evil_filled_cache(Log, Args, Dir) ->
exit(Fd, kill),
ok.
-otp_6278(suite) -> [];
-otp_6278(doc) -> ["OTP-6278. open/1 creates no status or crash report."];
+%% OTP-6278. open/1 creates no status or crash report.
otp_6278(Conf) when is_list(Conf) ->
Dir = ?privdir(Conf),
File = filename:join(Dir, "no_such_dir/no_such_file"),
- ?line error_logger:add_report_handler(?MODULE, self()),
- ?line {error, {file_error, _, _}} =
+ error_logger:add_report_handler(?MODULE, self()),
+ {error, {file_error, _, _}} =
disk_log:open([{name,n},{file,File}]),
receive
{crash_report,_Pid,Report} ->
- ?line io:format("Unexpected: ~p\n", [Report]),
- ?line ?t:fail()
+ io:format("Unexpected: ~p\n", [Report]),
+ ct:fail(failed)
after 1000 ->
ok
end,
- ?line error_logger:delete_report_handler(?MODULE).
+ error_logger:delete_report_handler(?MODULE).
-otp_10131(suite) -> [];
-otp_10131(doc) -> ["OTP-10131. head_func type."];
+%% OTP-10131. head_func type.
otp_10131(Conf) when is_list(Conf) ->
Dir = ?privdir(Conf),
Log = otp_10131,
@@ -4979,7 +4862,7 @@ copy_wrap_log(FromName, ToName, N, FromDir, ToDir) ->
-define(BUFSIZE, 8192).
copy_file(Src, Dest) ->
- % ?t:format("copying from ~p to ~p~n", [Src, Dest]),
+ %% io:format("copying from ~p to ~p~n", [Src, Dest]),
{ok, InFd} = file:open(Src, [raw, binary, read]),
{ok, OutFd} = file:open(Dest, [raw, binary, write]),
ok = copy_file1(InFd, OutFd),
@@ -5104,50 +4987,15 @@ get_known(Node) ->
%% Copied from erl_distribution_SUITE.erl:
start_node(Name, Param) ->
- ?t:start_node(Name, slave, [{args, Param}]).
+ test_server:start_node(Name, slave, [{args, Param}]).
stop_node(Node) ->
- ?t:stop_node(Node).
-
-%from(H, [H | T]) -> T;
-%from(H, [_ | T]) -> from(H, T);
-%from(_H, []) -> [].
-
-
-%% Check for NFS cache size, this is called from init_per_testcase() and
-%% makes different tests run depending on the size of the NFS cache on
-%% VxWorks. Possibly this could be adopted to Windows too, but we seldom use
-%% NFS when testing on windows, so I can find better things to do.
-%% The port program used simply reads the nfsCacheSize variable on the board.
-%% If the board is configured without NFS, the port program will fail to load
-%% and this will return 0, which may or may not be the wrong thing to do.
-
-check_nfs(_Config) ->
- 0.
+ test_server:stop_node(Node).
-skip_expand([]) ->
- [];
-skip_expand([Case | T]) ->
- case (catch apply(?MODULE, Case, [suite])) of
- {'EXIT', _} ->
- [Case | skip_expand(T)];
- [] ->
- [Case | skip_expand(T)];
- Res ->
- skip_expand(Res) ++ skip_expand(T)
- end.
-
-
-skip_list(Config) ->
- case check_nfs(Config) of
- 0 ->
- skip_expand(?SKIP_NO_CACHE);
- _ ->
- skip_expand(?SKIP_LARGE_CACHE)
- end.
+%% from(H, [H | T]) -> T;
+%% from(H, [_ | T]) -> from(H, T);
+%% from(_H, []) -> [].
-should_skip(_Test,_Config) ->
- false.
%%-----------------------------------------------------------------
%% The error_logger handler used.