aboutsummaryrefslogtreecommitdiffstats
path: root/lib/stdlib
diff options
context:
space:
mode:
authorHans Bolinder <[email protected]>2013-03-08 15:55:11 +0100
committerHans Bolinder <[email protected]>2013-03-18 16:26:34 +0100
commit2bcc458293f73c741ab2046f02a3e4c9bc0d57a1 (patch)
tree8ac6f00b0e36bfc55fe41a41973f3fb840eadf9e /lib/stdlib
parentb5c571f17a680d3481b43194e6648a03192b2397 (diff)
downloadotp-2bcc458293f73c741ab2046f02a3e4c9bc0d57a1.tar.gz
otp-2bcc458293f73c741ab2046f02a3e4c9bc0d57a1.tar.bz2
otp-2bcc458293f73c741ab2046f02a3e4c9bc0d57a1.zip
Remove ?line from dets_SUITE.erl
Diffstat (limited to 'lib/stdlib')
-rw-r--r--lib/stdlib/test/dets_SUITE.erl3857
1 files changed, 1928 insertions, 1929 deletions
diff --git a/lib/stdlib/test/dets_SUITE.erl b/lib/stdlib/test/dets_SUITE.erl
index 2c19fb3193..065b74ad41 100644
--- a/lib/stdlib/test/dets_SUITE.erl
+++ b/lib/stdlib/test/dets_SUITE.erl
@@ -22,7 +22,6 @@
-ifdef(debug).
-define(format(S, A), io:format(S, A)).
--define(line, put(line, ?LINE), ).
-define(config(X,Y), foo).
-define(t, test_server).
-define(privdir(_), "./dets_SUITE_priv").
@@ -135,10 +134,10 @@ newly_started(doc) ->
newly_started(suite) ->
[];
newly_started(Config) when is_list(Config) ->
- ?line true = is_alive(),
- ?line {ok, Node} = test_server:start_node(slave1, slave, []),
- ?line [] = rpc:call(Node, dets, all, []),
- ?line test_server:stop_node(Node),
+ true = is_alive(),
+ {ok, Node} = test_server:start_node(slave1, slave, []),
+ [] = rpc:call(Node, dets, all, []),
+ test_server:stop_node(Node),
ok.
basic_v8(doc) ->
@@ -156,31 +155,31 @@ basic_v9(Config) when is_list(Config) ->
basic(Config, 9).
basic(Config, Version) ->
- ?line Tab = dets_basic_test,
- ?line FName = filename(Tab, Config),
+ Tab = dets_basic_test,
+ FName = filename(Tab, Config),
P0 = pps(),
- ?line {ok, _} = dets:open_file(Tab,[{file, FName},{version,Version}]),
- ?line ok = dets:insert(Tab,{mazda,japan}),
- ?line ok = dets:insert(Tab,{toyota,japan}),
- ?line ok = dets:insert(Tab,{suzuki,japan}),
- ?line ok = dets:insert(Tab,{honda,japan}),
- ?line ok = dets:insert(Tab,{renault,france}),
- ?line ok = dets:insert(Tab,{citroen,france}),
- ?line ok = dets:insert(Tab,{opel,germany}),
- ?line ok = dets:insert(Tab,{saab,sweden}),
- ?line ok = dets:insert(Tab,{volvo,sweden}),
- ?line [{opel,germany}] = dets:lookup(Tab,opel),
- ?line Japs = dets:traverse(Tab, fun(Obj) ->
- case Obj of
- {_, japan} -> {continue, Obj};
- _ -> continue
- end
- end),
- ?line 4 = length(Japs),
- ?line ok = dets:close(Tab),
- ?line file:delete(FName),
- ?line check_pps(P0),
+ {ok, _} = dets:open_file(Tab,[{file, FName},{version,Version}]),
+ ok = dets:insert(Tab,{mazda,japan}),
+ ok = dets:insert(Tab,{toyota,japan}),
+ ok = dets:insert(Tab,{suzuki,japan}),
+ ok = dets:insert(Tab,{honda,japan}),
+ ok = dets:insert(Tab,{renault,france}),
+ ok = dets:insert(Tab,{citroen,france}),
+ ok = dets:insert(Tab,{opel,germany}),
+ ok = dets:insert(Tab,{saab,sweden}),
+ ok = dets:insert(Tab,{volvo,sweden}),
+ [{opel,germany}] = dets:lookup(Tab,opel),
+ Japs = dets:traverse(Tab, fun(Obj) ->
+ case Obj of
+ {_, japan} -> {continue, Obj};
+ _ -> continue
+ end
+ end),
+ 4 = length(Japs),
+ ok = dets:close(Tab),
+ file:delete(FName),
+ check_pps(P0),
ok.
@@ -204,24 +203,24 @@ open(Config, Version) ->
%% If this becomes a problem, one should consider running this
%% test on a slave node.
- ?line {Sets, Bags, Dups} = args(Config),
+ {Sets, Bags, Dups} = args(Config),
- ?line All = Sets ++ Bags ++ Dups,
- ?line delete_files(All),
+ All = Sets ++ Bags ++ Dups,
+ delete_files(All),
- ?line Data = make_data(1),
+ Data = make_data(1),
P0 = pps(),
- ?line Tabs = open_files(1, All, Version),
- ?line initialize(Tabs, Data),
- ?line check(Tabs, Data),
+ Tabs = open_files(1, All, Version),
+ initialize(Tabs, Data),
+ check(Tabs, Data),
- ?line foreach(fun(Tab) -> ok = dets:close(Tab) end, Tabs),
+ foreach(fun(Tab) -> ok = dets:close(Tab) end, Tabs),
%% Now reopen the files
?format("Reopening closed files \n", []),
- ?line Tabs = open_files(1, All, Version),
+ Tabs = open_files(1, All, Version),
?format("Checking contents of reopened files \n", []),
- ?line check(Tabs, Data),
+ check(Tabs, Data),
%% crash the dets server
?format("Crashing dets server \n", []),
@@ -235,25 +234,25 @@ open(Config, Version) ->
%% Now reopen the files again
?format("Reopening crashed files \n", []),
- ?line open_files(1, All, Version),
+ open_files(1, All, Version),
?format("Checking contents of repaired files \n", []),
- ?line check(Tabs, Data),
+ check(Tabs, Data),
- ?line close_all(Tabs),
+ close_all(Tabs),
- ?line delete_files(All),
+ delete_files(All),
P1 = pps(),
{Ports0, Procs0} = P0,
{Ports1, Procs1} = P1,
- ?line true = Ports1 =:= Ports0,
+ true = Ports1 =:= Ports0,
%% The dets_server process has been restarted:
- ?line [_] = Procs0 -- Procs1,
- ?line [_] = Procs1 -- Procs0,
+ [_] = Procs0 -- Procs1,
+ [_] = Procs1 -- Procs0,
ok.
check(Tabs, Data) ->
foreach(fun(Tab) ->
- ?line Kp = dets:info(Tab, keypos),
+ Kp = dets:info(Tab, keypos),
?format("checking ~p~n", [Tab]),
foreach(fun(Item) ->
case dets:lookup(Tab, k(Kp,Item)) of
@@ -285,31 +284,31 @@ sets_v9(Config) when is_list(Config) ->
sets(Config, 9).
sets(Config, Version) ->
- ?line {Sets, _, _} = args(Config),
+ {Sets, _, _} = args(Config),
- ?line Data = make_data(1),
- ?line delete_files(Sets),
+ Data = make_data(1),
+ delete_files(Sets),
P0 = pps(),
- ?line Tabs = open_files(1, Sets, Version),
+ Tabs = open_files(1, Sets, Version),
Bigger = [{17,q,w,w}, {48,q,w,w,w,w,w,w}], % 48 requires a bigger buddy
- ?line initialize(Tabs, Data++Bigger++Data), % overwrite
- ?line Len = length(Data),
- ?line foreach(fun(Tab) -> trav_test(Data, Len, Tab) end, Tabs),
- ?line size_test(Len, Tabs),
- ?line no_keys_test(Tabs),
- ?line foreach(fun(Tab) -> del_test(Tab) end, Tabs),
- ?line initialize(Tabs, Data),
- ?line foreach(fun(Tab) -> del_obj_test(Tab) end, Tabs),
- ?line initialize(Tabs, Data),
- ?line foreach(fun(Tab) ->
- Len = dets:info(Tab, size) end,
- Tabs),
- ?line foreach(fun(Tab) -> match_test(Data, Tab) end, Tabs),
- ?line foreach(fun(Tab) -> match_del_test(Tab) end, Tabs),
+ initialize(Tabs, Data++Bigger++Data), % overwrite
+ Len = length(Data),
+ foreach(fun(Tab) -> trav_test(Data, Len, Tab) end, Tabs),
+ size_test(Len, Tabs),
+ no_keys_test(Tabs),
+ foreach(fun(Tab) -> del_test(Tab) end, Tabs),
+ initialize(Tabs, Data),
+ foreach(fun(Tab) -> del_obj_test(Tab) end, Tabs),
+ initialize(Tabs, Data),
+ foreach(fun(Tab) ->
+ Len = dets:info(Tab, size) end,
+ Tabs),
+ foreach(fun(Tab) -> match_test(Data, Tab) end, Tabs),
+ foreach(fun(Tab) -> match_del_test(Tab) end, Tabs),
- ?line close_all(Tabs),
- ?line delete_files(Sets),
- ?line check_pps(P0),
+ close_all(Tabs),
+ delete_files(Sets),
+ check_pps(P0),
ok.
bags_v8(doc) ->
@@ -328,27 +327,27 @@ bags_v9(Config) when is_list(Config) ->
bags(Config, Version) ->
{_, Bags, _} = args(Config),
- ?line Data = make_data(1, bag), %% gives twice as many objects
- ?line delete_files(Bags),
+ Data = make_data(1, bag), %% gives twice as many objects
+ delete_files(Bags),
P0 = pps(),
- ?line Tabs = open_files(1, Bags, Version),
- ?line initialize(Tabs, Data++Data),
- ?line Len = length(Data),
- ?line foreach(fun(Tab) -> trav_test(Data, Len, Tab) end, Tabs),
- ?line size_test(Len, Tabs),
- ?line no_keys_test(Tabs),
- ?line foreach(fun(Tab) -> del_test(Tab) end, Tabs),
- ?line initialize(Tabs, Data),
- ?line foreach(fun(Tab) -> del_obj_test(Tab) end, Tabs),
- ?line initialize(Tabs, Data),
- ?line foreach(fun(Tab) ->
- Len = dets:info(Tab, size) end,
- Tabs),
- ?line foreach(fun(Tab) -> match_test(Data, Tab) end, Tabs),
- ?line foreach(fun(Tab) -> match_del_test(Tab) end, Tabs),
- ?line close_all(Tabs),
- ?line delete_files(Bags),
- ?line check_pps(P0),
+ Tabs = open_files(1, Bags, Version),
+ initialize(Tabs, Data++Data),
+ Len = length(Data),
+ foreach(fun(Tab) -> trav_test(Data, Len, Tab) end, Tabs),
+ size_test(Len, Tabs),
+ no_keys_test(Tabs),
+ foreach(fun(Tab) -> del_test(Tab) end, Tabs),
+ initialize(Tabs, Data),
+ foreach(fun(Tab) -> del_obj_test(Tab) end, Tabs),
+ initialize(Tabs, Data),
+ foreach(fun(Tab) ->
+ Len = dets:info(Tab, size) end,
+ Tabs),
+ foreach(fun(Tab) -> match_test(Data, Tab) end, Tabs),
+ foreach(fun(Tab) -> match_del_test(Tab) end, Tabs),
+ close_all(Tabs),
+ delete_files(Bags),
+ check_pps(P0),
ok.
@@ -368,27 +367,27 @@ duplicate_bags_v9(Config) when is_list(Config) ->
duplicate_bags(Config, Version) when is_list(Config) ->
{_, _, Dups} = args(Config),
- ?line Data = make_data(1, duplicate_bag), %% gives twice as many objects
- ?line delete_files(Dups),
+ Data = make_data(1, duplicate_bag), %% gives twice as many objects
+ delete_files(Dups),
P0 = pps(),
- ?line Tabs = open_files(1, Dups, Version),
- ?line initialize(Tabs, Data),
- ?line Len = length(Data),
- ?line foreach(fun(Tab) -> trav_test(Data, Len, Tab) end, Tabs),
- ?line size_test(Len, Tabs),
- ?line no_keys_test(Tabs),
- ?line foreach(fun(Tab) -> del_test(Tab) end, Tabs),
- ?line initialize(Tabs, Data),
- ?line foreach(fun(Tab) -> del_obj_test(Tab) end, Tabs),
- ?line initialize(Tabs, Data),
- ?line foreach(fun(Tab) ->
- Len = dets:info(Tab, size) end,
- Tabs),
- ?line foreach(fun(Tab) -> match_test(Data, Tab) end, Tabs),
- ?line foreach(fun(Tab) -> match_del_test(Tab) end, Tabs),
- ?line close_all(Tabs),
- ?line delete_files(Dups),
- ?line check_pps(P0),
+ Tabs = open_files(1, Dups, Version),
+ initialize(Tabs, Data),
+ Len = length(Data),
+ foreach(fun(Tab) -> trav_test(Data, Len, Tab) end, Tabs),
+ size_test(Len, Tabs),
+ no_keys_test(Tabs),
+ foreach(fun(Tab) -> del_test(Tab) end, Tabs),
+ initialize(Tabs, Data),
+ foreach(fun(Tab) -> del_obj_test(Tab) end, Tabs),
+ initialize(Tabs, Data),
+ foreach(fun(Tab) ->
+ Len = dets:info(Tab, size) end,
+ Tabs),
+ foreach(fun(Tab) -> match_test(Data, Tab) end, Tabs),
+ foreach(fun(Tab) -> match_del_test(Tab) end, Tabs),
+ close_all(Tabs),
+ delete_files(Dups),
+ check_pps(P0),
ok.
@@ -412,26 +411,26 @@ access(Config, Version) ->
Args = [[{ram_file, true}],
[]],
- ?line {Args_acc_1, _, _} = zip_filename(Args_acc, [], [], Config),
- ?line delete_files(Args_acc_1),
- ?line {Args_1, _, _} = zip_filename(Args, [], [], Config),
+ {Args_acc_1, _, _} = zip_filename(Args_acc, [], [], Config),
+ delete_files(Args_acc_1),
+ {Args_1, _, _} = zip_filename(Args, [], [], Config),
P0 = pps(),
- ?line {error, {file_error,_,enoent}} = dets:open_file('1', hd(Args_acc_1)),
-
- ?line Tabs = open_files(1, Args_1, Version),
- ?line close_all(Tabs),
- ?line Tabs = open_files(1, Args_acc_1, Version),
-
- ?line foreach(fun(Tab) ->
- {error, {access_mode,_}} = dets:insert(Tab, {1,2}),
- [] = dets:lookup(Tab, 11),
- '$end_of_table' = dets:first(Tab),
- {error, {access_mode,_}} = dets:delete(Tab, 22)
- end, Tabs),
- ?line close_all(Tabs),
- ?line delete_files(Args_acc_1),
- ?line check_pps(P0),
+ {error, {file_error,_,enoent}} = dets:open_file('1', hd(Args_acc_1)),
+
+ Tabs = open_files(1, Args_1, Version),
+ close_all(Tabs),
+ Tabs = open_files(1, Args_acc_1, Version),
+
+ foreach(fun(Tab) ->
+ {error, {access_mode,_}} = dets:insert(Tab, {1,2}),
+ [] = dets:lookup(Tab, 11),
+ '$end_of_table' = dets:first(Tab),
+ {error, {access_mode,_}} = dets:delete(Tab, 22)
+ end, Tabs),
+ close_all(Tabs),
+ delete_files(Args_acc_1),
+ check_pps(P0),
ok.
@@ -440,23 +439,23 @@ dirty_mark(doc) ->
dirty_mark(suite) ->
[];
dirty_mark(Config) when is_list(Config) ->
- ?line true = is_alive(),
- ?line Tab = dets_dirty_mark_test,
- ?line FName = filename(Tab, Config),
+ true = is_alive(),
+ Tab = dets_dirty_mark_test,
+ FName = filename(Tab, Config),
P0 = pps(),
- ?line dets:open_file(Tab,[{file, FName}]),
- ?line dets:insert(Tab,{mazda,japan}),
- ?line dets:insert(Tab,{toyota,japan}),
- ?line dets:insert(Tab,{suzuki,japan}),
- ?line dets:insert(Tab,{honda,japan}),
- ?line dets:insert(Tab,{renault,france}),
- ?line dets:insert(Tab,{citroen,france}),
- ?line dets:insert(Tab,{opel,germany}),
- ?line dets:insert(Tab,{saab,sweden}),
- ?line dets:insert(Tab,{volvo,sweden}),
- ?line [{opel,germany}] = dets:lookup(Tab,opel),
- ?line ok = dets:close(Tab),
- ?line Call = fun(P,A) ->
+ dets:open_file(Tab,[{file, FName}]),
+ dets:insert(Tab,{mazda,japan}),
+ dets:insert(Tab,{toyota,japan}),
+ dets:insert(Tab,{suzuki,japan}),
+ dets:insert(Tab,{honda,japan}),
+ dets:insert(Tab,{renault,france}),
+ dets:insert(Tab,{citroen,france}),
+ dets:insert(Tab,{opel,germany}),
+ dets:insert(Tab,{saab,sweden}),
+ dets:insert(Tab,{volvo,sweden}),
+ [{opel,germany}] = dets:lookup(Tab,opel),
+ ok = dets:close(Tab),
+ Call = fun(P,A) ->
P ! {self(), A},
receive
{P, Ans} ->
@@ -465,26 +464,26 @@ dirty_mark(Config) when is_list(Config) ->
exit(other_process_dead)
end
end,
- ?line {ok, Node} = test_server:start_node(dets_dirty_mark,
- slave,
- [{linked, false},
- {args, "-pa " ++
- filename:dirname
+ {ok, Node} = test_server:start_node(dets_dirty_mark,
+ slave,
+ [{linked, false},
+ {args, "-pa " ++
+ filename:dirname
(code:which(?MODULE))}]),
- ?line ok = ensure_node(20, Node),
+ ok = ensure_node(20, Node),
%% io:format("~p~n",[rpc:call(Node, code, get_path, [])]),
%% io:format("~p~n",[rpc:call(Node, file, get_cwd, [])]),
%% io:format("~p~n",[Config]),
- ?line Pid = rpc:call(Node,erlang, spawn,
+ Pid = rpc:call(Node,erlang, spawn,
[?MODULE, dets_dirty_loop, []]),
- ?line {ok, Tab} = Call(Pid, [open, Tab, [{file, FName}]]),
- ?line [{opel,germany}] = Call(Pid, [read,Tab,opel]),
- ?line test_server:stop_node(Node),
- ?line {ok, Tab} = dets:open_file(Tab,[{file, FName},
- {repair,false}]),
- ?line ok = dets:close(Tab),
- ?line file:delete(FName),
- ?line check_pps(P0),
+ {ok, Tab} = Call(Pid, [open, Tab, [{file, FName}]]),
+ [{opel,germany}] = Call(Pid, [read,Tab,opel]),
+ test_server:stop_node(Node),
+ {ok, Tab} = dets:open_file(Tab,[{file, FName},
+ {repair,false}]),
+ ok = dets:close(Tab),
+ file:delete(FName),
+ check_pps(P0),
ok.
dirty_mark2(doc) ->
@@ -492,22 +491,22 @@ dirty_mark2(doc) ->
dirty_mark2(suite) ->
[];
dirty_mark2(Config) when is_list(Config) ->
- ?line true = is_alive(),
- ?line Tab = dets_dirty_mark2_test,
- ?line FName = filename(Tab, Config),
+ true = is_alive(),
+ Tab = dets_dirty_mark2_test,
+ FName = filename(Tab, Config),
P0 = pps(),
- ?line dets:open_file(Tab,[{file, FName}]),
- ?line dets:insert(Tab,{toyota,japan}),
- ?line dets:insert(Tab,{suzuki,japan}),
- ?line dets:insert(Tab,{honda,japan}),
- ?line dets:insert(Tab,{renault,france}),
- ?line dets:insert(Tab,{citroen,france}),
- ?line dets:insert(Tab,{opel,germany}),
- ?line dets:insert(Tab,{saab,sweden}),
- ?line dets:insert(Tab,{volvo,sweden}),
- ?line [{opel,germany}] = dets:lookup(Tab,opel),
- ?line ok = dets:close(Tab),
- ?line Call = fun(P,A) ->
+ dets:open_file(Tab,[{file, FName}]),
+ dets:insert(Tab,{toyota,japan}),
+ dets:insert(Tab,{suzuki,japan}),
+ dets:insert(Tab,{honda,japan}),
+ dets:insert(Tab,{renault,france}),
+ dets:insert(Tab,{citroen,france}),
+ dets:insert(Tab,{opel,germany}),
+ dets:insert(Tab,{saab,sweden}),
+ dets:insert(Tab,{volvo,sweden}),
+ [{opel,germany}] = dets:lookup(Tab,opel),
+ ok = dets:close(Tab),
+ Call = fun(P,A) ->
P ! {self(), A},
receive
{P, Ans} ->
@@ -516,25 +515,25 @@ dirty_mark2(Config) when is_list(Config) ->
exit(other_process_dead)
end
end,
- ?line {ok, Node} = test_server:start_node(dets_dirty_mark2,
- slave,
- [{linked, false},
- {args, "-pa " ++
- filename:dirname
+ {ok, Node} = test_server:start_node(dets_dirty_mark2,
+ slave,
+ [{linked, false},
+ {args, "-pa " ++
+ filename:dirname
(code:which(?MODULE))}]),
- ?line ok = ensure_node(20, Node),
- ?line Pid = rpc:call(Node,erlang, spawn,
- [?MODULE, dets_dirty_loop, []]),
- ?line {ok, Tab} = Call(Pid, [open, Tab, [{file, FName},{auto_save,1000}]]),
- ?line ok = Call(Pid, [write,Tab,{mazda,japan}]),
- ?line timer:sleep(2100),
+ ok = ensure_node(20, Node),
+ Pid = rpc:call(Node,erlang, spawn,
+ [?MODULE, dets_dirty_loop, []]),
+ {ok, Tab} = Call(Pid, [open, Tab, [{file, FName},{auto_save,1000}]]),
+ ok = Call(Pid, [write,Tab,{mazda,japan}]),
+ timer:sleep(2100),
%% Read something, just to give auto save time to finish.
- ?line [{opel,germany}] = Call(Pid, [read,Tab,opel]),
- ?line test_server:stop_node(Node),
- ?line {ok, Tab} = dets:open_file(Tab, [{file, FName}, {repair,false}]),
- ?line ok = dets:close(Tab),
- ?line file:delete(FName),
- ?line check_pps(P0),
+ [{opel,germany}] = Call(Pid, [read,Tab,opel]),
+ test_server:stop_node(Node),
+ {ok, Tab} = dets:open_file(Tab, [{file, FName}, {repair,false}]),
+ ok = dets:close(Tab),
+ file:delete(FName),
+ check_pps(P0),
ok.
dets_dirty_loop() ->
@@ -570,38 +569,38 @@ bag_next_v9(suite) ->
bag_next_v9(doc) ->
["Check that bags and next work as expected."];
bag_next_v9(Config) when is_list(Config) ->
- ?line Tab = dets_bag_next_test,
- ?line FName = filename(Tab, Config),
+ Tab = dets_bag_next_test,
+ FName = filename(Tab, Config),
%% first and next crash upon error
- ?line dets:open_file(Tab,[{file, FName}, {type, bag},{version,9}]),
- ?line ok = dets:insert(Tab, [{1,1},{2,2},{3,3},{4,4}]),
- ?line FirstKey = dets:first(Tab),
- ?line NextKey = dets:next(Tab, FirstKey),
- ?line [FirstObj | _] = dets:lookup(Tab, FirstKey),
- ?line [NextObj | _] = dets:lookup(Tab, NextKey),
- ?line {ok, FirstPos} = dets:where(Tab, FirstObj),
- ?line {ok, NextPos} = dets:where(Tab, NextObj),
+ dets:open_file(Tab,[{file, FName}, {type, bag},{version,9}]),
+ ok = dets:insert(Tab, [{1,1},{2,2},{3,3},{4,4}]),
+ FirstKey = dets:first(Tab),
+ NextKey = dets:next(Tab, FirstKey),
+ [FirstObj | _] = dets:lookup(Tab, FirstKey),
+ [NextObj | _] = dets:lookup(Tab, NextKey),
+ {ok, FirstPos} = dets:where(Tab, FirstObj),
+ {ok, NextPos} = dets:where(Tab, NextObj),
crash(FName, NextPos+12),
- ?line {'EXIT',BadObject1} = (catch dets:next(Tab, FirstKey)),
- ?line bad_object(BadObject1, FName),
+ {'EXIT',BadObject1} = (catch dets:next(Tab, FirstKey)),
+ bad_object(BadObject1, FName),
crash(FName, FirstPos+12),
- ?line {'EXIT',BadObject2} = (catch dets:first(Tab)),
- ?line bad_object(BadObject2, FName),
- ?line dets:close(Tab),
- ?line file:delete(FName),
+ {'EXIT',BadObject2} = (catch dets:first(Tab)),
+ bad_object(BadObject2, FName),
+ dets:close(Tab),
+ file:delete(FName),
bag_next(Config, 9).
bag_next(Config, Version) ->
- ?line Tab = dets_bag_next_test,
- ?line FName = filename(Tab, Config),
+ Tab = dets_bag_next_test,
+ FName = filename(Tab, Config),
P0 = pps(),
- ?line dets:open_file(Tab,[{file, FName}, {type, bag},{version,Version}]),
- ?line dets:insert(Tab,{698,hopp}),
- ?line dets:insert(Tab,{186,hopp}),
- ?line dets:insert(Tab,{hej,hopp}),
- ?line dets:insert(Tab,{186,plopp}),
+ dets:open_file(Tab,[{file, FName}, {type, bag},{version,Version}]),
+ dets:insert(Tab,{698,hopp}),
+ dets:insert(Tab,{186,hopp}),
+ dets:insert(Tab,{hej,hopp}),
+ dets:insert(Tab,{186,plopp}),
Loop = fun(N, Last, Self) ->
case N of
0 ->
@@ -615,10 +614,10 @@ bag_next(Config, Version) ->
end
end
end,
- ?line ok = Loop(4,dets:first(Tab),Loop),
- ?line dets:close(Tab),
- ?line file:delete(FName),
- ?line check_pps(P0),
+ ok = Loop(4,dets:first(Tab),Loop),
+ dets:close(Tab),
+ file:delete(FName),
+ check_pps(P0),
ok.
oldbugs_v8(doc) ->
@@ -638,15 +637,15 @@ oldbugs_v9(Config) when is_list(Config) ->
oldbugs(Config, Version) ->
FName = filename(dets_suite_oldbugs_test, Config),
P0 = pps(),
- ?line {ok, ob} = dets:open_file(ob, [{version, Version},
+ {ok, ob} = dets:open_file(ob, [{version, Version},
{type, bag}, {file, FName}]),
- ?line ok = dets:insert(ob, {1, 2}),
- ?line ok = dets:insert(ob, {1,3}),
- ?line ok = dets:insert(ob, {1, 2}),
- ?line 2 = dets:info(ob, size), %% assertion
- ?line ok = dets:close(ob),
- ?line file:delete(FName),
- ?line check_pps(P0),
+ ok = dets:insert(ob, {1, 2}),
+ ok = dets:insert(ob, {1,3}),
+ ok = dets:insert(ob, {1, 2}),
+ 2 = dets:info(ob, size), %% assertion
+ ok = dets:close(ob),
+ file:delete(FName),
+ check_pps(P0),
ok.
unsafe_assumptions(suite) -> [];
@@ -654,30 +653,30 @@ unsafe_assumptions(doc) ->
"Tests that shrinking an object and then expanding it works.";
unsafe_assumptions(Config) when is_list(Config) ->
FName = filename(dets_suite_unsafe_assumptions_test, Config),
- ?line file:delete(FName),
+ file:delete(FName),
P0 = pps(),
- ?line {ok, a} = dets:open_file(a, [{version,8},{file, FName}]),
+ {ok, a} = dets:open_file(a, [{version,8},{file, FName}]),
O0 = {2,false},
O1 = {1, false},
O2 = {1, true},
O3 = {1, duplicate(20,false)},
O4 = {1, duplicate(25,false)}, % same 2-log as O3
- ?line ok = dets:insert(a, O1),
- ?line ok = dets:insert(a, O0),
- ?line true = [O1,O0] =:= sort(get_all_objects(a)),
- ?line true = [O1,O0] =:= sort(get_all_objects_fast(a)),
- ?line ok = dets:insert(a, O2),
- ?line true = [O2,O0] =:= sort(get_all_objects(a)),
- ?line true = [O2,O0] =:= sort(get_all_objects_fast(a)),
- ?line ok = dets:insert(a, O3),
- ?line true = [O3,O0] =:= sort(get_all_objects(a)),
- ?line true = [O3,O0] =:= sort(get_all_objects_fast(a)),
- ?line ok = dets:insert(a, O4),
- ?line true = [O4,O0] =:= sort(get_all_objects(a)),
- ?line true = [O4,O0] =:= sort(get_all_objects_fast(a)),
- ?line ok = dets:close(a),
- ?line file:delete(FName),
- ?line check_pps(P0),
+ ok = dets:insert(a, O1),
+ ok = dets:insert(a, O0),
+ true = [O1,O0] =:= sort(get_all_objects(a)),
+ true = [O1,O0] =:= sort(get_all_objects_fast(a)),
+ ok = dets:insert(a, O2),
+ true = [O2,O0] =:= sort(get_all_objects(a)),
+ true = [O2,O0] =:= sort(get_all_objects_fast(a)),
+ ok = dets:insert(a, O3),
+ true = [O3,O0] =:= sort(get_all_objects(a)),
+ true = [O3,O0] =:= sort(get_all_objects_fast(a)),
+ ok = dets:insert(a, O4),
+ true = [O4,O0] =:= sort(get_all_objects(a)),
+ true = [O4,O0] =:= sort(get_all_objects_fast(a)),
+ ok = dets:close(a),
+ file:delete(FName),
+ check_pps(P0),
ok.
truncated_segment_array_v8(suite) -> [];
@@ -698,22 +697,22 @@ trunc_seg_array(Config, V) ->
TabRef = dets_suite_truncated_segment_array_test,
Fname = filename(TabRef, Config),
%% Create file that needs to be repaired
- ?line file:delete(Fname),
+ file:delete(Fname),
P0 = pps(),
- ?line {ok, TabRef} = dets:open_file(TabRef, [{file, Fname},{version,V}]),
- ?line ok = dets:close(TabRef),
+ {ok, TabRef} = dets:open_file(TabRef, [{file, Fname},{version,V}]),
+ ok = dets:close(TabRef),
%% Truncate the file
- ?line HeadSize = headsz(V),
- ?line truncate(Fname, HeadSize + 10),
+ HeadSize = headsz(V),
+ truncate(Fname, HeadSize + 10),
%% Open the truncated file
- ?line io:format("Expect repair:~n"),
- ?line {ok, TabRef} = dets:open_file(TabRef,
+ io:format("Expect repair:~n"),
+ {ok, TabRef} = dets:open_file(TabRef,
[{file, Fname}, {repair, true}]),
- ?line ok = dets:close(TabRef),
- ?line file:delete(Fname),
- ?line check_pps(P0),
+ ok = dets:close(TabRef),
+ file:delete(Fname),
+ check_pps(P0),
ok.
open_file_v8(doc) ->
@@ -730,58 +729,58 @@ open_file_v9(suite) ->
open_file_v9(Config) when is_list(Config) ->
T = open_v9,
Fname = filename(T, Config),
- ?line {ok, _} = dets:open_file(T, [{file,Fname},{version,9}]),
- ?line 9 = dets:info(T, version),
- ?line true = [self()] =:= dets:info(T, users),
- ?line {ok, _} = dets:open_file(T, [{file,Fname},{version,9}]),
- ?line {error,incompatible_arguments} =
+ {ok, _} = dets:open_file(T, [{file,Fname},{version,9}]),
+ 9 = dets:info(T, version),
+ true = [self()] =:= dets:info(T, users),
+ {ok, _} = dets:open_file(T, [{file,Fname},{version,9}]),
+ {error,incompatible_arguments} =
dets:open_file(T, [{file,Fname},{version,8}]),
- ?line true = [self(),self()] =:= dets:info(T, users),
- ?line ok = dets:close(T),
- ?line true = [self()] =:= dets:info(T, users),
- ?line ok = dets:close(T),
- ?line undefined = ets:info(T, users),
- ?line file:delete(Fname),
+ true = [self(),self()] =:= dets:info(T, users),
+ ok = dets:close(T),
+ true = [self()] =:= dets:info(T, users),
+ ok = dets:close(T),
+ undefined = ets:info(T, users),
+ file:delete(Fname),
open_1(Config, 9).
open_1(Config, V) ->
TabRef = open_file_1_test,
Fname = filename(TabRef, Config),
- ?line file:delete(Fname),
+ file:delete(Fname),
P0 = pps(),
- ?line {error,{file_error,Fname,enoent}} = dets:open_file(Fname),
+ {error,{file_error,Fname,enoent}} = dets:open_file(Fname),
- ?line ok = file:write_file(Fname, duplicate(100,65)),
- ?line {error,{not_a_dets_file,Fname}} = dets:open_file(Fname),
- ?line file:delete(Fname),
+ ok = file:write_file(Fname, duplicate(100,65)),
+ {error,{not_a_dets_file,Fname}} = dets:open_file(Fname),
+ file:delete(Fname),
HeadSize = headsz(V),
- ?line {ok, TabRef} = dets:open_file(TabRef, [{file, Fname},{version,V}]),
- ?line ok = dets:close(TabRef),
- ?line truncate(Fname, HeadSize + 10),
- ?line true = dets:is_dets_file(Fname),
- ?line io:format("Expect repair:~n"),
- ?line {ok, Ref} = dets:open_file(Fname), % repairing
- ?line ok = dets:close(Ref),
- ?line file:delete(Fname),
+ {ok, TabRef} = dets:open_file(TabRef, [{file, Fname},{version,V}]),
+ ok = dets:close(TabRef),
+ truncate(Fname, HeadSize + 10),
+ true = dets:is_dets_file(Fname),
+ io:format("Expect repair:~n"),
+ {ok, Ref} = dets:open_file(Fname), % repairing
+ ok = dets:close(Ref),
+ file:delete(Fname),
%% truncated file header, invalid type
- ?line {ok, TabRef} = dets:open_file(TabRef, [{file,Fname},{version,V}]),
- ?line ok = ins(TabRef, 3000),
- ?line ok = dets:close(TabRef),
+ {ok, TabRef} = dets:open_file(TabRef, [{file,Fname},{version,V}]),
+ ok = ins(TabRef, 3000),
+ ok = dets:close(TabRef),
TypePos = 12,
crash(Fname, TypePos),
- ?line {error, {invalid_type_code,Fname}} = dets:open_file(Fname),
- ?line truncate(Fname, HeadSize - 10),
- ?line {error, {tooshort,Fname}} = dets:open_file(Fname),
- ?line {ok, TabRef} = dets:open_file(TabRef, [{file,Fname},{version,V}]),
- ?line ok = dets:close(TabRef),
- ?line file:delete(Fname),
-
- ?line {error,{file_error,{foo,bar},_}} = dets:is_dets_file({foo,bar}),
- ?line check_pps(P0),
+ {error, {invalid_type_code,Fname}} = dets:open_file(Fname),
+ truncate(Fname, HeadSize - 10),
+ {error, {tooshort,Fname}} = dets:open_file(Fname),
+ {ok, TabRef} = dets:open_file(TabRef, [{file,Fname},{version,V}]),
+ ok = dets:close(TabRef),
+ file:delete(Fname),
+
+ {error,{file_error,{foo,bar},_}} = dets:is_dets_file({foo,bar}),
+ check_pps(P0),
ok.
init_table_v8(doc) ->
@@ -799,16 +798,16 @@ init_table_v9(Config) when is_list(Config) ->
%% Objects are returned in "time order".
T = init_table_v9,
Fname = filename(T, Config),
- ?line file:delete(Fname),
+ file:delete(Fname),
L = [{1,a},{2,b},{1,c},{2,c},{1,c},{2,a},{1,b}],
Input = init([L]),
- ?line {ok, _} = dets:open_file(T, [{file,Fname},{version,9},
+ {ok, _} = dets:open_file(T, [{file,Fname},{version,9},
{type,duplicate_bag}]),
- ?line ok = dets:init_table(T, Input),
- ?line [{1,a},{1,c},{1,c},{1,b}] = dets:lookup(T, 1),
- ?line [{2,b},{2,c},{2,a}] = dets:lookup(T, 2),
- ?line ok = dets:close(T),
- ?line file:delete(Fname),
+ ok = dets:init_table(T, Input),
+ [{1,a},{1,c},{1,c},{1,b}] = dets:lookup(T, 1),
+ [{2,b},{2,c},{2,a}] = dets:lookup(T, 2),
+ ok = dets:close(T),
+ file:delete(Fname),
init_table(Config, 9),
fast_init_table(Config).
@@ -816,57 +815,57 @@ init_table_v9(Config) when is_list(Config) ->
init_table(Config, V) ->
TabRef = init_table_test,
Fname = filename(TabRef, Config),
- ?line file:delete(Fname),
+ file:delete(Fname),
P0 = pps(),
Args = [{file,Fname},{version,V},{auto_save,120000}],
- ?line {ok, _} = dets:open_file(TabRef, Args),
- ?line {'EXIT', _} =
+ {ok, _} = dets:open_file(TabRef, Args),
+ {'EXIT', _} =
(catch dets:init_table(TabRef, fun(foo) -> bar end)),
dets:close(TabRef),
- ?line {ok, _} = dets:open_file(TabRef, Args),
- ?line {'EXIT', _} = (catch dets:init_table(TabRef, fun() -> foo end)),
+ {ok, _} = dets:open_file(TabRef, Args),
+ {'EXIT', _} = (catch dets:init_table(TabRef, fun() -> foo end)),
dets:close(TabRef),
- ?line {ok, _} = dets:open_file(TabRef, Args),
- ?line {'EXIT', {badarg, _}} = (catch dets:init_table(TabRef, nofun)),
- ?line {'EXIT', {badarg, _}} =
+ {ok, _} = dets:open_file(TabRef, Args),
+ {'EXIT', {badarg, _}} = (catch dets:init_table(TabRef, nofun)),
+ {'EXIT', {badarg, _}} =
(catch dets:init_table(TabRef, fun(_X) -> end_of_input end,
[{foo,bar}])),
dets:close(TabRef),
- ?line {ok, _} = dets:open_file(TabRef, Args),
- ?line away = (catch dets:init_table(TabRef, fun(_) -> throw(away) end)),
+ {ok, _} = dets:open_file(TabRef, Args),
+ away = (catch dets:init_table(TabRef, fun(_) -> throw(away) end)),
dets:close(TabRef),
- ?line {ok, _} = dets:open_file(TabRef, Args),
- ?line {error, {init_fun, fopp}} =
+ {ok, _} = dets:open_file(TabRef, Args),
+ {error, {init_fun, fopp}} =
dets:init_table(TabRef, fun(read) -> fopp end),
dets:close(TabRef),
- ?line {ok, _} = dets:open_file(TabRef, Args),
- ?line dets:safe_fixtable(TabRef, true),
- ?line {error, {fixed_table, TabRef}} = dets:init_table(TabRef, init([])),
- ?line dets:safe_fixtable(TabRef, false),
- ?line ET = ets:new(foo,[]),
- ?line ok = dets:from_ets(TabRef, ET),
- ?line [] = get_all_objects(TabRef),
- ?line [] = get_all_objects_fast(TabRef),
- ?line true = ets:insert(ET, {1,a}),
- ?line true = ets:insert(ET, {2,b}),
- ?line ok = dets:from_ets(TabRef, ET),
- ?line [{1,a},{2,b}] = sort(get_all_objects(TabRef)),
- ?line [{1,a},{2,b}] = sort(get_all_objects_fast(TabRef)),
- ?line true = ets:delete(ET),
- ?line 120000 = dets:info(TabRef, auto_save),
- ?line ok = dets:close(TabRef),
-
- ?line {ok, _} = dets:open_file(TabRef, [{access,read} | Args]),
- ?line {error, {access_mode, Fname}} = dets:init_table(TabRef, init([])),
- ?line ok = dets:close(TabRef),
-
- ?line {ok, _} = dets:open_file(TabRef, Args),
- ?line {error, invalid_objects_list} =
+ {ok, _} = dets:open_file(TabRef, Args),
+ dets:safe_fixtable(TabRef, true),
+ {error, {fixed_table, TabRef}} = dets:init_table(TabRef, init([])),
+ dets:safe_fixtable(TabRef, false),
+ ET = ets:new(foo,[]),
+ ok = dets:from_ets(TabRef, ET),
+ [] = get_all_objects(TabRef),
+ [] = get_all_objects_fast(TabRef),
+ true = ets:insert(ET, {1,a}),
+ true = ets:insert(ET, {2,b}),
+ ok = dets:from_ets(TabRef, ET),
+ [{1,a},{2,b}] = sort(get_all_objects(TabRef)),
+ [{1,a},{2,b}] = sort(get_all_objects_fast(TabRef)),
+ true = ets:delete(ET),
+ 120000 = dets:info(TabRef, auto_save),
+ ok = dets:close(TabRef),
+
+ {ok, _} = dets:open_file(TabRef, [{access,read} | Args]),
+ {error, {access_mode, Fname}} = dets:init_table(TabRef, init([])),
+ ok = dets:close(TabRef),
+
+ {ok, _} = dets:open_file(TabRef, Args),
+ {error, invalid_objects_list} =
(catch dets:init_table(TabRef, init([[{1,2},bad,{3,4}]]))),
- ?line _ = dets:close(TabRef),
- ?line file:delete(Fname),
+ _ = dets:close(TabRef),
+ file:delete(Fname),
L1 = [[{1,a},{2,b}],[],[{3,c}],[{4,d}],[]],
bulk_init(L1, set, 4, Config, V),
@@ -879,28 +878,28 @@ init_table(Config, V) ->
file:delete(Fname),
%% Initiate a file that contains a lot of objects.
- ?line {ok, _} = dets:open_file(TabRef, [{min_no_slots,10000} | Args]),
- ?line ok = ins(TabRef, 6000),
+ {ok, _} = dets:open_file(TabRef, [{min_no_slots,10000} | Args]),
+ ok = ins(TabRef, 6000),
Fun = init_fun(0, 10000),
- ?line ok = dets:init_table(TabRef, Fun,{format,term}),
- ?line All = sort(get_all_objects(TabRef)),
- ?line FAll = get_all_objects_fast(TabRef),
- ?line true = All =:= sort(FAll),
- ?line true = length(All) =:= 10000,
- ?line ok = dets:close(TabRef),
- ?line file:delete(Fname),
-
- ?line {ok, _} = dets:open_file(TabRef, [{min_no_slots,4000} | Args]),
- ?line ok = ins(TabRef, 6000),
- ?line FileSize1 = dets:info(TabRef, file_size),
+ ok = dets:init_table(TabRef, Fun,{format,term}),
+ All = sort(get_all_objects(TabRef)),
+ FAll = get_all_objects_fast(TabRef),
+ true = All =:= sort(FAll),
+ true = length(All) =:= 10000,
+ ok = dets:close(TabRef),
+ file:delete(Fname),
+
+ {ok, _} = dets:open_file(TabRef, [{min_no_slots,4000} | Args]),
+ ok = ins(TabRef, 6000),
+ FileSize1 = dets:info(TabRef, file_size),
Fun2 = init_fun(0, 4000),
- ?line ok = dets:init_table(TabRef, Fun2),
- ?line FileSize2 = dets:info(TabRef, file_size),
- ?line ok = dets:close(TabRef),
- ?line true = FileSize1 > FileSize2,
- ?line file:delete(Fname),
+ ok = dets:init_table(TabRef, Fun2),
+ FileSize2 = dets:info(TabRef, file_size),
+ ok = dets:close(TabRef),
+ true = FileSize1 > FileSize2,
+ file:delete(Fname),
- ?line check_pps(P0),
+ check_pps(P0),
ok.
bulk_init(Ls, Type, N, Config, V) ->
@@ -909,26 +908,26 @@ bulk_init(Ls, Type, N, Config, V) ->
bulk_init(Ls, Type, N, Est, Config, V) ->
T = init_table_test,
Fname = filename(T, Config),
- ?line file:delete(Fname),
+ file:delete(Fname),
Input = init(Ls),
Args = [{ram_file,false}, {type,Type},{keypos,1},{file,Fname},
{estimated_no_objects, Est},{version,V}],
- ?line {ok, T} = dets:open_file(T, Args),
- ?line ok = dets:init_table(T, Input),
- ?line All = sort(get_all_objects(T)),
- ?line FAll = get_all_objects_fast(T),
- ?line true = All =:= sort(FAll),
- ?line true = length(All) =:= N,
- ?line true = dets:info(T, size) =:= N,
- ?line ok = dets:close(T),
+ {ok, T} = dets:open_file(T, Args),
+ ok = dets:init_table(T, Input),
+ All = sort(get_all_objects(T)),
+ FAll = get_all_objects_fast(T),
+ true = All =:= sort(FAll),
+ true = length(All) =:= N,
+ true = dets:info(T, size) =:= N,
+ ok = dets:close(T),
- ?line {ok, T} = dets:open_file(T, Args),
- ?line All2 = sort(get_all_objects(T)),
- ?line FAll2 = get_all_objects_fast(T),
- ?line true = All =:= All2,
- ?line true = All =:= sort(FAll2),
- ?line ok = dets:close(T),
- ?line file:delete(Fname).
+ {ok, T} = dets:open_file(T, Args),
+ All2 = sort(get_all_objects(T)),
+ FAll2 = get_all_objects_fast(T),
+ true = All =:= All2,
+ true = All =:= sort(FAll2),
+ ok = dets:close(T),
+ file:delete(Fname).
init(L) ->
fun(close) ->
@@ -954,130 +953,130 @@ fast_init_table(Config) ->
V = 9,
TabRef = init_table_test,
Fname = filename(TabRef, Config),
- ?line file:delete(Fname),
+ file:delete(Fname),
P0 = pps(),
Args = [{file,Fname},{version,V},{auto_save,120000}],
Source = init_table_test_source,
SourceFname = filename(Source, Config),
- ?line file:delete(SourceFname),
+ file:delete(SourceFname),
SourceArgs = [{file,SourceFname},{version,V},{auto_save,120000}],
- ?line {ok, Source} = dets:open_file(Source, SourceArgs),
+ {ok, Source} = dets:open_file(Source, SourceArgs),
- ?line {ok, _} = dets:open_file(TabRef, Args),
- ?line {'EXIT', _} =
+ {ok, _} = dets:open_file(TabRef, Args),
+ {'EXIT', _} =
(catch dets:init_table(TabRef, fun(foo) -> bar end, {format,bchunk})),
dets:close(TabRef),
- ?line {ok, _} = dets:open_file(TabRef, Args),
- ?line {'EXIT', _} = (catch dets:init_table(TabRef, fun() -> foo end,
+ {ok, _} = dets:open_file(TabRef, Args),
+ {'EXIT', _} = (catch dets:init_table(TabRef, fun() -> foo end,
{format,bchunk})),
dets:close(TabRef),
- ?line {ok, _} = dets:open_file(TabRef, Args),
- ?line {'EXIT', {badarg, _}} =
+ {ok, _} = dets:open_file(TabRef, Args),
+ {'EXIT', {badarg, _}} =
(catch dets:init_table(TabRef, nofun, {format,bchunk})),
dets:close(TabRef),
- ?line {ok, _} = dets:open_file(TabRef, Args),
- ?line away = (catch dets:init_table(TabRef, fun(_) -> throw(away) end,
+ {ok, _} = dets:open_file(TabRef, Args),
+ away = (catch dets:init_table(TabRef, fun(_) -> throw(away) end,
{format,bchunk})),
dets:close(TabRef),
- ?line {ok, _} = dets:open_file(TabRef, Args),
- ?line {error, {init_fun, fopp}} =
+ {ok, _} = dets:open_file(TabRef, Args),
+ {error, {init_fun, fopp}} =
dets:init_table(TabRef, fun(read) -> fopp end, {format,bchunk}),
dets:close(TabRef),
- ?line {ok, _} = dets:open_file(TabRef, Args),
- ?line dets:safe_fixtable(TabRef, true),
- ?line {error, {fixed_table, TabRef}} =
+ {ok, _} = dets:open_file(TabRef, Args),
+ dets:safe_fixtable(TabRef, true),
+ {error, {fixed_table, TabRef}} =
dets:init_table(TabRef, init([]), {format,bchunk}),
- ?line dets:safe_fixtable(TabRef, false),
- ?line ok = dets:close(TabRef),
+ dets:safe_fixtable(TabRef, false),
+ ok = dets:close(TabRef),
- ?line {ok, _} = dets:open_file(TabRef, [{access,read} | Args]),
- ?line {error, {access_mode, Fname}} =
+ {ok, _} = dets:open_file(TabRef, [{access,read} | Args]),
+ {error, {access_mode, Fname}} =
dets:init_table(TabRef, init([]), {format,bchunk}),
- ?line ok = dets:close(TabRef),
+ ok = dets:close(TabRef),
- ?line {ok, _} = dets:open_file(TabRef, Args),
- ?line {error, {init_fun,{1,2}}} =
+ {ok, _} = dets:open_file(TabRef, Args),
+ {error, {init_fun,{1,2}}} =
dets:init_table(TabRef, init([[{1,2},bad,{3,4}]]), {format,bchunk}),
- ?line _ = dets:close(TabRef),
- ?line file:delete(Fname),
+ _ = dets:close(TabRef),
+ file:delete(Fname),
- ?line {ok, _} = dets:open_file(TabRef, Args),
- ?line {error, {init_fun, end_of_input}} =
+ {ok, _} = dets:open_file(TabRef, Args),
+ {error, {init_fun, end_of_input}} =
dets:init_table(TabRef, init([]),{format,bchunk}),
- ?line _ = dets:close(TabRef),
- ?line file:delete(Fname),
+ _ = dets:close(TabRef),
+ file:delete(Fname),
- ?line {ok, _} = dets:open_file(TabRef, Args),
- ?line {'EXIT', {badarg, _}} =
+ {ok, _} = dets:open_file(TabRef, Args),
+ {'EXIT', {badarg, _}} =
(catch dets:init_table(TabRef, init([]),{format,foppla})),
- ?line _ = dets:close(TabRef),
- ?line file:delete(Fname),
+ _ = dets:close(TabRef),
+ file:delete(Fname),
- ?line {ok, _} = dets:open_file(TabRef, Args),
- ?line ok = ins(TabRef, 100),
+ {ok, _} = dets:open_file(TabRef, Args),
+ ok = ins(TabRef, 100),
- ?line [BParms | Objs] = collect_bchunk(TabRef, init_bchunk(TabRef)),
- ?line Parms = binary_to_term(BParms),
- ?line {error, {init_fun, <<"foobar">>}} =
+ [BParms | Objs] = collect_bchunk(TabRef, init_bchunk(TabRef)),
+ Parms = binary_to_term(BParms),
+ {error, {init_fun, <<"foobar">>}} =
dets:init_table(TabRef, init([[<<"foobar">>]]),{format,bchunk}),
- ?line _ = dets:close(TabRef),
- ?line file:delete(Fname),
+ _ = dets:close(TabRef),
+ file:delete(Fname),
- ?line {ok, _} = dets:open_file(TabRef, Args),
- ?line Parms1 = setelement(1, Parms, foobar),
+ {ok, _} = dets:open_file(TabRef, Args),
+ Parms1 = setelement(1, Parms, foobar),
BParms1 = term_to_binary(Parms1),
- ?line {error, {init_fun, BParms1}} =
+ {error, {init_fun, BParms1}} =
dets:init_table(TabRef, init([[BParms1 | Objs]]),{format,bchunk}),
- ?line _ = dets:close(TabRef),
- ?line file:delete(Fname),
+ _ = dets:close(TabRef),
+ file:delete(Fname),
- ?line {ok, _} = dets:open_file(TabRef, Args),
+ {ok, _} = dets:open_file(TabRef, Args),
[{Sz1,No1} | NoColls17] = element(tuple_size(Parms), Parms),
Parms2 = setelement(tuple_size(Parms), Parms, [{Sz1,No1+1} | NoColls17]),
BParms2 = term_to_binary(Parms2),
- ?line {error, invalid_objects_list} =
+ {error, invalid_objects_list} =
dets:init_table(TabRef, init([[BParms2 | Objs]]),{format,bchunk}),
- ?line _ = dets:close(TabRef),
- ?line file:delete(Fname),
+ _ = dets:close(TabRef),
+ file:delete(Fname),
- ?line {ok, _} = dets:open_file(TabRef, Args),
- ?line [{LSize1,Slot1,Obj1} | ObjsRest] = Objs,
+ {ok, _} = dets:open_file(TabRef, Args),
+ [{LSize1,Slot1,Obj1} | ObjsRest] = Objs,
- ?line BadSize = byte_size(Obj1)-1,
- ?line <<BadSizeObj:BadSize/binary,_:1/binary>> = Obj1,
- ?line BadObjs = [{LSize1,Slot1,BadSizeObj} | ObjsRest],
- ?line {error, invalid_objects_list} =
+ BadSize = byte_size(Obj1)-1,
+ <<BadSizeObj:BadSize/binary,_:1/binary>> = Obj1,
+ BadObjs = [{LSize1,Slot1,BadSizeObj} | ObjsRest],
+ {error, invalid_objects_list} =
dets:init_table(TabRef, init([[BParms | BadObjs]]),{format,bchunk}),
- ?line _ = dets:close(TabRef),
- ?line file:delete(Fname),
-
- ?line {ok, _} = dets:open_file(TabRef, Args),
- ?line <<Size:32,BigObj0/binary>> = list_to_binary(lists:duplicate(16,Obj1)),
- ?line BigObj = <<(Size*16):32,BigObj0/binary>>,
- ?line BadColl = [BParms, {LSize1+4,Slot1,BigObj} | ObjsRest],
- ?line {error, invalid_objects_list} =
+ _ = dets:close(TabRef),
+ file:delete(Fname),
+
+ {ok, _} = dets:open_file(TabRef, Args),
+ <<Size:32,BigObj0/binary>> = list_to_binary(lists:duplicate(16,Obj1)),
+ BigObj = <<(Size*16):32,BigObj0/binary>>,
+ BadColl = [BParms, {LSize1+4,Slot1,BigObj} | ObjsRest],
+ {error, invalid_objects_list} =
dets:init_table(TabRef, init([BadColl]),{format,bchunk}),
- ?line _ = dets:close(TabRef),
- ?line file:delete(Fname),
+ _ = dets:close(TabRef),
+ file:delete(Fname),
- ?line {ok, _} = dets:open_file(TabRef, Args),
+ {ok, _} = dets:open_file(TabRef, Args),
BadObj = <<"foobar">>,
- ?line {error, invalid_objects_list} =
+ {error, invalid_objects_list} =
dets:init_table(TabRef, init([[BParms, BadObj]]),{format,bchunk}),
- ?line _ = dets:close(TabRef),
- ?line file:delete(Fname),
+ _ = dets:close(TabRef),
+ file:delete(Fname),
- ?line {ok, _} = dets:open_file(TabRef, [{type,bag} | Args]),
- ?line {error, {init_fun, _}} =
+ {ok, _} = dets:open_file(TabRef, [{type,bag} | Args]),
+ {error, {init_fun, _}} =
dets:init_table(TabRef, init([[BParms]]),{format,bchunk}),
- ?line _ = dets:close(TabRef),
- ?line file:delete(Fname),
+ _ = dets:close(TabRef),
+ file:delete(Fname),
- ?line ok = dets:close(Source),
- ?line file:delete(SourceFname),
+ ok = dets:close(Source),
+ file:delete(SourceFname),
L1 = [{1,a},{2,b},{3,c},{4,d}],
fast_bulk_init(L1, set, 4, 4, Config, V),
@@ -1090,91 +1089,91 @@ fast_init_table(Config) ->
file:delete(Fname),
%% Initiate a file that contains a lot of objects.
- ?line {ok, _} = dets:open_file(Source, [{min_no_slots,10000} | SourceArgs]),
+ {ok, _} = dets:open_file(Source, [{min_no_slots,10000} | SourceArgs]),
Fun1 = init_fun(0, 10000),
- ?line ok = dets:init_table(Source, Fun1, {format,term}),
+ ok = dets:init_table(Source, Fun1, {format,term}),
- ?line {ok, _} = dets:open_file(TabRef, [{min_no_slots,10000} | Args]),
- ?line ok = ins(TabRef, 6000),
+ {ok, _} = dets:open_file(TabRef, [{min_no_slots,10000} | Args]),
+ ok = ins(TabRef, 6000),
Fun2 = init_bchunk(Source),
- ?line true =
+ true =
dets:is_compatible_bchunk_format(TabRef,
dets:info(Source, bchunk_format)),
- ?line false = dets:is_compatible_bchunk_format(TabRef, <<"foobar">>),
- ?line ok = dets:init_table(TabRef, Fun2, {format, bchunk}),
- ?line ok = dets:close(Source),
- ?line file:delete(SourceFname),
- ?line All = sort(get_all_objects(TabRef)),
- ?line FAll = get_all_objects_fast(TabRef),
- ?line true = All =:= sort(FAll),
- ?line true = length(All) =:= 10000,
- ?line ok = dets:close(TabRef),
- ?line file:delete(Fname),
+ false = dets:is_compatible_bchunk_format(TabRef, <<"foobar">>),
+ ok = dets:init_table(TabRef, Fun2, {format, bchunk}),
+ ok = dets:close(Source),
+ file:delete(SourceFname),
+ All = sort(get_all_objects(TabRef)),
+ FAll = get_all_objects_fast(TabRef),
+ true = All =:= sort(FAll),
+ true = length(All) =:= 10000,
+ ok = dets:close(TabRef),
+ file:delete(Fname),
%% Initiate inserts fewer objects than the table contains.
- ?line {ok, _} = dets:open_file(Source, [{min_no_slots,1000} | SourceArgs]),
- ?line ok = ins(Source, 4000),
+ {ok, _} = dets:open_file(Source, [{min_no_slots,1000} | SourceArgs]),
+ ok = ins(Source, 4000),
- ?line {ok, _} = dets:open_file(TabRef, [{min_no_slots,1000} | Args]),
- ?line ok = ins(TabRef, 6000),
- ?line FileSize1 = dets:info(TabRef, file_size),
+ {ok, _} = dets:open_file(TabRef, [{min_no_slots,1000} | Args]),
+ ok = ins(TabRef, 6000),
+ FileSize1 = dets:info(TabRef, file_size),
Fun4 = init_bchunk(Source),
- ?line ok = dets:init_table(TabRef, Fun4, {format, bchunk}),
- ?line ok = dets:close(Source),
- ?line file:delete(SourceFname),
- ?line FileSize2 = dets:info(TabRef, file_size),
- ?line All_2 = sort(get_all_objects(TabRef)),
- ?line FAll_2 = get_all_objects_fast(TabRef),
- ?line true = All_2 =:= sort(FAll_2),
- ?line true = length(All_2) =:= 4000,
- ?line ok = dets:close(TabRef),
- ?line true = FileSize1 > FileSize2,
+ ok = dets:init_table(TabRef, Fun4, {format, bchunk}),
+ ok = dets:close(Source),
+ file:delete(SourceFname),
+ FileSize2 = dets:info(TabRef, file_size),
+ All_2 = sort(get_all_objects(TabRef)),
+ FAll_2 = get_all_objects_fast(TabRef),
+ true = All_2 =:= sort(FAll_2),
+ true = length(All_2) =:= 4000,
+ ok = dets:close(TabRef),
+ true = FileSize1 > FileSize2,
%% Bchunk and fixed table.
- ?line {ok, _} = dets:open_file(TabRef, Args),
- ?line NoItems = dets:info(TabRef, no_objects),
- ?line AllObjects1 = sort(get_all_objects_fast(TabRef)),
- ?line dets:safe_fixtable(TabRef, true),
- ?line true = dets:info(TabRef, fixed),
- ?line Cont1 = init_bchunk(TabRef),
- ?line NoDel =
+ {ok, _} = dets:open_file(TabRef, Args),
+ NoItems = dets:info(TabRef, no_objects),
+ AllObjects1 = sort(get_all_objects_fast(TabRef)),
+ dets:safe_fixtable(TabRef, true),
+ true = dets:info(TabRef, fixed),
+ Cont1 = init_bchunk(TabRef),
+ NoDel =
dets:select_delete(TabRef, [{{'_',{item,'_','_'}},[],[true]}]),
- ?line true = (NoDel > 0),
- ?line AllObjects2 = sort(get_all_objects_fast(TabRef)),
- ?line true = dets:info(TabRef, fixed),
- ?line Cont2 = init_bchunk(TabRef),
- ?line NoItems2 = dets:info(TabRef, no_objects),
- ?line true = (NoItems =:= NoItems2 + NoDel),
- ?line NoDel2 = dets:select_delete(TabRef, [{'_',[],[true]}]),
- ?line true = (NoDel2 > 0),
- ?line AllObjects3 = sort(get_all_objects_fast(TabRef)),
- ?line NoItems3 = dets:info(TabRef, no_objects),
- ?line true = (NoItems3 =:= 0),
- ?line true = dets:info(TabRef, fixed),
- ?line true = (NoItems2 =:= NoItems3 + NoDel2),
- ?line Cont3 = init_bchunk(TabRef),
-
- ?line BinColl1 = collect_bchunk(TabRef, Cont1),
- ?line BinColl2 = collect_bchunk(TabRef, Cont2),
- ?line BinColl3 = collect_bchunk(TabRef, Cont3),
- ?line dets:safe_fixtable(TabRef, false),
- ?line ok = dets:close(TabRef),
- ?line file:delete(Fname),
+ true = (NoDel > 0),
+ AllObjects2 = sort(get_all_objects_fast(TabRef)),
+ true = dets:info(TabRef, fixed),
+ Cont2 = init_bchunk(TabRef),
+ NoItems2 = dets:info(TabRef, no_objects),
+ true = (NoItems =:= NoItems2 + NoDel),
+ NoDel2 = dets:select_delete(TabRef, [{'_',[],[true]}]),
+ true = (NoDel2 > 0),
+ AllObjects3 = sort(get_all_objects_fast(TabRef)),
+ NoItems3 = dets:info(TabRef, no_objects),
+ true = (NoItems3 =:= 0),
+ true = dets:info(TabRef, fixed),
+ true = (NoItems2 =:= NoItems3 + NoDel2),
+ Cont3 = init_bchunk(TabRef),
+
+ BinColl1 = collect_bchunk(TabRef, Cont1),
+ BinColl2 = collect_bchunk(TabRef, Cont2),
+ BinColl3 = collect_bchunk(TabRef, Cont3),
+ dets:safe_fixtable(TabRef, false),
+ ok = dets:close(TabRef),
+ file:delete(Fname),
%% Now check that the above collected binaries are correct.
- ?line {ok, _} = dets:open_file(TabRef, Args),
- ?line ok = dets:init_table(TabRef, init([BinColl1]),{format,bchunk}),
- ?line true = (AllObjects1 =:= sort(get_all_objects_fast(TabRef))),
- ?line true = (length(AllObjects1) =:= dets:info(TabRef, no_objects)),
- ?line ok = dets:init_table(TabRef, init([BinColl2]),{format,bchunk}),
- ?line true = (AllObjects2 =:= sort(get_all_objects_fast(TabRef))),
- ?line true = (length(AllObjects2) =:= dets:info(TabRef, no_objects)),
- ?line ok = dets:init_table(TabRef, init([BinColl3]),{format,bchunk}),
- ?line true = (AllObjects3 =:= sort(get_all_objects_fast(TabRef))),
- ?line true = (length(AllObjects3) =:= dets:info(TabRef, no_objects)),
- ?line ok = dets:close(TabRef),
- ?line file:delete(Fname),
- ?line check_pps(P0),
+ {ok, _} = dets:open_file(TabRef, Args),
+ ok = dets:init_table(TabRef, init([BinColl1]),{format,bchunk}),
+ true = (AllObjects1 =:= sort(get_all_objects_fast(TabRef))),
+ true = (length(AllObjects1) =:= dets:info(TabRef, no_objects)),
+ ok = dets:init_table(TabRef, init([BinColl2]),{format,bchunk}),
+ true = (AllObjects2 =:= sort(get_all_objects_fast(TabRef))),
+ true = (length(AllObjects2) =:= dets:info(TabRef, no_objects)),
+ ok = dets:init_table(TabRef, init([BinColl3]),{format,bchunk}),
+ true = (AllObjects3 =:= sort(get_all_objects_fast(TabRef))),
+ true = (length(AllObjects3) =:= dets:info(TabRef, no_objects)),
+ ok = dets:close(TabRef),
+ file:delete(Fname),
+ check_pps(P0),
ok.
fast_bulk_init(L, Type, N, NoKeys, Config, V) ->
@@ -1183,40 +1182,40 @@ fast_bulk_init(L, Type, N, NoKeys, Config, V) ->
fast_bulk_init(L, Type, N, NoKeys, Est, Config, V) ->
T = init_table_test,
Fname = filename(T, Config),
- ?line file:delete(Fname),
+ file:delete(Fname),
Args0 = [{ram_file,false}, {type,Type},{keypos,1},
{estimated_no_objects, Est},{version,V}],
Args = [{file,Fname} | Args0],
S = init_table_test_source,
SFname = filename(S, Config),
- ?line file:delete(SFname),
+ file:delete(SFname),
SArgs = [{file,SFname} | Args0],
- ?line {ok, S} = dets:open_file(S, SArgs),
- ?line ok = dets:insert(S, L),
+ {ok, S} = dets:open_file(S, SArgs),
+ ok = dets:insert(S, L),
Input = init_bchunk(S),
- ?line {ok, T} = dets:open_file(T, Args),
- ?line ok = dets:init_table(T, Input, [{format,bchunk}]),
- ?line All = sort(get_all_objects(T)),
- ?line FAll = get_all_objects_fast(T),
- ?line true = All =:= sort(FAll),
- ?line true = length(All) =:= N,
- ?line true = dets:info(T, size) =:= N,
- ?line true = dets:info(T, no_keys) =:= NoKeys,
- ?line ok = dets:close(T),
+ {ok, T} = dets:open_file(T, Args),
+ ok = dets:init_table(T, Input, [{format,bchunk}]),
+ All = sort(get_all_objects(T)),
+ FAll = get_all_objects_fast(T),
+ true = All =:= sort(FAll),
+ true = length(All) =:= N,
+ true = dets:info(T, size) =:= N,
+ true = dets:info(T, no_keys) =:= NoKeys,
+ ok = dets:close(T),
- ?line {ok, T} = dets:open_file(T, Args),
- ?line All2 = sort(get_all_objects(T)),
- ?line FAll2 = get_all_objects_fast(T),
- ?line true = All =:= All2,
- ?line true = All =:= sort(FAll2),
- ?line ok = dets:close(T),
- ?line file:delete(Fname),
-
- ?line ok = dets:close(S),
- ?line file:delete(SFname),
+ {ok, T} = dets:open_file(T, Args),
+ All2 = sort(get_all_objects(T)),
+ FAll2 = get_all_objects_fast(T),
+ true = All =:= All2,
+ true = All =:= sort(FAll2),
+ ok = dets:close(T),
+ file:delete(Fname),
+
+ ok = dets:close(S),
+ file:delete(SFname),
ok.
init_bchunk(T) ->
@@ -1268,94 +1267,94 @@ repair_v9(Config) when is_list(Config) ->
%% Convert from format 9 to format 8.
T = convert_98,
Fname = filename(T, Config),
- ?line file:delete(Fname),
- ?line {ok, _} = dets:open_file(T, [{file,Fname},{version,9},
+ file:delete(Fname),
+ {ok, _} = dets:open_file(T, [{file,Fname},{version,9},
{type,duplicate_bag}]),
- ?line 9 = dets:info(T, version),
- ?line true = is_binary(dets:info(T, bchunk_format)),
- ?line ok = dets:insert(T, [{1,a},{2,b},{1,c},{2,c},{1,c},{2,a},{1,b}]),
- ?line dets:close(T),
- ?line {error, {version_mismatch, _}} =
+ 9 = dets:info(T, version),
+ true = is_binary(dets:info(T, bchunk_format)),
+ ok = dets:insert(T, [{1,a},{2,b},{1,c},{2,c},{1,c},{2,a},{1,b}]),
+ dets:close(T),
+ {error, {version_mismatch, _}} =
dets:open_file(T, [{file,Fname},{version,8},{type,duplicate_bag}]),
- ?line {ok, _} = dets:open_file(T, [{file,Fname},{version,8},
+ {ok, _} = dets:open_file(T, [{file,Fname},{version,8},
{type,duplicate_bag},{repair,force}]),
- ?line 8 = dets:info(T, version),
- ?line true = undefined =:= dets:info(T, bchunk_format),
- ?line [{1,a},{1,b},{1,c},{1,c}] = sort(dets:lookup(T, 1)),
- ?line [{2,a},{2,b},{2,c}] = sort(dets:lookup(T, 2)),
- ?line 7 = dets:info(T, no_objects),
- ?line no_keys_test(T),
- ?line _ = histogram(T, silent),
- ?line ok = dets:close(T),
- ?line file:delete(Fname),
+ 8 = dets:info(T, version),
+ true = undefined =:= dets:info(T, bchunk_format),
+ [{1,a},{1,b},{1,c},{1,c}] = sort(dets:lookup(T, 1)),
+ [{2,a},{2,b},{2,c}] = sort(dets:lookup(T, 2)),
+ 7 = dets:info(T, no_objects),
+ no_keys_test(T),
+ _ = histogram(T, silent),
+ ok = dets:close(T),
+ file:delete(Fname),
%% The short lived format 9(a).
%% Not very throughly tested here.
A9 = a9,
- ?line Version9aS = filename:join(?datadir(Config), "version_9a.dets"),
- ?line Version9aT = filename('v9a.dets', Config),
- ?line {ok, _} = file:copy(Version9aS, Version9aT),
- ?line {ok, A9} = dets:open_file(A9, [{file,Version9aT}]),
- ?line undefined = dets:info(A9, bchunk_format),
- ?line [{1,a},{2,b},{3,c}] = sort(dets:match_object(A9, '_')),
- ?line ok = dets:insert(A9, {4,d}),
- ?line ok = dets:close(A9),
- ?line {ok, A9} = dets:open_file(A9, [{file,Version9aT}]),
- ?line {error, old_version} = dets:bchunk(A9, start),
- ?line ok = dets:close(A9),
- ?line io:format("Expect forced repair:~n"),
- ?line {ok, A9} = dets:open_file(A9, [{file,Version9aT},{repair,force}]),
- ?line {_, _} = dets:bchunk(A9, start),
- ?line ok = dets:close(A9),
- ?line file:delete(Version9aT),
+ Version9aS = filename:join(?datadir(Config), "version_9a.dets"),
+ Version9aT = filename('v9a.dets', Config),
+ {ok, _} = file:copy(Version9aS, Version9aT),
+ {ok, A9} = dets:open_file(A9, [{file,Version9aT}]),
+ undefined = dets:info(A9, bchunk_format),
+ [{1,a},{2,b},{3,c}] = sort(dets:match_object(A9, '_')),
+ ok = dets:insert(A9, {4,d}),
+ ok = dets:close(A9),
+ {ok, A9} = dets:open_file(A9, [{file,Version9aT}]),
+ {error, old_version} = dets:bchunk(A9, start),
+ ok = dets:close(A9),
+ io:format("Expect forced repair:~n"),
+ {ok, A9} = dets:open_file(A9, [{file,Version9aT},{repair,force}]),
+ {_, _} = dets:bchunk(A9, start),
+ ok = dets:close(A9),
+ file:delete(Version9aT),
repair(Config, 9).
repair(Config, V) ->
TabRef = repair_test,
Fname = filename(TabRef, Config),
- ?line file:delete(Fname),
+ file:delete(Fname),
HeadSize = headsz(V),
P0 = pps(),
- ?line {'EXIT', {badarg, _}} =
+ {'EXIT', {badarg, _}} =
(catch dets:open_file(TabRef, [{min_no_slots,1000},
{max_no_slots,500}])),
- ?line {error,{file_error,hoppla,enoent}} = dets:file_info(hoppla),
- ?line {error,{file_error,Fname,enoent}} =
+ {error,{file_error,hoppla,enoent}} = dets:file_info(hoppla),
+ {error,{file_error,Fname,enoent}} =
dets:open_file(TabRef, [{file, Fname}, {access, read}]),
%% compacting, and some kind of test that free lists are saved OK on file
- ?line {ok, TabRef} = dets:open_file(TabRef, [{file,Fname},{version,V}]),
- ?line 0 = dets:info(TabRef, size),
- ?line ok = ins(TabRef, 30000),
- ?line ok = del(TabRef, 30000, 3),
- ?line ok = dets:close(TabRef),
- ?line {error, {access_mode,Fname}} =
+ {ok, TabRef} = dets:open_file(TabRef, [{file,Fname},{version,V}]),
+ 0 = dets:info(TabRef, size),
+ ok = ins(TabRef, 30000),
+ ok = del(TabRef, 30000, 3),
+ ok = dets:close(TabRef),
+ {error, {access_mode,Fname}} =
dets:open_file(foo, [{file,Fname},{repair,force},{access,read}]),
- ?line {ok, Ref3} = dets:open_file(Fname), % no repair!
- ?line 20000 = dets:info(Ref3, size),
- ?line 20000 = dets:foldl(fun(_, N) -> N+1 end, 0, Ref3),
- ?line 20000 = count_objects_quite_fast(Ref3), % actually a test of match
- ?line no_keys_test(Ref3),
- ?line ok = dets:close(Ref3),
+ {ok, Ref3} = dets:open_file(Fname), % no repair!
+ 20000 = dets:info(Ref3, size),
+ 20000 = dets:foldl(fun(_, N) -> N+1 end, 0, Ref3),
+ 20000 = count_objects_quite_fast(Ref3), % actually a test of match
+ no_keys_test(Ref3),
+ ok = dets:close(Ref3),
if
V =:= 8 ->
- ?line {ok, TabRef} = dets:open_file(TabRef,
+ {ok, TabRef} = dets:open_file(TabRef,
[{file, Fname},{version,V},{access,read}]),
- ?line ok = dets:close(TabRef),
- ?line io:format("Expect compacting repair:~n"),
- ?line {ok, TabRef} = dets:open_file(TabRef,
+ ok = dets:close(TabRef),
+ io:format("Expect compacting repair:~n"),
+ {ok, TabRef} = dets:open_file(TabRef,
[{file, Fname},{version,V}]),
- ?line 20000 = dets:info(TabRef, size),
- ?line _ = histogram(TabRef, silent),
- ?line ok = dets:close(TabRef);
+ 20000 = dets:info(TabRef, size),
+ _ = histogram(TabRef, silent),
+ ok = dets:close(TabRef);
true ->
ok
end,
- ?line {error,{keypos_mismatch,Fname}} =
+ {error,{keypos_mismatch,Fname}} =
dets:open_file(TabRef, [{file, Fname},{keypos,17}]),
- ?line {error,{type_mismatch,Fname}} =
+ {error,{type_mismatch,Fname}} =
dets:open_file(TabRef, [{file, Fname},{type,duplicate_bag}]),
%% make one of the temporary files unwritable
@@ -1364,257 +1363,257 @@ repair(Config, V) ->
Fname ++ ".TMP.10000";
true -> Fname ++ ".TMP.1"
end,
- ?line file:delete(TmpFile),
- ?line {ok, TmpFd} = file:open(TmpFile, [read,write]),
- ?line ok = file:close(TmpFd),
- ?line unwritable(TmpFile),
- ?line {error,{file_error,TmpFile,eacces}} = dets:fsck(Fname, V),
- ?line {ok, _} = dets:open_file(TabRef,
- [{repair,false},{file, Fname},{version,V}]),
- ?line 20000 = length(get_all_objects(TabRef)),
- ?line _ = histogram(TabRef, silent),
- ?line 20000 = length(get_all_objects_fast(TabRef)),
- ?line ok = dets:close(TabRef),
- ?line writable(TmpFile),
- ?line file:delete(TmpFile),
-
- ?line truncate(Fname, HeadSize + 10),
- ?line {error,{not_closed, Fname}} =
+ file:delete(TmpFile),
+ {ok, TmpFd} = file:open(TmpFile, [read,write]),
+ ok = file:close(TmpFd),
+ unwritable(TmpFile),
+ {error,{file_error,TmpFile,eacces}} = dets:fsck(Fname, V),
+ {ok, _} = dets:open_file(TabRef,
+ [{repair,false},{file, Fname},{version,V}]),
+ 20000 = length(get_all_objects(TabRef)),
+ _ = histogram(TabRef, silent),
+ 20000 = length(get_all_objects_fast(TabRef)),
+ ok = dets:close(TabRef),
+ writable(TmpFile),
+ file:delete(TmpFile),
+
+ truncate(Fname, HeadSize + 10),
+ {error,{not_closed, Fname}} =
dets:open_file(TabRef, [{file, Fname}, {access, read}]),
- ?line {error,{not_closed, Fname}} =
+ {error,{not_closed, Fname}} =
dets:open_file(TabRef, [{file, Fname}, {access, read},
{repair,force}]),
- ?line {error,{needs_repair, Fname}} =
+ {error,{needs_repair, Fname}} =
dets:open_file(TabRef, [{file, Fname}, {repair, false}]),
- ?line file:delete(Fname),
+ file:delete(Fname),
%% truncated file header
- ?line {ok, TabRef} = dets:open_file(TabRef, [{file,Fname},{version,V}]),
- ?line ok = ins(TabRef, 100),
- ?line ok = dets:close(TabRef),
- ?line truncate(Fname, HeadSize - 10),
+ {ok, TabRef} = dets:open_file(TabRef, [{file,Fname},{version,V}]),
+ ok = ins(TabRef, 100),
+ ok = dets:close(TabRef),
+ truncate(Fname, HeadSize - 10),
%% a new file is created ('tooshort')
- ?line {ok, TabRef} = dets:open_file(TabRef,
- [{file,Fname},{version,V},
- {min_no_slots,1000},
- {max_no_slots,1000000}]),
+ {ok, TabRef} = dets:open_file(TabRef,
+ [{file,Fname},{version,V},
+ {min_no_slots,1000},
+ {max_no_slots,1000000}]),
case dets:info(TabRef, no_slots) of
undefined -> ok;
{Min1,Slot1,Max1} ->
- ?line true = Min1 =< Slot1, true = Slot1 =< Max1,
- ?line true = 1000 < Min1, true = 1000+256 > Min1,
- ?line true = 1000000 < Max1, true = (1 bsl 20)+256 > Max1
+ true = Min1 =< Slot1, true = Slot1 =< Max1,
+ true = 1000 < Min1, true = 1000+256 > Min1,
+ true = 1000000 < Max1, true = (1 bsl 20)+256 > Max1
end,
- ?line 0 = dets:info(TabRef, size),
- ?line no_keys_test(TabRef),
- ?line _ = histogram(TabRef, silent),
- ?line ok = dets:close(TabRef),
- ?line file:delete(Fname),
+ 0 = dets:info(TabRef, size),
+ no_keys_test(TabRef),
+ _ = histogram(TabRef, silent),
+ ok = dets:close(TabRef),
+ file:delete(Fname),
%% version bump (v8)
- ?line Version7S = filename:join(?datadir(Config), "version_r2d.dets"),
- ?line Version7T = filename('v2.dets', Config),
- ?line {ok, _} = file:copy(Version7S, Version7T),
- ?line {error,{version_bump, Version7T}} = dets:open_file(Version7T),
- ?line {error,{version_bump, Version7T}} =
+ Version7S = filename:join(?datadir(Config), "version_r2d.dets"),
+ Version7T = filename('v2.dets', Config),
+ {ok, _} = file:copy(Version7S, Version7T),
+ {error,{version_bump, Version7T}} = dets:open_file(Version7T),
+ {error,{version_bump, Version7T}} =
dets:open_file(Version7T, [{file,Version7T},{repair,false}]),
- ?line {error,{version_bump, Version7T}} =
+ {error,{version_bump, Version7T}} =
dets:open_file(Version7T, [{file, Version7T}, {access, read}]),
- ?line io:format("Expect upgrade:~n"),
- ?line {ok, _} = dets:open_file(Version7T,
+ io:format("Expect upgrade:~n"),
+ {ok, _} = dets:open_file(Version7T,
[{file, Version7T},{version, V}]),
- ?line [{1,a},{2,b}] = sort(get_all_objects(Version7T)),
- ?line [{1,a},{2,b}] = sort(get_all_objects_fast(Version7T)),
+ [{1,a},{2,b}] = sort(get_all_objects(Version7T)),
+ [{1,a},{2,b}] = sort(get_all_objects_fast(Version7T)),
Phash = if
V =:= 8 -> phash;
true -> phash2
end,
- ?line Phash = dets:info(Version7T, hash),
- ?line _ = histogram(Version7T, silent),
- ?line ok = dets:close(Version7T),
- ?line {ok, _} = dets:open_file(Version7T, [{file, Version7T}]),
- ?line Phash = dets:info(Version7T, hash),
- ?line ok = dets:close(Version7T),
- ?line file:delete(Version7T),
+ Phash = dets:info(Version7T, hash),
+ _ = histogram(Version7T, silent),
+ ok = dets:close(Version7T),
+ {ok, _} = dets:open_file(Version7T, [{file, Version7T}]),
+ Phash = dets:info(Version7T, hash),
+ ok = dets:close(Version7T),
+ file:delete(Version7T),
%% converting free lists
- ?line Version8aS = filename:join(?datadir(Config), "version_r3b02.dets"),
- ?line Version8aT = filename('v3.dets', Config),
- ?line {ok, _} = file:copy(Version8aS, Version8aT),
+ Version8aS = filename:join(?datadir(Config), "version_r3b02.dets"),
+ Version8aT = filename('v3.dets', Config),
+ {ok, _} = file:copy(Version8aS, Version8aT),
%% min_no_slots and max_no_slots are ignored - no repair is taking place
- ?line {ok, _} = dets:open_file(version_8a,
+ {ok, _} = dets:open_file(version_8a,
[{file, Version8aT},{min_no_slots,1000},
{max_no_slots,100000}]),
- ?line [{1,b},{2,a},{a,1},{b,2}] = sort(get_all_objects(version_8a)),
- ?line [{1,b},{2,a},{a,1},{b,2}] = sort(get_all_objects_fast(version_8a)),
- ?line ok = ins(version_8a, 1000),
- ?line 1002 = dets:info(version_8a, size),
- ?line no_keys_test(version_8a),
- ?line All8a = sort(get_all_objects(version_8a)),
- ?line 1002 = length(All8a),
- ?line FAll8a = sort(get_all_objects_fast(version_8a)),
- ?line true = sort(All8a) =:= sort(FAll8a),
- ?line ok = del(version_8a, 300, 3),
- ?line 902 = dets:info(version_8a, size),
- ?line no_keys_test(version_8a),
- ?line All8a2 = sort(get_all_objects(version_8a)),
- ?line 902 = length(All8a2),
- ?line FAll8a2 = sort(get_all_objects_fast(version_8a)),
- ?line true = sort(All8a2) =:= sort(FAll8a2),
- ?line _ = histogram(version_8a, silent),
- ?line ok = dets:close(version_8a),
- ?line file:delete(Version8aT),
+ [{1,b},{2,a},{a,1},{b,2}] = sort(get_all_objects(version_8a)),
+ [{1,b},{2,a},{a,1},{b,2}] = sort(get_all_objects_fast(version_8a)),
+ ok = ins(version_8a, 1000),
+ 1002 = dets:info(version_8a, size),
+ no_keys_test(version_8a),
+ All8a = sort(get_all_objects(version_8a)),
+ 1002 = length(All8a),
+ FAll8a = sort(get_all_objects_fast(version_8a)),
+ true = sort(All8a) =:= sort(FAll8a),
+ ok = del(version_8a, 300, 3),
+ 902 = dets:info(version_8a, size),
+ no_keys_test(version_8a),
+ All8a2 = sort(get_all_objects(version_8a)),
+ 902 = length(All8a2),
+ FAll8a2 = sort(get_all_objects_fast(version_8a)),
+ true = sort(All8a2) =:= sort(FAll8a2),
+ _ = histogram(version_8a, silent),
+ ok = dets:close(version_8a),
+ file:delete(Version8aT),
%% will fail unless the slots are properly sorted when repairing (v8)
BArgs = [{file, Fname},{type,duplicate_bag},
{delayed_write,{3000,10000}},{version,V}],
- ?line {ok, TabRef} = dets:open_file(TabRef, BArgs),
+ {ok, TabRef} = dets:open_file(TabRef, BArgs),
Seq = seq(1, 500),
Small = map(fun(X) -> {X,X} end, Seq),
Big = map(fun(X) -> erlang:make_tuple(20, X) end, Seq),
- ?line ok = dets:insert(TabRef, Small),
- ?line ok = dets:insert(TabRef, Big),
- ?line ok = dets:insert(TabRef, Small),
- ?line ok = dets:insert(TabRef, Big),
- ?line All = sort(safe_get_all_objects(TabRef)),
- ?line ok = dets:close(TabRef),
- ?line io:format("Expect forced repair:~n"),
- ?line {ok, _} =
+ ok = dets:insert(TabRef, Small),
+ ok = dets:insert(TabRef, Big),
+ ok = dets:insert(TabRef, Small),
+ ok = dets:insert(TabRef, Big),
+ All = sort(safe_get_all_objects(TabRef)),
+ ok = dets:close(TabRef),
+ io:format("Expect forced repair:~n"),
+ {ok, _} =
dets:open_file(TabRef, [{repair,force},{min_no_slots,2000} | BArgs]),
if
V =:= 9 ->
- ?line {MinNoSlots,_,MaxNoSlots} = dets:info(TabRef, no_slots),
- ?line ok = dets:close(TabRef),
- ?line io:format("Expect compaction:~n"),
- ?line {ok, _} =
+ {MinNoSlots,_,MaxNoSlots} = dets:info(TabRef, no_slots),
+ ok = dets:close(TabRef),
+ io:format("Expect compaction:~n"),
+ {ok, _} =
dets:open_file(TabRef, [{repair,force},
{min_no_slots,MinNoSlots},
{max_no_slots,MaxNoSlots} | BArgs]);
true ->
ok
end,
- ?line All2 = get_all_objects(TabRef),
- ?line true = All =:= sort(All2),
- ?line FAll2 = get_all_objects_fast(TabRef),
- ?line true = All =:= sort(FAll2),
- ?line true = length(All) =:= dets:info(TabRef, size),
- ?line no_keys_test(TabRef),
+ All2 = get_all_objects(TabRef),
+ true = All =:= sort(All2),
+ FAll2 = get_all_objects_fast(TabRef),
+ true = All =:= sort(FAll2),
+ true = length(All) =:= dets:info(TabRef, size),
+ no_keys_test(TabRef),
Fun = fun(X) -> 4 = length(dets:lookup(TabRef, X)) end,
- ?line foreach(Fun, Seq),
- ?line _ = histogram(TabRef, silent),
- ?line ok = dets:close(TabRef),
- ?line file:delete(Fname),
+ foreach(Fun, Seq),
+ _ = histogram(TabRef, silent),
+ ok = dets:close(TabRef),
+ file:delete(Fname),
%% object bigger than segments, the "hole" is taken care of
- ?line {ok, TabRef} = dets:open_file(TabRef, [{file, Fname},{version,V}]),
+ {ok, TabRef} = dets:open_file(TabRef, [{file, Fname},{version,V}]),
Tuple = erlang:make_tuple(1000, foobar), % > 2 kB
- ?line ok = dets:insert(TabRef, Tuple),
+ ok = dets:insert(TabRef, Tuple),
%% at least one full segment (objects smaller than 2 kB):
- ?line ins(TabRef, 2000),
- ?line ok = dets:close(TabRef),
+ ins(TabRef, 2000),
+ ok = dets:close(TabRef),
if
V =:= 8 ->
%% first estimated number of objects is wrong, repair once more
- ?line {ok, Fd} = file:open(Fname, [read,write]),
+ {ok, Fd} = file:open(Fname, [read,write]),
NoPos = HeadSize - 8, % no_objects
- ?line file:pwrite(Fd, NoPos, <<0:32>>), % NoItems
+ file:pwrite(Fd, NoPos, <<0:32>>), % NoItems
ok = file:close(Fd),
- ?line dets:fsck(Fname, V),
- ?line {ok, _} =
+ dets:fsck(Fname, V),
+ {ok, _} =
dets:open_file(TabRef,
[{repair,false},{file, Fname},{version,V}]),
- ?line 2001 = length(get_all_objects(TabRef)),
- ?line _ = histogram(TabRef, silent),
- ?line 2001 = length(get_all_objects_fast(TabRef)),
- ?line ok = dets:close(TabRef);
+ 2001 = length(get_all_objects(TabRef)),
+ _ = histogram(TabRef, silent),
+ 2001 = length(get_all_objects_fast(TabRef)),
+ ok = dets:close(TabRef);
true ->
ok
end,
- ?line {ok, _} =
+ {ok, _} =
dets:open_file(TabRef,
[{repair,false},{file, Fname},{version,V}]),
- ?line {ok, ObjPos} = dets:where(TabRef, {66,{item,number,66}}),
- ?line ok = dets:close(TabRef),
+ {ok, ObjPos} = dets:where(TabRef, {66,{item,number,66}}),
+ ok = dets:close(TabRef),
%% Damaged object.
Pos = 12, % v9: compaction fails, proper repair follows
crash(Fname, ObjPos+Pos),
- ?line io:format(
+ io:format(
"Expect forced repair (possibly after attempted compaction):~n"),
- ?line {ok, _} =
+ {ok, _} =
dets:open_file(TabRef, [{repair,force},{file, Fname},{version,V}]),
- ?line true = dets:info(TabRef, size) < 2001,
- ?line ok = dets:close(TabRef),
- ?line file:delete(Fname),
+ true = dets:info(TabRef, size) < 2001,
+ ok = dets:close(TabRef),
+ file:delete(Fname),
%% The file is smaller than the padded object.
- ?line {ok, TabRef} = dets:open_file(TabRef, [{file,Fname},{version,V}]),
- ?line ok = dets:insert(TabRef, Tuple),
- ?line ok = dets:close(TabRef),
- ?line io:format("Expect forced repair or compaction:~n"),
- ?line {ok, _} =
+ {ok, TabRef} = dets:open_file(TabRef, [{file,Fname},{version,V}]),
+ ok = dets:insert(TabRef, Tuple),
+ ok = dets:close(TabRef),
+ io:format("Expect forced repair or compaction:~n"),
+ {ok, _} =
dets:open_file(TabRef, [{repair,force},{file, Fname},{version,V}]),
- ?line true = 1 =:= dets:info(TabRef, size),
- ?line ok = dets:close(TabRef),
- ?line file:delete(Fname),
+ true = 1 =:= dets:info(TabRef, size),
+ ok = dets:close(TabRef),
+ file:delete(Fname),
%% Damaged free lists.
- ?line {ok, TabRef} = dets:open_file(TabRef, [{file,Fname},{version,V}]),
- ?line ok = ins(TabRef, 300),
- ?line ok = dets:sync(TabRef),
- ?line ok = del(TabRef, 300, 3),
+ {ok, TabRef} = dets:open_file(TabRef, [{file,Fname},{version,V}]),
+ ok = ins(TabRef, 300),
+ ok = dets:sync(TabRef),
+ ok = del(TabRef, 300, 3),
%% FileSize is approximately where the free lists will be written.
- ?line FileSize = dets:info(TabRef, memory),
- ?line ok = dets:close(TabRef),
+ FileSize = dets:info(TabRef, memory),
+ ok = dets:close(TabRef),
crash(Fname, FileSize+20),
%% Used to return bad_freelists, but that changed in OTP-9622
- ?line {ok, TabRef} =
+ {ok, TabRef} =
dets:open_file(TabRef, [{file,Fname},{version,V}]),
- ?line ok = dets:close(TabRef),
- ?line file:delete(Fname),
+ ok = dets:close(TabRef),
+ file:delete(Fname),
%% File not closed, opening with read and read_write access tried.
- ?line {ok, TabRef} = dets:open_file(TabRef, [{file,Fname},{version,V}]),
- ?line ok = ins(TabRef, 300),
- ?line ok = dets:close(TabRef),
- ?line crash(Fname, ?CLOSED_PROPERLY_POS+3, ?NOT_PROPERLY_CLOSED),
- ?line {error, {not_closed, Fname}} =
+ {ok, TabRef} = dets:open_file(TabRef, [{file,Fname},{version,V}]),
+ ok = ins(TabRef, 300),
+ ok = dets:close(TabRef),
+ crash(Fname, ?CLOSED_PROPERLY_POS+3, ?NOT_PROPERLY_CLOSED),
+ {error, {not_closed, Fname}} =
dets:open_file(foo, [{file,Fname},{version,V},{repair,force},
{access,read}]),
- ?line {error, {not_closed, Fname}} =
+ {error, {not_closed, Fname}} =
dets:open_file(foo, [{file,Fname},{version,V},{repair,true},
{access,read}]),
- ?line io:format("Expect repair:~n"),
- ?line {ok, TabRef} =
+ io:format("Expect repair:~n"),
+ {ok, TabRef} =
dets:open_file(TabRef, [{file,Fname},{version,V},{repair,true},
{access,read_write}]),
- ?line ok = dets:close(TabRef),
- ?line crash(Fname, ?CLOSED_PROPERLY_POS+3, ?NOT_PROPERLY_CLOSED),
- ?line io:format("Expect forced repair:~n"),
- ?line {ok, TabRef} =
+ ok = dets:close(TabRef),
+ crash(Fname, ?CLOSED_PROPERLY_POS+3, ?NOT_PROPERLY_CLOSED),
+ io:format("Expect forced repair:~n"),
+ {ok, TabRef} =
dets:open_file(TabRef, [{file,Fname},{version,V},{repair,force},
{access,read_write}]),
- ?line ok = dets:close(TabRef),
- ?line file:delete(Fname),
+ ok = dets:close(TabRef),
+ file:delete(Fname),
%% The size of an object is huge.
- ?line {ok, TabRef} = dets:open_file(TabRef, [{file,Fname},{version,V}]),
- ?line ok = dets:insert(TabRef, [{1,2,3},{2,3,4}]),
- ?line {ok, ObjPos2} = dets:where(TabRef, {1,2,3}),
- ?line ok = dets:close(TabRef),
+ {ok, TabRef} = dets:open_file(TabRef, [{file,Fname},{version,V}]),
+ ok = dets:insert(TabRef, [{1,2,3},{2,3,4}]),
+ {ok, ObjPos2} = dets:where(TabRef, {1,2,3}),
+ ok = dets:close(TabRef),
ObjPos3 = if
V =:= 8 -> ObjPos2 + 4;
V =:= 9 -> ObjPos2
end,
crash(Fname, ObjPos3, 255),
- ?line io:format("Expect forced repair:~n"),
- ?line {ok, TabRef} =
+ io:format("Expect forced repair:~n"),
+ {ok, TabRef} =
dets:open_file(TabRef, [{file,Fname},{version,V},{repair,force}]),
- ?line ok = dets:close(TabRef),
- ?line file:delete(Fname),
+ ok = dets:close(TabRef),
+ file:delete(Fname),
- ?line check_pps(P0),
+ check_pps(P0),
ok.
hash_v8b_v8c(doc) ->
@@ -1623,77 +1622,77 @@ hash_v8b_v8c(doc) ->
hash_v8b_v8c(suite) ->
[];
hash_v8b_v8c(Config) when is_list(Config) ->
- ?line Source =
+ Source =
filename:join(?datadir(Config), "dets_test_v8b.dets"),
%% Little endian version of old file (there is an endianess bug in
%% the old hash). This is all about version 8 of the dets file format.
P0 = pps(),
- ?line SourceLE =
+ SourceLE =
filename:join(?datadir(Config),
"dets_test_v8b_little_endian.dets"),
- ?line Target1 = filename('oldhash1.dets', Config),
- ?line Target1LE = filename('oldhash1le.dets', Config),
- ?line Target2 = filename('oldhash2.dets', Config),
- ?line {ok, Bin} = file:read_file(Source),
- ?line {ok, BinLE} = file:read_file(SourceLE),
- ?line ok = file:write_file(Target1,Bin),
- ?line ok = file:write_file(Target1LE,BinLE),
- ?line ok = file:write_file(Target2,Bin),
- ?line {ok, d1} = dets:open_file(d1,[{file,Target1}]),
- ?line {ok, d1le} = dets:open_file(d1le,[{file,Target1LE}]),
- ?line {ok, d2} = dets:open_file(d2,[{file,Target2},{repair,force},
+ Target1 = filename('oldhash1.dets', Config),
+ Target1LE = filename('oldhash1le.dets', Config),
+ Target2 = filename('oldhash2.dets', Config),
+ {ok, Bin} = file:read_file(Source),
+ {ok, BinLE} = file:read_file(SourceLE),
+ ok = file:write_file(Target1,Bin),
+ ok = file:write_file(Target1LE,BinLE),
+ ok = file:write_file(Target2,Bin),
+ {ok, d1} = dets:open_file(d1,[{file,Target1}]),
+ {ok, d1le} = dets:open_file(d1le,[{file,Target1LE}]),
+ {ok, d2} = dets:open_file(d2,[{file,Target2},{repair,force},
{version,8}]),
- ?line FF = fun(N,_F,_T) when N > 16#FFFFFFFFFFFFFFFF ->
- ok;
- (N,F,T) ->
- V = integer_to_list(N),
- case dets:lookup(T,N) of
- [{N,V}] ->
- F(N*2,F,T);
- _Error ->
- exit({failed,{lookup,T,N}})
- end
- end,
- ?line Mess = case (catch FF(1,FF,d1)) of
- {'EXIT', {failed, {lookup,_,_}}} ->
- ?line ok = dets:close(d1),
- ?line FF(1,FF,d1le),
- ?line hash = dets:info(d1le,hash),
- ?line dets:insert(d1le,{33333333333,hejsan}),
- ?line [{33333333333,hejsan}] =
- dets:lookup(d1le,33333333333),
- ?line ok = dets:close(d1le),
- ?line {ok, d1le} = dets:open_file(d1le,
- [{file,Target1LE}]),
- ?line [{33333333333,hejsan}] =
- dets:lookup(d1le,33333333333),
- ?line FF(1,FF,d1le),
- ?line ok = dets:close(d1le),
- "Seems to be a little endian machine";
- {'EXIT', Fault} ->
- exit(Fault);
- _ ->
- ?line ok = dets:close(d1le),
- ?line hash = dets:info(d1,hash),
- ?line dets:insert(d1,{33333333333,hejsan}),
- ?line [{33333333333,hejsan}] =
- dets:lookup(d1,33333333333),
- ?line ok = dets:close(d1),
- ?line {ok, d1} = dets:open_file(d1,[{file,Target1}]),
- ?line [{33333333333,hejsan}] =
- dets:lookup(d1,33333333333),
- ?line FF(1,FF,d1),
- ?line ok = dets:close(d1),
- "Seems to be a big endian machine"
- end,
- ?line FF(1,FF,d2),
- ?line phash = dets:info(d2,hash),
- ?line ok = dets:close(d2),
- ?line file:delete(Target1),
- ?line file:delete(Target1LE),
- ?line file:delete(Target2),
- ?line check_pps(P0),
+ FF = fun(N,_F,_T) when N > 16#FFFFFFFFFFFFFFFF ->
+ ok;
+ (N,F,T) ->
+ V = integer_to_list(N),
+ case dets:lookup(T,N) of
+ [{N,V}] ->
+ F(N*2,F,T);
+ _Error ->
+ exit({failed,{lookup,T,N}})
+ end
+ end,
+ Mess = case (catch FF(1,FF,d1)) of
+ {'EXIT', {failed, {lookup,_,_}}} ->
+ ok = dets:close(d1),
+ FF(1,FF,d1le),
+ hash = dets:info(d1le,hash),
+ dets:insert(d1le,{33333333333,hejsan}),
+ [{33333333333,hejsan}] =
+ dets:lookup(d1le,33333333333),
+ ok = dets:close(d1le),
+ {ok, d1le} = dets:open_file(d1le,
+ [{file,Target1LE}]),
+ [{33333333333,hejsan}] =
+ dets:lookup(d1le,33333333333),
+ FF(1,FF,d1le),
+ ok = dets:close(d1le),
+ "Seems to be a little endian machine";
+ {'EXIT', Fault} ->
+ exit(Fault);
+ _ ->
+ ok = dets:close(d1le),
+ hash = dets:info(d1,hash),
+ dets:insert(d1,{33333333333,hejsan}),
+ [{33333333333,hejsan}] =
+ dets:lookup(d1,33333333333),
+ ok = dets:close(d1),
+ {ok, d1} = dets:open_file(d1,[{file,Target1}]),
+ [{33333333333,hejsan}] =
+ dets:lookup(d1,33333333333),
+ FF(1,FF,d1),
+ ok = dets:close(d1),
+ "Seems to be a big endian machine"
+ end,
+ FF(1,FF,d2),
+ phash = dets:info(d2,hash),
+ ok = dets:close(d2),
+ file:delete(Target1),
+ file:delete(Target1LE),
+ file:delete(Target2),
+ check_pps(P0),
{comment, Mess}.
phash(doc) ->
@@ -1704,57 +1703,57 @@ phash(Config) when is_list(Config) ->
T = phash,
Phash_v9bS = filename:join(?datadir(Config), "version_9b_phash.dat"),
Fname = filename('v9b.dets', Config),
- ?line {ok, _} = file:copy(Phash_v9bS, Fname),
+ {ok, _} = file:copy(Phash_v9bS, Fname),
%% Deleting all objects changes the hash function.
%% A feature... (it's for free)
- ?line {ok, T} = dets:open_file(T, [{file, Fname}]),
- ?line phash = dets:info(T, hash),
- ?line dets:delete_all_objects(T),
- ?line phash2 = dets:info(T, hash),
- ?line [] = get_all_objects(T),
- ?line [] = get_all_objects_fast(T),
- ?line ok = dets:close(T),
+ {ok, T} = dets:open_file(T, [{file, Fname}]),
+ phash = dets:info(T, hash),
+ dets:delete_all_objects(T),
+ phash2 = dets:info(T, hash),
+ [] = get_all_objects(T),
+ [] = get_all_objects_fast(T),
+ ok = dets:close(T),
%% The hash function is kept when compacting a table.
- ?line {ok, _} = file:copy(Phash_v9bS, Fname),
- ?line io:format("Expect compaction:~n"),
- ?line {ok, T} = dets:open_file(T, [{file, Fname},{repair,force}]),
- ?line phash = dets:info(T, hash),
- ?line [{1,a},{2,b},{3,c},{4,d},{5,e}] =
+ {ok, _} = file:copy(Phash_v9bS, Fname),
+ io:format("Expect compaction:~n"),
+ {ok, T} = dets:open_file(T, [{file, Fname},{repair,force}]),
+ phash = dets:info(T, hash),
+ [{1,a},{2,b},{3,c},{4,d},{5,e}] =
lists:sort(dets:lookup_keys(T, [1,2,3,4,5])),
- ?line ok = dets:close(T),
+ ok = dets:close(T),
%% The hash function is updated when repairing a table (no cost).
- ?line {ok, _} = file:copy(Phash_v9bS, Fname),
+ {ok, _} = file:copy(Phash_v9bS, Fname),
crash(Fname, ?CLOSED_PROPERLY_POS+3, 0),
- ?line io:format("Expect repair:~n"),
- ?line {ok, T} = dets:open_file(T, [{file, Fname}]),
- ?line phash2 = dets:info(T, hash),
- ?line [{1,a},{2,b},{3,c},{4,d},{5,e}] =
+ io:format("Expect repair:~n"),
+ {ok, T} = dets:open_file(T, [{file, Fname}]),
+ phash2 = dets:info(T, hash),
+ [{1,a},{2,b},{3,c},{4,d},{5,e}] =
lists:sort(dets:lookup_keys(T, [1,2,3,4,5])),
- ?line ok = dets:close(T),
+ ok = dets:close(T),
%% One cannot use the bchunk format when copying between a phash
%% table and a phash2 table. (There is no test for the case an R9
%% (or later) node (using phash2) copies a table to an R8 node
%% (using phash).) See also the comment on HASH_PARMS in dets_v9.erl.
- ?line {ok, _} = file:copy(Phash_v9bS, Fname),
- ?line {ok, T} = dets:open_file(T, [{file, Fname}]),
- ?line Type = dets:info(T, type),
- ?line KeyPos = dets:info(T, keypos),
+ {ok, _} = file:copy(Phash_v9bS, Fname),
+ {ok, T} = dets:open_file(T, [{file, Fname}]),
+ Type = dets:info(T, type),
+ KeyPos = dets:info(T, keypos),
Input = init_bchunk(T),
T2 = phash_table,
Fname2 = filename(T2, Config),
Args = [{type,Type},{keypos,KeyPos},{version,9},{file,Fname2}],
- ?line {ok, T2} = dets:open_file(T2, Args),
- ?line {error, {init_fun, _}} =
+ {ok, T2} = dets:open_file(T2, Args),
+ {error, {init_fun, _}} =
dets:init_table(T2, Input, {format,bchunk}),
- ?line _ = dets:close(T2),
- ?line ok = dets:close(T),
- ?line file:delete(Fname2),
+ _ = dets:close(T2),
+ ok = dets:close(T),
+ file:delete(Fname2),
- ?line file:delete(Fname),
+ file:delete(Fname),
ok.
fold_v8(doc) ->
@@ -1774,50 +1773,50 @@ fold_v9(Config) when is_list(Config) ->
fold(Config, Version) ->
T = test_table,
N = 100,
- ?line Fname = filename(T, Config),
- ?line file:delete(Fname),
+ Fname = filename(T, Config),
+ file:delete(Fname),
P0 = pps(),
Args = [{version, Version}, {file,Fname}, {estimated_no_objects, N}],
- ?line {ok, _} = dets:open_file(T, Args),
+ {ok, _} = dets:open_file(T, Args),
- ?line ok = ins(T, N),
+ ok = ins(T, N),
- ?line Ets = ets:new(to_ets, [public]),
- ?line dets:to_ets(T, Ets),
- ?line true = N =:= ets:info(Ets, size),
- ?line ets:delete(Ets),
+ Ets = ets:new(to_ets, [public]),
+ dets:to_ets(T, Ets),
+ true = N =:= ets:info(Ets, size),
+ ets:delete(Ets),
- ?line Ets2 = ets:new(to_ets, [private]),
- ?line dets:to_ets(T, Ets2),
- ?line true = N =:= ets:info(Ets2, size),
- ?line ets:delete(Ets2),
+ Ets2 = ets:new(to_ets, [private]),
+ dets:to_ets(T, Ets2),
+ true = N =:= ets:info(Ets2, size),
+ ets:delete(Ets2),
- ?line {'EXIT', {badarg, _}} = (catch dets:to_ets(T, not_an_ets_table)),
+ {'EXIT', {badarg, _}} = (catch dets:to_ets(T, not_an_ets_table)),
F0 = fun(X, A) -> [X | A] end,
- ?line true = N =:= length(dets:foldl(F0, [], T)),
- ?line true = N =:= length(dets:foldr(F0, [], T)),
+ true = N =:= length(dets:foldl(F0, [], T)),
+ true = N =:= length(dets:foldr(F0, [], T)),
F1 = fun(_X, _A) -> throw(away) end,
- ?line away = (catch dets:foldl(F1, [], T)),
- ?line away = (catch dets:foldr(F1, [], T)),
+ away = (catch dets:foldl(F1, [], T)),
+ away = (catch dets:foldr(F1, [], T)),
F2 = fun(X, A) -> X + A end,
- ?line {'EXIT', _} = (catch dets:foldl(F2, [], T)),
- ?line {'EXIT', _} = (catch dets:foldr(F2, [], T)),
+ {'EXIT', _} = (catch dets:foldl(F2, [], T)),
+ {'EXIT', _} = (catch dets:foldr(F2, [], T)),
F3 = fun(_X) -> throw(away) end,
- ?line away = (catch dets:traverse(T, F3)),
+ away = (catch dets:traverse(T, F3)),
F4 = fun(X) -> X + 17 end,
- ?line {'EXIT', _} = (catch dets:traverse(T, F4)),
+ {'EXIT', _} = (catch dets:traverse(T, F4)),
- ?line F5 = fun(_X) -> done end,
- ?line done = dets:traverse(T, F5),
+ F5 = fun(_X) -> done end,
+ done = dets:traverse(T, F5),
- ?line {ok, ObjPos} = dets:where(T, {66,{item,number,66}}),
- ?line ok = dets:close(T),
+ {ok, ObjPos} = dets:where(T, {66,{item,number,66}}),
+ ok = dets:close(T),
%% Damaged object.
Pos = if
@@ -1825,15 +1824,15 @@ fold(Config, Version) ->
Version =:= 9 -> 8
end,
crash(Fname, ObjPos+Pos),
- ?line {ok, _} = dets:open_file(T, Args),
- ?line io:format("Expect corrupt table:~n"),
- ?line BadObject1 = dets:foldl(F0, [], T),
- ?line bad_object(BadObject1, Fname),
- ?line BadObject2 = dets:close(T),
- ?line bad_object(BadObject2, Fname),
-
- ?line file:delete(Fname),
- ?line check_pps(P0),
+ {ok, _} = dets:open_file(T, Args),
+ io:format("Expect corrupt table:~n"),
+ BadObject1 = dets:foldl(F0, [], T),
+ bad_object(BadObject1, Fname),
+ BadObject2 = dets:close(T),
+ bad_object(BadObject2, Fname),
+
+ file:delete(Fname),
+ check_pps(P0),
ok.
fixtable_v8(doc) ->
@@ -1852,64 +1851,64 @@ fixtable_v9(Config) when is_list(Config) ->
fixtable(Config, Version) when is_list(Config) ->
T = fixtable,
- ?line Fname = filename(fixtable, Config),
- ?line file:delete(Fname),
+ Fname = filename(fixtable, Config),
+ file:delete(Fname),
Args = [{version,Version},{file,Fname}],
P0 = pps(),
- ?line {ok, _} = dets:open_file(T, Args),
+ {ok, _} = dets:open_file(T, Args),
%% badarg
- ?line check_badarg(catch dets:safe_fixtable(no_table,true),
+ check_badarg(catch dets:safe_fixtable(no_table,true),
dets, safe_fixtable, [no_table,true]),
- ?line check_badarg(catch dets:safe_fixtable(T,undefined),
+ check_badarg(catch dets:safe_fixtable(T,undefined),
dets, safe_fixtable, [T,undefined]),
%% The table is not allowed to grow while the elements are inserted:
- ?line ok = ins(T, 500),
- ?line dets:safe_fixtable(T, false),
+ ok = ins(T, 500),
+ dets:safe_fixtable(T, false),
%% Now the table can grow. At the same time as elements are inserted,
%% the table tries to catch up with the previously inserted elements.
- ?line ok = ins(T, 1000),
- ?line 1000 = dets:info(T, size),
- ?line ok = dets:close(T),
- ?line file:delete(Fname),
+ ok = ins(T, 1000),
+ 1000 = dets:info(T, size),
+ ok = dets:close(T),
+ file:delete(Fname),
- ?line {ok, _} = dets:open_file(T, [{type, duplicate_bag} | Args]),
+ {ok, _} = dets:open_file(T, [{type, duplicate_bag} | Args]),
%% In a fixed table, delete and re-insert an object.
- ?line ok = dets:insert(T, {1, a, b}),
- ?line dets:safe_fixtable(T, true),
- ?line ok = dets:match_delete(T, {1, a, b}),
- ?line ok = dets:insert(T, {1, a, b}),
- ?line dets:safe_fixtable(T, false),
- ?line 1 = length(dets:match_object(T, '_')),
-
- ?line ok = dets:match_delete(T, '_'),
+ ok = dets:insert(T, {1, a, b}),
+ dets:safe_fixtable(T, true),
+ ok = dets:match_delete(T, {1, a, b}),
+ ok = dets:insert(T, {1, a, b}),
+ dets:safe_fixtable(T, false),
+ 1 = length(dets:match_object(T, '_')),
+
+ ok = dets:match_delete(T, '_'),
%% In a fixed table, delete and insert a smaller object.
- ?line ok = dets:insert(T, {1, duplicate(100, e)}),
- ?line dets:safe_fixtable(T, true),
- ?line ok = dets:match_delete(T, {1, '_'}),
- ?line ok = dets:insert(T, {1, a, b}),
- ?line dets:safe_fixtable(T, false),
- ?line 1 = length(dets:match_object(T, '_')),
-
- ?line ok = dets:delete_all_objects(T),
+ ok = dets:insert(T, {1, duplicate(100, e)}),
+ dets:safe_fixtable(T, true),
+ ok = dets:match_delete(T, {1, '_'}),
+ ok = dets:insert(T, {1, a, b}),
+ dets:safe_fixtable(T, false),
+ 1 = length(dets:match_object(T, '_')),
+
+ ok = dets:delete_all_objects(T),
%% Like the last one, but one extra object.
- ?line ok = dets:insert(T, {1, duplicate(100, e)}),
- ?line ok = dets:insert(T, {2, duplicate(100, e)}),
- ?line dets:safe_fixtable(T, true),
- ?line ok = dets:match_delete(T, {1, '_'}),
- ?line ok = dets:insert(T, {1, a, b}),
- ?line dets:safe_fixtable(T, false),
- ?line 2 = length(dets:match_object(T, '_')),
- ?line dets:safe_fixtable(T, true),
- ?line ok = dets:delete_all_objects(T),
- ?line true = dets:info(T, fixed),
- ?line 0 = length(dets:match_object(T, '_')),
-
- ?line ok = dets:close(T),
- ?line file:delete(Fname),
- ?line check_pps(P0),
+ ok = dets:insert(T, {1, duplicate(100, e)}),
+ ok = dets:insert(T, {2, duplicate(100, e)}),
+ dets:safe_fixtable(T, true),
+ ok = dets:match_delete(T, {1, '_'}),
+ ok = dets:insert(T, {1, a, b}),
+ dets:safe_fixtable(T, false),
+ 2 = length(dets:match_object(T, '_')),
+ dets:safe_fixtable(T, true),
+ ok = dets:delete_all_objects(T),
+ true = dets:info(T, fixed),
+ 0 = length(dets:match_object(T, '_')),
+
+ ok = dets:close(T),
+ file:delete(Fname),
+ check_pps(P0),
ok.
match_v8(doc) ->
@@ -1928,164 +1927,164 @@ match_v9(Config) when is_list(Config) ->
match(Config, Version) ->
T = match,
- ?line Fname = filename(match, Config),
- ?line file:delete(Fname),
+ Fname = filename(match, Config),
+ file:delete(Fname),
P0 = pps(),
Args = [{version, Version}, {file,Fname}, {type, duplicate_bag},
{estimated_no_objects,550}],
- ?line {ok, _} = dets:open_file(T, Args),
- ?line ok = dets:insert(T, {1, a, b}),
- ?line ok = dets:insert(T, {1, b, a}),
- ?line ok = dets:insert(T, {2, a, b}),
- ?line ok = dets:insert(T, {2, b, a}),
+ {ok, _} = dets:open_file(T, Args),
+ ok = dets:insert(T, {1, a, b}),
+ ok = dets:insert(T, {1, b, a}),
+ ok = dets:insert(T, {2, a, b}),
+ ok = dets:insert(T, {2, b, a}),
%% match, badarg
MSpec = [{'_',[],['$_']}],
- ?line check_badarg(catch dets:match(no_table, '_'),
- dets, match, [no_table,'_']),
- ?line check_badarg(catch dets:match(T, '_', not_a_number),
- dets, match, [T,'_',not_a_number]),
- ?line {EC1, _} = dets:select(T, MSpec, 1),
- ?line check_badarg(catch dets:match(EC1),
- dets, match, [EC1]),
+ check_badarg(catch dets:match(no_table, '_'),
+ dets, match, [no_table,'_']),
+ check_badarg(catch dets:match(T, '_', not_a_number),
+ dets, match, [T,'_',not_a_number]),
+ {EC1, _} = dets:select(T, MSpec, 1),
+ check_badarg(catch dets:match(EC1),
+ dets, match, [EC1]),
%% match_object, badarg
- ?line check_badarg(catch dets:match_object(no_table, '_'),
- dets, match_object, [no_table,'_']),
- ?line check_badarg(catch dets:match_object(T, '_', not_a_number),
- dets, match_object, [T,'_',not_a_number]),
- ?line {EC2, _} = dets:select(T, MSpec, 1),
- ?line check_badarg(catch dets:match_object(EC2),
- dets, match_object, [EC2]),
+ check_badarg(catch dets:match_object(no_table, '_'),
+ dets, match_object, [no_table,'_']),
+ check_badarg(catch dets:match_object(T, '_', not_a_number),
+ dets, match_object, [T,'_',not_a_number]),
+ {EC2, _} = dets:select(T, MSpec, 1),
+ check_badarg(catch dets:match_object(EC2),
+ dets, match_object, [EC2]),
dets:safe_fixtable(T, true),
- ?line {[_, _], C1} = dets:match_object(T, '_', 2),
- ?line {[_, _], C2} = dets:match_object(C1),
- ?line '$end_of_table' = dets:match_object(C2),
- ?line {[_, _], C3} = dets:match_object(T, {1, '_', '_'}, 100),
- ?line '$end_of_table' = dets:match_object(C3),
- ?line '$end_of_table' = dets:match_object(T, {'_'}, default),
- ?line dets:safe_fixtable(T, false),
-
- ?line dets:safe_fixtable(T, true),
- ?line {[_, _], C30} = dets:match(T, '$1', 2),
- ?line {[_, _], C31} = dets:match(C30),
- ?line '$end_of_table' = dets:match(C31),
- ?line {[_, _], C32} = dets:match(T, {1, '$1', '_'}, 100),
- ?line '$end_of_table' = dets:match(C32),
- ?line '$end_of_table' = dets:match(T, {'_'}, default),
- ?line dets:safe_fixtable(T, false),
- ?line [[1],[1],[2],[2]] = sort(dets:match(T, {'$1','_','_'})),
+ {[_, _], C1} = dets:match_object(T, '_', 2),
+ {[_, _], C2} = dets:match_object(C1),
+ '$end_of_table' = dets:match_object(C2),
+ {[_, _], C3} = dets:match_object(T, {1, '_', '_'}, 100),
+ '$end_of_table' = dets:match_object(C3),
+ '$end_of_table' = dets:match_object(T, {'_'}, default),
+ dets:safe_fixtable(T, false),
+
+ dets:safe_fixtable(T, true),
+ {[_, _], C30} = dets:match(T, '$1', 2),
+ {[_, _], C31} = dets:match(C30),
+ '$end_of_table' = dets:match(C31),
+ {[_, _], C32} = dets:match(T, {1, '$1', '_'}, 100),
+ '$end_of_table' = dets:match(C32),
+ '$end_of_table' = dets:match(T, {'_'}, default),
+ dets:safe_fixtable(T, false),
+ [[1],[1],[2],[2]] = sort(dets:match(T, {'$1','_','_'})),
%% delete and insert while chunking
%% (this case almost worthless after changes in OTP-5232)
- ?line ok = dets:match_delete(T, '_'),
+ ok = dets:match_delete(T, '_'),
L500 = seq(1, 500),
Fun = fun(X) -> ok = dets:insert(T, {X, a, b, c, d}) end,
- ?line foreach(Fun, L500),
+ foreach(Fun, L500),
%% Select one object DI in L3 below to be deleted.
- ?line {_, TmpCont} = dets:match_object(T, '_', 200),
- ?line {_, TmpCont1} = dets:match_object(TmpCont),
- ?line {TTL, _} = dets:match_object(TmpCont1),
- ?line DI = if Version =:= 8 -> last(TTL); Version =:= 9 -> hd(TTL) end,
- ?line dets:safe_fixtable(T, true),
- ?line {L1, C20} = dets:match_object(T, '_', 200),
- ?line true = 200 =< length(L1),
- ?line ok = dets:match_delete(T, {'2','_','_'}), % no match
- ?line ok = dets:match_delete(T, DI), % last object
+ {_, TmpCont} = dets:match_object(T, '_', 200),
+ {_, TmpCont1} = dets:match_object(TmpCont),
+ {TTL, _} = dets:match_object(TmpCont1),
+ DI = if Version =:= 8 -> last(TTL); Version =:= 9 -> hd(TTL) end,
+ dets:safe_fixtable(T, true),
+ {L1, C20} = dets:match_object(T, '_', 200),
+ true = 200 =< length(L1),
+ ok = dets:match_delete(T, {'2','_','_'}), % no match
+ ok = dets:match_delete(T, DI), % last object
Tiny = {1050},
- ?line ok = dets:insert(T, Tiny),
- ?line true = member(Tiny, dets:match_object(T, '_')),
- ?line {_L2, C21} = dets:match_object(C20),
- ?line {_L3, _C22} = dets:match_object(C21),
+ ok = dets:insert(T, Tiny),
+ true = member(Tiny, dets:match_object(T, '_')),
+ {_L2, C21} = dets:match_object(C20),
+ {_L3, _C22} = dets:match_object(C21),
%% It used to be that Tiny was not visible here, but since the
%% scanning of files was changed to inspect the free lists every
%% now and then it may very well be visible here.
- %% ?line false = member(Tiny, _L3),
+ %% false = member(Tiny, _L3),
%% DI used to visible here, but the above mentioned modification
%% has changed that; it may or may not be visible.
- %% ?line true = member(DI, _L3),
- ?line dets:safe_fixtable(T, false),
- ?line true = dets:member(T, 1050),
- ?line true = member(Tiny, dets:match_object(T, '_')),
- ?line false = member(DI, dets:match_object(T, '_')),
+ %% true = member(DI, _L3),
+ dets:safe_fixtable(T, false),
+ true = dets:member(T, 1050),
+ true = member(Tiny, dets:match_object(T, '_')),
+ false = member(DI, dets:match_object(T, '_')),
- ?line ok = dets:close(T),
- ?line file:delete(Fname),
+ ok = dets:close(T),
+ file:delete(Fname),
N = 100,
- ?line {ok, _} = dets:open_file(T, [{estimated_no_objects,N} | Args]),
- ?line ok = ins(T, N),
+ {ok, _} = dets:open_file(T, [{estimated_no_objects,N} | Args]),
+ ok = ins(T, N),
Obj = {66,{item,number,66}},
Spec = {'_','_'},
- ?line {ok, ObjPos} = dets:where(T, Obj),
- ?line ok = dets:close(T),
+ {ok, ObjPos} = dets:where(T, Obj),
+ ok = dets:close(T),
%% Damaged object.
crash(Fname, ObjPos+12),
- ?line {ok, _} = dets:open_file(T, Args),
- ?line io:format("Expect corrupt table:~n"),
- ?line case ins(T, N) of
+ {ok, _} = dets:open_file(T, Args),
+ io:format("Expect corrupt table:~n"),
+ case ins(T, N) of
ok ->
- ?line bad_object(dets:sync(T), Fname);
+ bad_object(dets:sync(T), Fname);
Else ->
- ?line bad_object(Else, Fname)
+ bad_object(Else, Fname)
end,
- ?line io:format("Expect corrupt table:~n"),
- ?line bad_object(dets:match(T, Spec), Fname),
- ?line io:format("Expect corrupt table:~n"),
- ?line bad_object(dets:match_delete(T, Spec), Fname),
- ?line bad_object(dets:close(T), Fname),
- ?line file:delete(Fname),
-
- ?line {ok, _} = dets:open_file(T, [{estimated_no_objects,N} | Args]),
- ?line ok = ins(T, N),
- ?line {ok, ObjPos2} = dets:where(T, Obj),
- ?line ok = dets:close(T),
+ io:format("Expect corrupt table:~n"),
+ bad_object(dets:match(T, Spec), Fname),
+ io:format("Expect corrupt table:~n"),
+ bad_object(dets:match_delete(T, Spec), Fname),
+ bad_object(dets:close(T), Fname),
+ file:delete(Fname),
+
+ {ok, _} = dets:open_file(T, [{estimated_no_objects,N} | Args]),
+ ok = ins(T, N),
+ {ok, ObjPos2} = dets:where(T, Obj),
+ ok = dets:close(T),
%% Damaged size of object.
%% In v8, there is a next pointer before the size.
CrashPos = if Version =:= 8 -> 5; Version =:= 9 -> 1 end,
crash(Fname, ObjPos2+CrashPos),
- ?line {ok, _} = dets:open_file(T, Args),
- ?line io:format("Expect corrupt table:~n"),
- ?line case ins(T, N) of
- ok ->
- ?line bad_object(dets:sync(T), Fname);
- Else2 ->
- ?line bad_object(Else2, Fname)
- end,
+ {ok, _} = dets:open_file(T, Args),
+ io:format("Expect corrupt table:~n"),
+ case ins(T, N) of
+ ok ->
+ bad_object(dets:sync(T), Fname);
+ Else2 ->
+ bad_object(Else2, Fname)
+ end,
%% Just echoes...
- ?line bad_object(dets:match(T, Spec), Fname),
- ?line bad_object(dets:match_delete(T, Spec), Fname),
- ?line bad_object(dets:close(T), Fname),
- ?line file:delete(Fname),
+ bad_object(dets:match(T, Spec), Fname),
+ bad_object(dets:match_delete(T, Spec), Fname),
+ bad_object(dets:close(T), Fname),
+ file:delete(Fname),
- ?line {ok, _} = dets:open_file(T, [{estimated_no_objects,N} | Args]),
- ?line ok = ins(T, N),
- ?line {ok, ObjPos3} = dets:where(T, Obj),
- ?line ok = dets:close(T),
+ {ok, _} = dets:open_file(T, [{estimated_no_objects,N} | Args]),
+ ok = ins(T, N),
+ {ok, ObjPos3} = dets:where(T, Obj),
+ ok = dets:close(T),
%% match_delete finds an error
CrashPos3 = if Version =:= 8 -> 12; Version =:= 9 -> 16 end,
crash(Fname, ObjPos3+CrashPos3),
- ?line {ok, _} = dets:open_file(T, Args),
- ?line bad_object(dets:match_delete(T, Spec), Fname),
- ?line bad_object(dets:close(T), Fname),
- ?line file:delete(Fname),
+ {ok, _} = dets:open_file(T, Args),
+ bad_object(dets:match_delete(T, Spec), Fname),
+ bad_object(dets:close(T), Fname),
+ file:delete(Fname),
%% The key is not fixed, but not all objects with the key are removed.
- ?line {ok, _} = dets:open_file(T, Args),
- ?line ok = dets:insert(T, [{1,a},{1,b},{1,c},{1,a},{1,b},{1,c}]),
- ?line 6 = dets:info(T, size),
- ?line ok = dets:match_delete(T, {'_',a}),
- ?line 4 = dets:info(T, size),
- ?line [{1,b},{1,b},{1,c},{1,c}] =
+ {ok, _} = dets:open_file(T, Args),
+ ok = dets:insert(T, [{1,a},{1,b},{1,c},{1,a},{1,b},{1,c}]),
+ 6 = dets:info(T, size),
+ ok = dets:match_delete(T, {'_',a}),
+ 4 = dets:info(T, size),
+ [{1,b},{1,b},{1,c},{1,c}] =
sort(dets:match_object(T,{'_','_'})),
- ?line ok = dets:close(T),
- ?line file:delete(Fname),
+ ok = dets:close(T),
+ file:delete(Fname),
- ?line check_pps(P0),
+ check_pps(P0),
ok.
select_v8(doc) ->
@@ -2104,102 +2103,102 @@ select_v9(Config) when is_list(Config) ->
select(Config, Version) ->
T = select,
- ?line Fname = filename(select, Config),
- ?line file:delete(Fname),
+ Fname = filename(select, Config),
+ file:delete(Fname),
P0 = pps(),
- ?line Args = [{version,Version}, {file,Fname}, {type, duplicate_bag},
- {estimated_no_objects,550}],
- ?line {ok, _} = dets:open_file(T, Args),
- ?line ok = dets:insert(T, {1, a, b}),
- ?line ok = dets:insert(T, {1, b, a}),
- ?line ok = dets:insert(T, {2, a, b}),
- ?line ok = dets:insert(T, {2, b, a}),
- ?line ok = dets:insert(T, {3, a, b}),
- ?line ok = dets:insert(T, {3, b, a}),
+ Args = [{version,Version}, {file,Fname}, {type, duplicate_bag},
+ {estimated_no_objects,550}],
+ {ok, _} = dets:open_file(T, Args),
+ ok = dets:insert(T, {1, a, b}),
+ ok = dets:insert(T, {1, b, a}),
+ ok = dets:insert(T, {2, a, b}),
+ ok = dets:insert(T, {2, b, a}),
+ ok = dets:insert(T, {3, a, b}),
+ ok = dets:insert(T, {3, b, a}),
%% badarg
MSpec = [{'_',[],['$_']}],
- ?line check_badarg(catch dets:select(no_table, MSpec),
- dets, select, [no_table,MSpec]),
- ?line check_badarg(catch dets:select(T, <<17>>),
- dets, select, [T,<<17>>]),
- ?line check_badarg(catch dets:select(T, []),
- dets, select, [T,[]]),
- ?line check_badarg(catch dets:select(T, MSpec, not_a_number),
- dets, select, [T,MSpec,not_a_number]),
- ?line {EC, _} = dets:match(T, '_', 1),
- ?line check_badarg(catch dets:select(EC),
- dets, select, [EC]),
+ check_badarg(catch dets:select(no_table, MSpec),
+ dets, select, [no_table,MSpec]),
+ check_badarg(catch dets:select(T, <<17>>),
+ dets, select, [T,<<17>>]),
+ check_badarg(catch dets:select(T, []),
+ dets, select, [T,[]]),
+ check_badarg(catch dets:select(T, MSpec, not_a_number),
+ dets, select, [T,MSpec,not_a_number]),
+ {EC, _} = dets:match(T, '_', 1),
+ check_badarg(catch dets:select(EC),
+ dets, select, [EC]),
AllSpec = [{'_',[],['$_']}],
- ?line dets:safe_fixtable(T, true),
- ?line {[_, _], C1} = dets:select(T, AllSpec, 2),
- ?line {[_, _], C2} = dets:select(C1),
- ?line {[_, _], C2a} = dets:select(C2),
- ?line '$end_of_table' = dets:select(C2a),
- ?line {[_, _], C3} = dets:select(T, [{{1,'_','_'},[],['$_']}], 100),
- ?line '$end_of_table' = dets:select(C3),
- ?line '$end_of_table' = dets:select(T, [{{'_'},[],['$_']}], default),
- ?line dets:safe_fixtable(T, false),
+ dets:safe_fixtable(T, true),
+ {[_, _], C1} = dets:select(T, AllSpec, 2),
+ {[_, _], C2} = dets:select(C1),
+ {[_, _], C2a} = dets:select(C2),
+ '$end_of_table' = dets:select(C2a),
+ {[_, _], C3} = dets:select(T, [{{1,'_','_'},[],['$_']}], 100),
+ '$end_of_table' = dets:select(C3),
+ '$end_of_table' = dets:select(T, [{{'_'},[],['$_']}], default),
+ dets:safe_fixtable(T, false),
Sp1 = [{{1,'_','_'},[],['$_']},{{1,'_','_'},[],['$_']},
{{2,'_','_'},[],['$_']}],
- ?line [_,_,_,_] = dets:select(T, Sp1),
+ [_,_,_,_] = dets:select(T, Sp1),
Sp2 = [{{1,'_','_'},[],['$_']},{{1,'_','_'},[],['$_']},
{{'_','_','_'},[],['$_']}],
- ?line [_,_,_,_,_,_] = dets:select(T, Sp2),
+ [_,_,_,_,_,_] = dets:select(T, Sp2),
AllDeleteSpec = [{'_',[],[true]}],
%% delete and insert while chunking
%% (this case almost worthless after changes in OTP-5232)
- ?line 6 = dets:select_delete(T, AllDeleteSpec),
+ 6 = dets:select_delete(T, AllDeleteSpec),
L500 = seq(1, 500),
Fun = fun(X) -> ok = dets:insert(T, {X, a, b, c, d}) end,
- ?line foreach(Fun, L500),
+ foreach(Fun, L500),
%% Select one object DI in L3 below to be deleted.
- ?line {_, TmpCont} = dets:match_object(T, '_', 200),
- ?line {_, TmpCont1} = dets:match_object(TmpCont),
- ?line {TTL, _} = dets:match_object(TmpCont1),
- ?line DI = if Version =:= 8 -> last(TTL); Version =:= 9 -> hd(TTL) end,
- ?line dets:safe_fixtable(T, true),
- ?line {L1, C20} = dets:select(T, AllSpec, 200),
- ?line true = 200 =< length(L1),
- ?line 0 = dets:select_delete(T, [{{2,'_','_'},[],[true]}]),
- ?line 1 = dets:select_delete(T, [{DI,[],[true]}]), % last object
+ {_, TmpCont} = dets:match_object(T, '_', 200),
+ {_, TmpCont1} = dets:match_object(TmpCont),
+ {TTL, _} = dets:match_object(TmpCont1),
+ DI = if Version =:= 8 -> last(TTL); Version =:= 9 -> hd(TTL) end,
+ dets:safe_fixtable(T, true),
+ {L1, C20} = dets:select(T, AllSpec, 200),
+ true = 200 =< length(L1),
+ 0 = dets:select_delete(T, [{{2,'_','_'},[],[true]}]),
+ 1 = dets:select_delete(T, [{DI,[],[true]}]), % last object
Tiny = {1050},
- ?line ok = dets:insert(T, Tiny),
- ?line true = member(Tiny, dets:select(T, AllSpec)),
- ?line {_L2, C21} = dets:select(C20),
- ?line {_L3, _C22} = dets:select(C21),
+ ok = dets:insert(T, Tiny),
+ true = member(Tiny, dets:select(T, AllSpec)),
+ {_L2, C21} = dets:select(C20),
+ {_L3, _C22} = dets:select(C21),
%% It used to be that Tiny was not visible here, but since the
%% scanning of files was changed to inspect the free lists every
%% now and then it may very well be visible here.
- %% ?line false = member(Tiny, _L3),
+ %% false = member(Tiny, _L3),
%% DI used to visible here, but the above mentioned modification
%% has changed that; it may or may not be visible.
- %% ?line true = member(DI, _L3),
- ?line true = dets:member(T, 1050),
- ?line true = member(Tiny, dets:select(T, AllSpec)),
- ?line false = member(DI, dets:select(T, AllSpec)),
- ?line dets:safe_fixtable(T, false),
- ?line true = dets:member(T, 1050),
- ?line true = member(Tiny, dets:select(T, AllSpec)),
- ?line false = member(DI, dets:select(T, AllSpec)),
- ?line ok = dets:close(T),
- ?line file:delete(Fname),
+ %% true = member(DI, _L3),
+ true = dets:member(T, 1050),
+ true = member(Tiny, dets:select(T, AllSpec)),
+ false = member(DI, dets:select(T, AllSpec)),
+ dets:safe_fixtable(T, false),
+ true = dets:member(T, 1050),
+ true = member(Tiny, dets:select(T, AllSpec)),
+ false = member(DI, dets:select(T, AllSpec)),
+ ok = dets:close(T),
+ file:delete(Fname),
%% The key is not fixed, but not all objects with the key are removed.
- ?line {ok, _} = dets:open_file(T, Args),
- ?line ok = dets:insert(T, [{1,a},{1,b},{1,c},{1,a},{1,b},{1,c}]),
- ?line 6 = dets:info(T, size),
- ?line 2 = dets:select_delete(T, [{{'_',a},[],[true]}]),
- ?line 4 = dets:info(T, size),
- ?line [{1,b},{1,b},{1,c},{1,c}] = sort(dets:select(T, AllSpec)),
- ?line ok = dets:close(T),
- ?line file:delete(Fname),
-
- ?line check_pps(P0),
+ {ok, _} = dets:open_file(T, Args),
+ ok = dets:insert(T, [{1,a},{1,b},{1,c},{1,a},{1,b},{1,c}]),
+ 6 = dets:info(T, size),
+ 2 = dets:select_delete(T, [{{'_',a},[],[true]}]),
+ 4 = dets:info(T, size),
+ [{1,b},{1,b},{1,c},{1,c}] = sort(dets:select(T, AllSpec)),
+ ok = dets:close(T),
+ file:delete(Fname),
+
+ check_pps(P0),
ok.
update_counter(doc) ->
@@ -2208,34 +2207,34 @@ update_counter(suite) ->
[];
update_counter(Config) when is_list(Config) ->
T = update_counter,
- ?line Fname = filename(select, Config),
- ?line file:delete(Fname),
+ Fname = filename(select, Config),
+ file:delete(Fname),
P0 = pps(),
- ?line check_badarg(catch dets:update_counter(no_table, 1, 1),
- dets, update_counter, [no_table,1,1]),
+ check_badarg(catch dets:update_counter(no_table, 1, 1),
+ dets, update_counter, [no_table,1,1]),
Args = [{file,Fname},{keypos,2}],
- ?line {ok, _} = dets:open_file(T, [{type,set} | Args]),
- ?line {'EXIT', {badarg, _}} = (catch dets:update_counter(T, 1, 1)),
- ?line ok = dets:insert(T, {1,a}),
- ?line {'EXIT', {badarg, _}} = (catch dets:update_counter(T, 1, 1)),
- ?line ok = dets:insert(T, {0,1}),
- ?line {'EXIT', {badarg, _}} = (catch dets:update_counter(T, 1, 1)),
- ?line ok = dets:insert(T, {0,1,0}),
- ?line 1 = dets:update_counter(T, 1, 1),
- ?line 2 = dets:update_counter(T, 1, 1),
- ?line 6 = dets:update_counter(T, 1, {3,4}),
- ?line {'EXIT', {badarg, _}} = (catch dets:update_counter(T, 1, {0,3})),
- ?line ok = dets:close(T),
- ?line file:delete(Fname),
-
- ?line {ok, _} = dets:open_file(T, [{type,bag} | Args]),
- ?line ok = dets:insert(T, {0,1,0}),
- ?line {'EXIT', {badarg, _}} = (catch dets:update_counter(T, 1, 1)),
- ?line ok = dets:close(T),
- ?line file:delete(Fname),
- ?line check_pps(P0),
+ {ok, _} = dets:open_file(T, [{type,set} | Args]),
+ {'EXIT', {badarg, _}} = (catch dets:update_counter(T, 1, 1)),
+ ok = dets:insert(T, {1,a}),
+ {'EXIT', {badarg, _}} = (catch dets:update_counter(T, 1, 1)),
+ ok = dets:insert(T, {0,1}),
+ {'EXIT', {badarg, _}} = (catch dets:update_counter(T, 1, 1)),
+ ok = dets:insert(T, {0,1,0}),
+ 1 = dets:update_counter(T, 1, 1),
+ 2 = dets:update_counter(T, 1, 1),
+ 6 = dets:update_counter(T, 1, {3,4}),
+ {'EXIT', {badarg, _}} = (catch dets:update_counter(T, 1, {0,3})),
+ ok = dets:close(T),
+ file:delete(Fname),
+
+ {ok, _} = dets:open_file(T, [{type,bag} | Args]),
+ ok = dets:insert(T, {0,1,0}),
+ {'EXIT', {badarg, _}} = (catch dets:update_counter(T, 1, 1)),
+ ok = dets:close(T),
+ file:delete(Fname),
+ check_pps(P0),
ok.
@@ -2245,133 +2244,133 @@ badarg(suite) ->
[];
badarg(Config) when is_list(Config) ->
T = badarg,
- ?line Fname = filename(select, Config),
- ?line file:delete(Fname),
+ Fname = filename(select, Config),
+ file:delete(Fname),
P0 = pps(),
Args = [{file,Fname},{keypos,3}],
- ?line {ok, _} = dets:open_file(T, [{type,set} | Args]),
- % ?line dets:verbose(),
+ {ok, _} = dets:open_file(T, [{type,set} | Args]),
+ % dets:verbose(),
%% badargs are tested in match, select and fixtable too.
%% open
- ?line check_badarg(catch dets:open_file({a,tuple},[]),
- dets, open_file, [{a,tuple},[]]),
- ?line check_badarg(catch dets:open_file({a,tuple}),
- dets, open_file,[{a,tuple}]),
- ?line check_badarg(catch dets:open_file(file,[foo]),
- dets, open_file, [file,[foo]]),
- ?line check_badarg(catch dets:open_file({hej,san},[{type,set}|3]),
- dets, open_file, [{hej,san},[{type,set}|3]]),
+ check_badarg(catch dets:open_file({a,tuple},[]),
+ dets, open_file, [{a,tuple},[]]),
+ check_badarg(catch dets:open_file({a,tuple}),
+ dets, open_file,[{a,tuple}]),
+ check_badarg(catch dets:open_file(file,[foo]),
+ dets, open_file, [file,[foo]]),
+ check_badarg(catch dets:open_file({hej,san},[{type,set}|3]),
+ dets, open_file, [{hej,san},[{type,set}|3]]),
%% insert
- ?line check_badarg(catch dets:insert(no_table, {1,2}),
- dets, insert, [no_table,{1,2}]),
- ?line check_badarg(catch dets:insert(no_table, [{1,2}]),
- dets, insert, [no_table,[{1,2}]]),
- ?line check_badarg(catch dets:insert(T, {1,2}),
- dets, insert, [T,{1,2}]),
- ?line check_badarg(catch dets:insert(T, [{1,2}]),
- dets, insert, [T,[{1,2}]]),
- ?line check_badarg(catch dets:insert(T, [{1,2,3} | 3]),
- dets, insert, [T,[{1,2,3}|3]]),
+ check_badarg(catch dets:insert(no_table, {1,2}),
+ dets, insert, [no_table,{1,2}]),
+ check_badarg(catch dets:insert(no_table, [{1,2}]),
+ dets, insert, [no_table,[{1,2}]]),
+ check_badarg(catch dets:insert(T, {1,2}),
+ dets, insert, [T,{1,2}]),
+ check_badarg(catch dets:insert(T, [{1,2}]),
+ dets, insert, [T,[{1,2}]]),
+ check_badarg(catch dets:insert(T, [{1,2,3} | 3]),
+ dets, insert, [T,[{1,2,3}|3]]),
%% lookup{_keys}
- ?line check_badarg(catch dets:lookup_keys(T, []),
- dets, lookup_keys, [badarg,[]]),
- ?line check_badarg(catch dets:lookup(no_table, 1),
- dets, lookup, [no_table,1]),
- ?line check_badarg(catch dets:lookup_keys(T, [1 | 2]),
- dets, lookup_keys, [T,[1|2]]),
+ check_badarg(catch dets:lookup_keys(T, []),
+ dets, lookup_keys, [badarg,[]]),
+ check_badarg(catch dets:lookup(no_table, 1),
+ dets, lookup, [no_table,1]),
+ check_badarg(catch dets:lookup_keys(T, [1 | 2]),
+ dets, lookup_keys, [T,[1|2]]),
%% member
- ?line check_badarg(catch dets:member(no_table, 1),
- dets, member, [no_table,1]),
+ check_badarg(catch dets:member(no_table, 1),
+ dets, member, [no_table,1]),
%% sync
- ?line check_badarg(catch dets:sync(no_table),
- dets, sync, [no_table]),
+ check_badarg(catch dets:sync(no_table),
+ dets, sync, [no_table]),
%% delete{_keys}
- ?line check_badarg(catch dets:delete(no_table, 1),
- dets, delete, [no_table,1]),
+ check_badarg(catch dets:delete(no_table, 1),
+ dets, delete, [no_table,1]),
%% delete_object
- ?line check_badarg(catch dets:delete_object(no_table, {1,2,3}),
- dets, delete_object, [no_table,{1,2,3}]),
- ?line check_badarg(catch dets:delete_object(T, {1,2}),
- dets, delete_object, [T,{1,2}]),
- ?line check_badarg(catch dets:delete_object(no_table, [{1,2,3}]),
- dets, delete_object, [no_table,[{1,2,3}]]),
- ?line check_badarg(catch dets:delete_object(T, [{1,2}]),
- dets, delete_object, [T,[{1,2}]]),
- ?line check_badarg(catch dets:delete_object(T, [{1,2,3} | 3]),
- dets, delete_object, [T,[{1,2,3}|3]]),
+ check_badarg(catch dets:delete_object(no_table, {1,2,3}),
+ dets, delete_object, [no_table,{1,2,3}]),
+ check_badarg(catch dets:delete_object(T, {1,2}),
+ dets, delete_object, [T,{1,2}]),
+ check_badarg(catch dets:delete_object(no_table, [{1,2,3}]),
+ dets, delete_object, [no_table,[{1,2,3}]]),
+ check_badarg(catch dets:delete_object(T, [{1,2}]),
+ dets, delete_object, [T,[{1,2}]]),
+ check_badarg(catch dets:delete_object(T, [{1,2,3} | 3]),
+ dets, delete_object, [T,[{1,2,3}|3]]),
%% first,next,slot
- ?line check_badarg(catch dets:first(no_table),
- dets, first, [no_table]),
- ?line check_badarg(catch dets:next(no_table, 1),
- dets, next, [no_table,1]),
- ?line check_badarg(catch dets:slot(no_table, 0),
- dets, slot, [no_table,0]),
+ check_badarg(catch dets:first(no_table),
+ dets, first, [no_table]),
+ check_badarg(catch dets:next(no_table, 1),
+ dets, next, [no_table,1]),
+ check_badarg(catch dets:slot(no_table, 0),
+ dets, slot, [no_table,0]),
%% info
- ?line undefined = dets:info(no_table),
- ?line undefined = dets:info(no_table, foo),
- ?line undefined = dets:info(T, foo),
+ undefined = dets:info(no_table),
+ undefined = dets:info(no_table, foo),
+ undefined = dets:info(T, foo),
%% match_delete
- ?line check_badarg(catch dets:match_delete(no_table, '_'),
+ check_badarg(catch dets:match_delete(no_table, '_'),
dets, match_delete, [no_table,'_']),
%% delete_all_objects
- ?line check_badarg(catch dets:delete_all_objects(no_table),
- dets, delete_all_objects, [no_table]),
+ check_badarg(catch dets:delete_all_objects(no_table),
+ dets, delete_all_objects, [no_table]),
%% select_delete
MSpec = [{'_',[],['$_']}],
- ?line check_badarg(catch dets:select_delete(no_table, MSpec),
- dets, select_delete, [no_table,MSpec]),
- ?line check_badarg(catch dets:select_delete(T, <<17>>),
- dets, select_delete, [T, <<17>>]),
+ check_badarg(catch dets:select_delete(no_table, MSpec),
+ dets, select_delete, [no_table,MSpec]),
+ check_badarg(catch dets:select_delete(T, <<17>>),
+ dets, select_delete, [T, <<17>>]),
%% traverse, fold
TF = fun(_) -> continue end,
- ?line check_badarg(catch dets:traverse(no_table, TF),
- dets, traverse, [no_table,TF]),
+ check_badarg(catch dets:traverse(no_table, TF),
+ dets, traverse, [no_table,TF]),
FF = fun(_, A) -> A end,
- ?line check_badarg(catch dets:foldl(FF, [], no_table),
- dets, foldl, [FF,[],no_table]),
- ?line check_badarg(catch dets:foldr(FF, [], no_table),
- dets, foldl, [FF,[],no_table]),
+ check_badarg(catch dets:foldl(FF, [], no_table),
+ dets, foldl, [FF,[],no_table]),
+ check_badarg(catch dets:foldr(FF, [], no_table),
+ dets, foldl, [FF,[],no_table]),
%% close
- ?line ok = dets:close(T),
- ?line {error, not_owner} = dets:close(T),
- ?line {error, not_owner} = dets:close(T),
+ ok = dets:close(T),
+ {error, not_owner} = dets:close(T),
+ {error, not_owner} = dets:close(T),
%% init_table
IF = fun(X) -> X end,
- ?line check_badarg(catch dets:init_table(no_table, IF),
- dets, init_table, [no_table,IF,[]]),
- ?line check_badarg(catch dets:init_table(no_table, IF, []),
- dets, init_table, [no_table,IF,[]]),
+ check_badarg(catch dets:init_table(no_table, IF),
+ dets, init_table, [no_table,IF,[]]),
+ check_badarg(catch dets:init_table(no_table, IF, []),
+ dets, init_table, [no_table,IF,[]]),
%% from_ets
Ets = ets:new(ets,[]),
- ?line check_badarg(catch dets:from_ets(no_table, Ets),
- dets, from_ets, [no_table,Ets]),
+ check_badarg(catch dets:from_ets(no_table, Ets),
+ dets, from_ets, [no_table,Ets]),
ets:delete(Ets),
- ?line {ok, T} = dets:open_file(T, Args),
- ?line {error,incompatible_arguments} =
+ {ok, T} = dets:open_file(T, Args),
+ {error,incompatible_arguments} =
dets:open_file(T, [{type,bag} | Args]),
- ?line ok = dets:close(T),
+ ok = dets:close(T),
file:delete(Fname),
- ?line check_pps(P0),
+ check_pps(P0),
ok.
cache_sets_v8(doc) ->
@@ -2407,11 +2406,11 @@ cache_sets(Config, DelayedWrite, Extra, Sz, Version) ->
%% Sz = integer(). Size of the inserted tuples.
T = cache,
- ?line Fname = filename(cache, Config),
- ?line file:delete(Fname),
+ Fname = filename(cache, Config),
+ file:delete(Fname),
P0 = pps(),
- ?line {ok, _} =
+ {ok, _} =
dets:open_file(T,[{version, Version}, {file,Fname}, {type,set},
{delayed_write, DelayedWrite}]),
@@ -2420,48 +2419,48 @@ cache_sets(Config, DelayedWrite, Extra, Sz, Version) ->
if
Extra ->
%% Insert enough to get three keys in some slot.
- ?line dets:safe_fixtable(T, true),
+ dets:safe_fixtable(T, true),
insert_objs(T, 1, Sz, Dups);
true ->
{1,[]}
end,
Tuple = erlang:make_tuple(Sz, Key),
- ?line ok = dets:delete(T, Key),
- ?line ok = dets:sync(T),
+ ok = dets:delete(T, Key),
+ ok = dets:sync(T),
%% The values of keys in the same slot as Key are checked.
- ?line OtherValues = sort(lookup_keys(T, OtherKeys)),
+ OtherValues = sort(lookup_keys(T, OtherKeys)),
- ?line ok = dets:insert(T, Tuple),
- ?line [Tuple] = dets:lookup(T, Key),
- ?line true = dets:member(T, Key),
- ?line ok = dets:insert(T, [Tuple,Tuple]),
+ ok = dets:insert(T, Tuple),
+ [Tuple] = dets:lookup(T, Key),
+ true = dets:member(T, Key),
+ ok = dets:insert(T, [Tuple,Tuple]),
%% If no delay, the cache gets filled immediately, and written.
- ?line [Tuple] = dets:lookup_keys(T, [Key,a,b,c,d,e,f]),
- ?line true = dets:member(T, Key),
+ [Tuple] = dets:lookup_keys(T, [Key,a,b,c,d,e,f]),
+ true = dets:member(T, Key),
%% If delay, this happens without file access.
- ?line ok = dets:delete(T,Key),
- ?line ok = dets:insert(T,Tuple),
- ?line ok = dets:insert(T,Tuple),
- ?line [Tuple] = dets:lookup(T, Key),
- ?line true = dets:member(T, Key),
- ?line ok = dets:sync(T),
- ?line [Tuple] = dets:lookup(T, Key),
- ?line true = dets:member(T, Key),
+ ok = dets:delete(T,Key),
+ ok = dets:insert(T,Tuple),
+ ok = dets:insert(T,Tuple),
+ [Tuple] = dets:lookup(T, Key),
+ true = dets:member(T, Key),
+ ok = dets:sync(T),
+ [Tuple] = dets:lookup(T, Key),
+ true = dets:member(T, Key),
%% Key's objects are is on file only,
%% key 'toto' in the cache (if there is one).
- ?line ok = dets:delete(T,toto),
- ?line ok = dets:insert(T,[{toto,b},{toto,b}]),
- ?line true = sort([Tuple,{toto,b}]) =:=
- sort(dets:lookup_keys(T, [Key,toto])),
- ?line true = dets:member(T, toto),
+ ok = dets:delete(T,toto),
+ ok = dets:insert(T,[{toto,b},{toto,b}]),
+ true = sort([Tuple,{toto,b}]) =:=
+ sort(dets:lookup_keys(T, [Key,toto])),
+ true = dets:member(T, toto),
- ?line ok = dets:delete(T, Key),
- ?line ok = dets:sync(T),
- ?line false = dets:member(T, Key),
- ?line Size = dets:info(T, size),
+ ok = dets:delete(T, Key),
+ ok = dets:sync(T),
+ false = dets:member(T, Key),
+ Size = dets:info(T, size),
%% No object with the key on the file.
%% Delete, add one object.
@@ -2483,37 +2482,37 @@ cache_sets(Config, DelayedWrite, Extra, Sz, Version) ->
E -> E + 1
end,
Tuple2 = setelement(2, Tuple, Element),
- ?line ok = dets:sync(T),
- ?line ok = dets:insert(T, Tuple2),
- ?line [Tuple2] = dets:lookup(T, Key),
- ?line true = dets:member(T, Key),
- ?line ok = dets:sync(T),
- ?line [Tuple2] = dets:lookup(T, Key),
- ?line true = dets:member(T, Key),
-
- ?line ok = dets:insert(T, {3,a}),
- ?line ok = dets:insert(T, {3,b}),
- ?line ok = dets:delete_object(T, {3,c}),
- ?line ok = dets:delete_object(T, {3,d}),
- ?line [{3,b}] = dets:lookup(T, 3),
-
- ?line ok = dets:delete(T, 3),
- ?line ok = dets:delete_object(T, {3,c}),
- ?line ok = dets:delete_object(T, {3,d}),
- ?line [] = dets:lookup(T, 3),
-
- ?line OtherValues = sort(lookup_keys(T, OtherKeys)),
+ ok = dets:sync(T),
+ ok = dets:insert(T, Tuple2),
+ [Tuple2] = dets:lookup(T, Key),
+ true = dets:member(T, Key),
+ ok = dets:sync(T),
+ [Tuple2] = dets:lookup(T, Key),
+ true = dets:member(T, Key),
+
+ ok = dets:insert(T, {3,a}),
+ ok = dets:insert(T, {3,b}),
+ ok = dets:delete_object(T, {3,c}),
+ ok = dets:delete_object(T, {3,d}),
+ [{3,b}] = dets:lookup(T, 3),
+
+ ok = dets:delete(T, 3),
+ ok = dets:delete_object(T, {3,c}),
+ ok = dets:delete_object(T, {3,d}),
+ [] = dets:lookup(T, 3),
+
+ OtherValues = sort(lookup_keys(T, OtherKeys)),
if
Extra ->
%% Let the table grow a while, if it needs to.
- ?line All1 = get_all_objects(T),
- ?line dets:safe_fixtable(T, false),
- ?line timer:sleep(1000),
- ?line OtherValues = sort(lookup_keys(T, OtherKeys)),
- ?line dets:safe_fixtable(T, true),
- ?line All2 = get_all_objects(T),
- ?line FAll2 = get_all_objects_fast(T),
- ?line true = sort(All2) =:= sort(FAll2),
+ All1 = get_all_objects(T),
+ dets:safe_fixtable(T, false),
+ timer:sleep(1000),
+ OtherValues = sort(lookup_keys(T, OtherKeys)),
+ dets:safe_fixtable(T, true),
+ All2 = get_all_objects(T),
+ FAll2 = get_all_objects_fast(T),
+ true = sort(All2) =:= sort(FAll2),
case symdiff(All1, All2) of
{[],[]} -> ok;
{X,Y} ->
@@ -2523,10 +2522,10 @@ cache_sets(Config, DelayedWrite, Extra, Sz, Version) ->
true ->
ok
end,
- ?line ok = dets:close(T),
+ ok = dets:close(T),
file:delete(Fname),
- ?line check_pps(P0),
+ check_pps(P0),
ok.
cache_bags_v8(doc) ->
@@ -2562,11 +2561,11 @@ cache_bags(Config, DelayedWrite, Extra, Sz, Version) ->
%% Sz = integer(). Size of the inserted tuples.
T = cache,
- ?line Fname = filename(cache, Config),
- ?line file:delete(Fname),
+ Fname = filename(cache, Config),
+ file:delete(Fname),
P0 = pps(),
- ?line {ok, _} =
+ {ok, _} =
dets:open_file(T,[{version, Version}, {file,Fname}, {type,bag},
{delayed_write, DelayedWrite}]),
@@ -2575,49 +2574,49 @@ cache_bags(Config, DelayedWrite, Extra, Sz, Version) ->
if
Extra ->
%% Insert enough to get three keys in some slot.
- ?line dets:safe_fixtable(T, true),
+ dets:safe_fixtable(T, true),
insert_objs(T, 1, Sz, Dups);
true ->
{1,[]}
end,
Tuple = erlang:make_tuple(Sz, Key),
- ?line ok = dets:delete(T, Key),
- ?line ok = dets:sync(T),
+ ok = dets:delete(T, Key),
+ ok = dets:sync(T),
%% The values of keys in the same slot as Key are checked.
- ?line OtherValues = sort(lookup_keys(T, OtherKeys)),
+ OtherValues = sort(lookup_keys(T, OtherKeys)),
- ?line ok = dets:insert(T, Tuple),
- ?line [Tuple] = dets:lookup(T, Key),
- ?line true = dets:member(T, Key),
- ?line ok = dets:insert(T, [Tuple,Tuple]),
+ ok = dets:insert(T, Tuple),
+ [Tuple] = dets:lookup(T, Key),
+ true = dets:member(T, Key),
+ ok = dets:insert(T, [Tuple,Tuple]),
%% If no delay, the cache gets filled immediately, and written.
- ?line [Tuple] = dets:lookup_keys(T, [Key,a,b,c,d,e,f]),
- ?line true = dets:member(T, Key),
+ [Tuple] = dets:lookup_keys(T, [Key,a,b,c,d,e,f]),
+ true = dets:member(T, Key),
%% If delay, this happens without file access.
%% (This is no longer true; cache lookup has been simplified.)
- ?line ok = dets:delete(T,Key),
- ?line ok = dets:insert(T,Tuple),
- ?line ok = dets:insert(T,Tuple),
- ?line [Tuple] = dets:lookup(T, Key),
- ?line true = dets:member(T, Key),
- ?line ok = dets:sync(T),
- ?line [Tuple] = dets:lookup(T, Key),
- ?line true = dets:member(T, Key),
+ ok = dets:delete(T,Key),
+ ok = dets:insert(T,Tuple),
+ ok = dets:insert(T,Tuple),
+ [Tuple] = dets:lookup(T, Key),
+ true = dets:member(T, Key),
+ ok = dets:sync(T),
+ [Tuple] = dets:lookup(T, Key),
+ true = dets:member(T, Key),
%% Key's objects are is on file only,
%% key toto in the cache (if there is one).
- ?line ok = dets:delete(T,toto),
- ?line false = dets:member(T, toto),
- ?line ok = dets:insert(T,[{toto,b},{toto,b}]),
- ?line true = sort([Tuple,{toto,b}]) =:=
- sort(dets:lookup_keys(T, [Key,toto])),
- ?line true = dets:member(T, toto),
+ ok = dets:delete(T,toto),
+ false = dets:member(T, toto),
+ ok = dets:insert(T,[{toto,b},{toto,b}]),
+ true = sort([Tuple,{toto,b}]) =:=
+ sort(dets:lookup_keys(T, [Key,toto])),
+ true = dets:member(T, toto),
- ?line ok = dets:delete(T, Key),
- ?line ok = dets:sync(T),
- ?line Size = dets:info(T, size),
+ ok = dets:delete(T, Key),
+ ok = dets:sync(T),
+ Size = dets:info(T, size),
%% No object with the key on the file.
%% Delete, add one object.
@@ -2634,50 +2633,50 @@ cache_bags(Config, DelayedWrite, Extra, Sz, Version) ->
del_and_ins(both, T, Size2, Tuple, Key, 1),
%% Overwrite an objekt on file with the same object.
- ?line ok = dets:insert(T, Tuple),
- ?line ok = dets:sync(T),
- ?line [Tuple2] = dets:lookup(T, Key),
- ?line true = dets:member(T, Key),
- ?line ok = dets:insert(T, Tuple),
- ?line ok = dets:sync(T),
- ?line [Tuple2] = dets:lookup(T, Key),
- ?line true = dets:member(T, Key),
+ ok = dets:insert(T, Tuple),
+ ok = dets:sync(T),
+ [Tuple2] = dets:lookup(T, Key),
+ true = dets:member(T, Key),
+ ok = dets:insert(T, Tuple),
+ ok = dets:sync(T),
+ [Tuple2] = dets:lookup(T, Key),
+ true = dets:member(T, Key),
%% A mix of insert and delete.
- ?line ok = dets:delete(T, Key),
- ?line ok = dets:sync(T),
- ?line ok = dets:delete(T, Key),
- ?line ok = dets:insert(T, {Key,foo}),
- ?line ok = dets:insert(T, {Key,bar}),
- ?line [{Key,bar},{Key,foo}] = sort(dets:lookup(T, Key)),
- ?line true = dets:member(T, Key),
- ?line ok = dets:delete_object(T, {Key,foo}),
- ?line ok = dets:insert(T, {Key,kar}),
- ?line [{Key,bar},{Key,kar}] = sort(dets:lookup(T, Key)),
- ?line true = dets:member(T, Key),
- ?line ok = dets:insert(T, [{Key,kar},{Key,kar}]),
- ?line [{Key,bar},{Key,kar}] = sort(dets:lookup(T, Key)),
- ?line true = dets:member(T, Key),
- ?line ok = dets:delete_object(T, {Key,bar}),
- ?line ok = dets:delete_object(T, {Key,kar}),
- ?line [] = dets:lookup(T, Key),
- ?line false = dets:member(T, Key),
- ?line ok = dets:sync(T),
- ?line [] = dets:lookup(T, Key),
- ?line false = dets:member(T, Key),
-
- ?line OtherValues = sort(lookup_keys(T, OtherKeys)),
+ ok = dets:delete(T, Key),
+ ok = dets:sync(T),
+ ok = dets:delete(T, Key),
+ ok = dets:insert(T, {Key,foo}),
+ ok = dets:insert(T, {Key,bar}),
+ [{Key,bar},{Key,foo}] = sort(dets:lookup(T, Key)),
+ true = dets:member(T, Key),
+ ok = dets:delete_object(T, {Key,foo}),
+ ok = dets:insert(T, {Key,kar}),
+ [{Key,bar},{Key,kar}] = sort(dets:lookup(T, Key)),
+ true = dets:member(T, Key),
+ ok = dets:insert(T, [{Key,kar},{Key,kar}]),
+ [{Key,bar},{Key,kar}] = sort(dets:lookup(T, Key)),
+ true = dets:member(T, Key),
+ ok = dets:delete_object(T, {Key,bar}),
+ ok = dets:delete_object(T, {Key,kar}),
+ [] = dets:lookup(T, Key),
+ false = dets:member(T, Key),
+ ok = dets:sync(T),
+ [] = dets:lookup(T, Key),
+ false = dets:member(T, Key),
+
+ OtherValues = sort(lookup_keys(T, OtherKeys)),
if
Extra ->
%% Let the table grow for a while, if it needs to.
- ?line All1 = get_all_objects(T),
- ?line dets:safe_fixtable(T, false),
- ?line timer:sleep(1200),
- ?line OtherValues = sort(lookup_keys(T, OtherKeys)),
- ?line dets:safe_fixtable(T, true),
- ?line All2 = get_all_objects(T),
- ?line FAll2 = get_all_objects_fast(T),
- ?line true = sort(All2) =:= sort(FAll2),
+ All1 = get_all_objects(T),
+ dets:safe_fixtable(T, false),
+ timer:sleep(1200),
+ OtherValues = sort(lookup_keys(T, OtherKeys)),
+ dets:safe_fixtable(T, true),
+ All2 = get_all_objects(T),
+ FAll2 = get_all_objects_fast(T),
+ true = sort(All2) =:= sort(FAll2),
case symdiff(All1, All2) of
{[],[]} -> ok;
{X,Y} ->
@@ -2687,28 +2686,28 @@ cache_bags(Config, DelayedWrite, Extra, Sz, Version) ->
true ->
ok
end,
- ?line ok = dets:close(T),
+ ok = dets:close(T),
file:delete(Fname),
%% Second object of a key added and looked up simultaneously.
R1 = {index_test,1,2,3,4},
R2 = {index_test,2,2,13,14},
R3 = {index_test,1,12,13,14},
- ?line {ok, _} = dets:open_file(T,[{version,Version},{type,bag},
- {keypos,2},{file,Fname}]),
- ?line ok = dets:insert(T,R1),
- ?line ok = dets:sync(T),
- ?line ok = dets:insert(T,R2),
- ?line ok = dets:sync(T),
- ?line ok = dets:insert(T,R3),
- ?line [R1,R3] = sort(dets:lookup(T,1)),
- ?line true = dets:member(T, 1),
- ?line [R1,R3] = sort(dets:lookup(T,1)),
- ?line true = dets:member(T, 1),
- ?line ok = dets:close(T),
+ {ok, _} = dets:open_file(T,[{version,Version},{type,bag},
+ {keypos,2},{file,Fname}]),
+ ok = dets:insert(T,R1),
+ ok = dets:sync(T),
+ ok = dets:insert(T,R2),
+ ok = dets:sync(T),
+ ok = dets:insert(T,R3),
+ [R1,R3] = sort(dets:lookup(T,1)),
+ true = dets:member(T, 1),
+ [R1,R3] = sort(dets:lookup(T,1)),
+ true = dets:member(T, 1),
+ ok = dets:close(T),
file:delete(Fname),
- ?line check_pps(P0),
+ check_pps(P0),
ok.
cache_duplicate_bags_v8(doc) ->
@@ -2743,11 +2742,11 @@ cache_dup_bags(Config, DelayedWrite, Extra, Sz, Version) ->
%% Sz = integer(). Size of the inserted tuples.
T = cache,
- ?line Fname = filename(cache, Config),
- ?line file:delete(Fname),
+ Fname = filename(cache, Config),
+ file:delete(Fname),
P0 = pps(),
- ?line {ok, _} =
+ {ok, _} =
dets:open_file(T,[{version, Version}, {file,Fname},
{type,duplicate_bag},
{delayed_write, DelayedWrite}]),
@@ -2757,53 +2756,53 @@ cache_dup_bags(Config, DelayedWrite, Extra, Sz, Version) ->
if
Extra ->
%% Insert enough to get three keys in some slot.
- ?line dets:safe_fixtable(T, true),
+ dets:safe_fixtable(T, true),
insert_objs(T, 1, Sz, Dups);
true ->
{1,[]}
end,
Tuple = erlang:make_tuple(Sz, Key),
- ?line ok = dets:delete(T, Key),
- ?line ok = dets:sync(T),
- ?line false = dets:member(T, Key),
+ ok = dets:delete(T, Key),
+ ok = dets:sync(T),
+ false = dets:member(T, Key),
%% The values of keys in the same slot as Key are checked.
- ?line OtherValues = sort(lookup_keys(T, OtherKeys)),
+ OtherValues = sort(lookup_keys(T, OtherKeys)),
- ?line ok = dets:insert(T, Tuple),
- ?line [Tuple] = dets:lookup(T, Key),
- ?line true = dets:member(T, Key),
- ?line ok = dets:insert(T, [Tuple,Tuple]),
+ ok = dets:insert(T, Tuple),
+ [Tuple] = dets:lookup(T, Key),
+ true = dets:member(T, Key),
+ ok = dets:insert(T, [Tuple,Tuple]),
%% If no delay, the cache gets filled immediately, and written.
- ?line [Tuple,Tuple,Tuple] = dets:lookup_keys(T, [Key,a,b,c,d,e,f]),
- ?line true = dets:member(T, Key),
+ [Tuple,Tuple,Tuple] = dets:lookup_keys(T, [Key,a,b,c,d,e,f]),
+ true = dets:member(T, Key),
%% If delay, this happens without file access.
%% (This is no longer true; cache lookup has been simplified.)
- ?line ok = dets:delete(T,Key),
- ?line ok = dets:insert(T,Tuple),
- ?line ok = dets:insert(T,Tuple),
- ?line [Tuple,Tuple] = dets:lookup(T, Key),
- ?line true = dets:member(T, Key),
- ?line ok = dets:sync(T),
- ?line [Tuple,Tuple] = dets:lookup(T, Key),
- ?line true = dets:member(T, Key),
+ ok = dets:delete(T,Key),
+ ok = dets:insert(T,Tuple),
+ ok = dets:insert(T,Tuple),
+ [Tuple,Tuple] = dets:lookup(T, Key),
+ true = dets:member(T, Key),
+ ok = dets:sync(T),
+ [Tuple,Tuple] = dets:lookup(T, Key),
+ true = dets:member(T, Key),
%% One object in the cache, one on the file.
- ?line ok = dets:delete(T,Key),
- ?line ok = dets:insert(T,Tuple),
- ?line ok = dets:sync(T),
- ?line ok = dets:insert(T,Tuple),
- ?line true = dets:member(T, Key), % should not read the file, but it does..
+ ok = dets:delete(T,Key),
+ ok = dets:insert(T,Tuple),
+ ok = dets:sync(T),
+ ok = dets:insert(T,Tuple),
+ true = dets:member(T, Key), % should not read the file, but it does..
%% Key's objects are is on file only,
%% key toto in the cache (if there is one).
- ?line ok = dets:delete(T,toto),
- ?line ok = dets:insert(T,[{toto,b},{toto,b}]),
- ?line true = sort([Tuple,Tuple,{toto,b},{toto,b}]) =:=
+ ok = dets:delete(T,toto),
+ ok = dets:insert(T,[{toto,b},{toto,b}]),
+ true = sort([Tuple,Tuple,{toto,b},{toto,b}]) =:=
sort(dets:lookup_keys(T, [Key,toto])),
- ?line true = dets:member(T, toto),
- ?line Size = dets:info(T, size),
+ true = dets:member(T, toto),
+ Size = dets:info(T, size),
%% Two objects with the same key on the file.
%% Delete them, add two objects.
@@ -2824,18 +2823,18 @@ cache_dup_bags(Config, DelayedWrite, Extra, Sz, Version) ->
del_and_ins(object, T, Size, Tuple, Key, 1),
del_and_ins(both, T, Size, Tuple, Key, 1),
- ?line OtherValues = sort(lookup_keys(T, OtherKeys)),
+ OtherValues = sort(lookup_keys(T, OtherKeys)),
if
Extra ->
%% Let the table grow for a while, if it needs to.
- ?line All1 = get_all_objects(T),
- ?line dets:safe_fixtable(T, false),
- ?line timer:sleep(1200),
- ?line OtherValues = sort(lookup_keys(T, OtherKeys)),
- ?line dets:safe_fixtable(T, true),
- ?line All2 = get_all_objects(T),
- ?line FAll2 = get_all_objects_fast(T),
- ?line true = sort(All2) =:= sort(FAll2),
+ All1 = get_all_objects(T),
+ dets:safe_fixtable(T, false),
+ timer:sleep(1200),
+ OtherValues = sort(lookup_keys(T, OtherKeys)),
+ dets:safe_fixtable(T, true),
+ All2 = get_all_objects(T),
+ FAll2 = get_all_objects_fast(T),
+ true = sort(All2) =:= sort(FAll2),
case symdiff(All1, All2) of
{[],[]} -> ok;
{X,Y} ->
@@ -2845,10 +2844,10 @@ cache_dup_bags(Config, DelayedWrite, Extra, Sz, Version) ->
true ->
ok
end,
- ?line ok = dets:close(T),
+ ok = dets:close(T),
file:delete(Fname),
- ?line check_pps(P0),
+ check_pps(P0),
ok.
lookup_keys(_T, []) ->
@@ -2859,47 +2858,47 @@ lookup_keys(T, Keys) ->
del_and_ins(W, T, Size, Obj, Key, N) ->
case W of
object ->
- ?line ok = dets:delete_object(T, Obj);
+ ok = dets:delete_object(T, Obj);
key ->
- ?line ok = dets:delete(T, Key);
+ ok = dets:delete(T, Key);
both ->
- ?line ok = dets:delete(T, Key),
- ?line ok = dets:delete_object(T, Obj)
+ ok = dets:delete(T, Key),
+ ok = dets:delete_object(T, Obj)
end,
Objs = duplicate(N, Obj),
- ?line [] = dets:lookup(T, Key),
- ?line ok = dets:insert(T, Objs),
- ?line Objs = dets:lookup_keys(T, [snurrespratt,Key]),
- ?line true = Size + length(Objs)-2 =:= dets:info(T, size),
- ?line Objs = dets:lookup(T, Key).
+ [] = dets:lookup(T, Key),
+ ok = dets:insert(T, Objs),
+ Objs = dets:lookup_keys(T, [snurrespratt,Key]),
+ true = Size + length(Objs)-2 =:= dets:info(T, size),
+ Objs = dets:lookup(T, Key).
insert_objs(T, N, Sz, Dups) ->
Seq = seq(N,N+255),
L0 = map(fun(I) -> erlang:make_tuple(Sz, I) end, Seq),
L = append(duplicate(Dups, L0)),
- ?line ok = dets:insert(T, L),
- ?line case search_slot(T, 0) of
- false ->
- insert_objs(T, N+256, Sz, Dups);
- Keys ->
- Keys
- end.
+ ok = dets:insert(T, L),
+ case search_slot(T, 0) of
+ false ->
+ insert_objs(T, N+256, Sz, Dups);
+ Keys ->
+ Keys
+ end.
search_slot(T, I) ->
- ?line case dets:slot(T, I) of
- '$end_of_table' ->
- false;
- Objs ->
- case usort(map(fun(X) -> element(1, X) end, Objs)) of
- [_, Key, _ | _] = Keys0 ->
- Keys = delete(Key, Keys0),
- {Key, Keys};
- _ ->
- search_slot(T, I+1)
- end
- end.
+ case dets:slot(T, I) of
+ '$end_of_table' ->
+ false;
+ Objs ->
+ case usort(map(fun(X) -> element(1, X) end, Objs)) of
+ [_, Key, _ | _] = Keys0 ->
+ Keys = delete(Key, Keys0),
+ {Key, Keys};
+ _ ->
+ search_slot(T, I+1)
+ end
+ end.
symdiff(L1, L2) ->
{X, _, Y} =
@@ -2912,18 +2911,18 @@ otp_4208(suite) ->
[];
otp_4208(Config) when is_list(Config) ->
Tab = otp_4208,
- ?line FName = filename(Tab, Config),
+ FName = filename(Tab, Config),
Expected = sort([{3,ghi,12},{1,abc,10},{4,jkl,13},{2,def,11}]),
file:delete(FName),
- ?line {ok, Tab} = dets:open_file(Tab, [{file,FName}]),
- ?line ok = dets:insert(Tab, [{1,abc,10},{2,def,11},{3,ghi,12},{4,jkl,13}]),
- ?line Expected = sort(dets:traverse(Tab, fun(X) -> {continue, X} end)),
- ?line ok = dets:close(Tab),
-
- ?line {ok, Tab} = dets:open_file(Tab, [{access, read},{file,FName}]),
- ?line Expected = sort(dets:traverse(Tab, fun(X) -> {continue, X} end)),
- ?line ok = dets:close(Tab),
+ {ok, Tab} = dets:open_file(Tab, [{file,FName}]),
+ ok = dets:insert(Tab, [{1,abc,10},{2,def,11},{3,ghi,12},{4,jkl,13}]),
+ Expected = sort(dets:traverse(Tab, fun(X) -> {continue, X} end)),
+ ok = dets:close(Tab),
+
+ {ok, Tab} = dets:open_file(Tab, [{access, read},{file,FName}]),
+ Expected = sort(dets:traverse(Tab, fun(X) -> {continue, X} end)),
+ ok = dets:close(Tab),
file:delete(FName),
ok.
@@ -2934,21 +2933,21 @@ otp_4989(suite) ->
[];
otp_4989(Config) when is_list(Config) ->
Tab = otp_4989,
- ?line FName = filename(Tab, Config),
+ FName = filename(Tab, Config),
%% Do exactly as in the error report.
- ?line _Ets = ets:new(Tab, [named_table]),
+ _Ets = ets:new(Tab, [named_table]),
ets_init(Tab, 100000),
- ?line {ok, Tab} =
+ {ok, Tab} =
dets:open_file(Tab, [{access, read_write}, {file,FName}, {keypos,2}]),
- ?line ok = dets:from_ets(Tab, Tab),
- ?line ok = dets:close(Tab),
+ ok = dets:from_ets(Tab, Tab),
+ ok = dets:close(Tab),
%% Restore.
- ?line {ok, Tab} =
+ {ok, Tab} =
dets:open_file(Tab, [{access, read}, {keypos, 2}, {file, FName}]),
- ?line true = ets:delete_all_objects(Tab),
- ?line true = ets:from_dets(Tab, Tab),
- ?line ok = dets:close(Tab),
+ true = ets:delete_all_objects(Tab),
+ true = ets:from_dets(Tab, Tab),
+ ok = dets:close(Tab),
ets:delete(Tab),
file:delete(FName),
ok.
@@ -2965,20 +2964,20 @@ otp_8898(suite) ->
[];
otp_8898(Config) when is_list(Config) ->
Tab = otp_8898,
- ?line FName = filename(Tab, Config),
+ FName = filename(Tab, Config),
Server = self(),
- ?line file:delete(FName),
- ?line {ok, _} = dets:open_file(Tab,[{file, FName}]),
- ?line [P1,P2,P3] = new_clients(3, Tab),
+ file:delete(FName),
+ {ok, _} = dets:open_file(Tab,[{file, FName}]),
+ [P1,P2,P3] = new_clients(3, Tab),
Seq = [{P1,[sync]},{P2,[{lookup,1,[]}]},{P3,[{insert,{1,b}}]}],
- ?line atomic_requests(Server, Tab, [[]], Seq),
- ?line true = get_replies([{P1,ok},{P2,ok},{P3,ok}]),
- ?line ok = dets:close(Tab),
- ?line {ok, _} = dets:open_file(Tab,[{file, FName}]),
- ?line file:delete(FName),
+ atomic_requests(Server, Tab, [[]], Seq),
+ true = get_replies([{P1,ok},{P2,ok},{P3,ok}]),
+ ok = dets:close(Tab),
+ {ok, _} = dets:open_file(Tab,[{file, FName}]),
+ file:delete(FName),
ok.
@@ -2988,25 +2987,25 @@ otp_8899(suite) ->
[];
otp_8899(Config) when is_list(Config) ->
Tab = many_clients,
- ?line FName = filename(Tab, Config),
+ FName = filename(Tab, Config),
Server = self(),
- ?line file:delete(FName),
- ?line {ok, _} = dets:open_file(Tab,[{file, FName},{version,9}]),
- ?line [P1,P2,P3,P4] = new_clients(4, Tab),
+ file:delete(FName),
+ {ok, _} = dets:open_file(Tab,[{file, FName},{version,9}]),
+ [P1,P2,P3,P4] = new_clients(4, Tab),
MC = [Tab],
Seq6a = [{P1,[{insert,[{used_to_be_skipped_by,match}]},
{lookup,1,[{1,a}]}]},
{P2,[{verbose,true,MC}]},
{P3,[{lookup,1,[{1,a}]}]}, {P4,[{verbose,true,MC}]}],
- ?line atomic_requests(Server, Tab, [[{1,a},{2,b},{3,c}]], Seq6a),
- ?line true = get_replies([{P1,ok}, {P2,ok}, {P3,ok}, {P4,ok}]),
- ?line [{1,a},{2,b},{3,c},{used_to_be_skipped_by,match}] =
+ atomic_requests(Server, Tab, [[{1,a},{2,b},{3,c}]], Seq6a),
+ true = get_replies([{P1,ok}, {P2,ok}, {P3,ok}, {P4,ok}]),
+ [{1,a},{2,b},{3,c},{used_to_be_skipped_by,match}] =
lists:sort(dets:match_object(Tab, '_')),
- ?line _ = dets:close(Tab),
- ?line file:delete(FName),
+ _ = dets:close(Tab),
+ file:delete(FName),
ok.
@@ -3016,14 +3015,14 @@ many_clients(suite) ->
[];
many_clients(Config) when is_list(Config) ->
Tab = many_clients,
- ?line FName = filename(Tab, Config),
+ FName = filename(Tab, Config),
Server = self(),
- ?line file:delete(FName),
+ file:delete(FName),
P0 = pps(),
- ?line {ok, _} = dets:open_file(Tab,[{file, FName},{version,9}]),
- ?line [P1,P2,P3,P4] = new_clients(4, Tab),
+ {ok, _} = dets:open_file(Tab,[{file, FName},{version,9}]),
+ [P1,P2,P3,P4] = new_clients(4, Tab),
%% dets:init_table/2 is used for making sure that all processes
%% start sending requests before the Dets process begins to handle
@@ -3034,67 +3033,67 @@ many_clients(Config) when is_list(Config) ->
%% One key is read, updated, and read again.
Seq1 = [{P1,[{lookup,1,[{1,a}]}]}, {P2,[{insert,{1,b}}]},
{P3,[{lookup,1,[{1,b}]}]}, {P4,[{lookup,1,[{1,b}]}]}],
- ?line atomic_requests(Server, Tab, [[{1,a}]], Seq1),
- ?line true = get_replies([{P1,ok}, {P2,ok}, {P3,ok}, {P4,ok}]),
+ atomic_requests(Server, Tab, [[{1,a}]], Seq1),
+ true = get_replies([{P1,ok}, {P2,ok}, {P3,ok}, {P4,ok}]),
%% Different keys read by different processes
Seq2 = [{P1,[{member,1,true}]}, {P2,[{lookup,2,[{2,b}]}]},
{P3,[{lookup,1,[{1,a}]}]}, {P4,[{lookup,3,[{3,c}]}]}],
- ?line atomic_requests(Server, Tab, [[{1,a},{2,b},{3,c}]], Seq2),
- ?line true = get_replies([{P1,ok}, {P2,ok}, {P3,ok}, {P4,ok}]),
+ atomic_requests(Server, Tab, [[{1,a},{2,b},{3,c}]], Seq2),
+ true = get_replies([{P1,ok}, {P2,ok}, {P3,ok}, {P4,ok}]),
%% Reading deleted key.
Seq3 = [{P1,[{delete_key,2}]}, {P2,[{lookup,1,[{1,a}]}]},
{P3,[{lookup,1,[{1,a}]}]}, {P4,[{member,2,false}]}],
- ?line atomic_requests(Server, Tab, [[{1,a},{2,b},{3,c}]], Seq3),
- ?line true = get_replies([{P1,ok}, {P2,ok}, {P3,ok}, {P4,ok}]),
+ atomic_requests(Server, Tab, [[{1,a},{2,b},{3,c}]], Seq3),
+ true = get_replies([{P1,ok}, {P2,ok}, {P3,ok}, {P4,ok}]),
%% Inserting objects.
Seq4 = [{P1,[{insert,[{1,a},{2,b}]}]}, {P2,[{insert,[{2,c},{3,a}]}]},
{P3,[{insert,[{3,b},{4,d}]}]},
{P4,[{lookup_keys,[1,2,3,4],[{1,a},{2,c},{3,b},{4,d}]}]}],
- ?line atomic_requests(Server, Tab, [], Seq4),
- ?line true = get_replies([{P1,ok}, {P2,ok}, {P3,ok}, {P4,ok}]),
+ atomic_requests(Server, Tab, [], Seq4),
+ true = get_replies([{P1,ok}, {P2,ok}, {P3,ok}, {P4,ok}]),
%% Deleting objects.
Seq5 = [{P1,[{delete_object,{1,a}}]}, {P2,[{delete_object,{1,a}}]},
{P3,[{delete_object,{3,c}}]},
{P4,[{lookup_keys,[1,2,3,4],[{2,b}]}]}],
- ?line atomic_requests(Server, Tab, [[{1,a},{2,b},{3,c}]], Seq5),
- ?line true = get_replies([{P1,ok}, {P2,ok}, {P3,ok}, {P4,ok}]),
+ atomic_requests(Server, Tab, [[{1,a},{2,b},{3,c}]], Seq5),
+ true = get_replies([{P1,ok}, {P2,ok}, {P3,ok}, {P4,ok}]),
%% Some request not streamed.
Seq6 = [{P1,[{lookup,1,[{1,a}]}]}, {P2,[{info,size,3}]},
{P3,[{lookup,1,[{1,a}]}]}, {P4,[{info,size,3}]}],
- ?line atomic_requests(Server, Tab, [[{1,a},{2,b},{3,c}]], Seq6),
- ?line true = get_replies([{P1,ok}, {P2,ok}, {P3,ok}, {P4,ok}]),
+ atomic_requests(Server, Tab, [[{1,a},{2,b},{3,c}]], Seq6),
+ true = get_replies([{P1,ok}, {P2,ok}, {P3,ok}, {P4,ok}]),
%% Some request not streamed.
Seq7 = [{P1,[{insert,[{3,a}]}]}, {P2,[{insert,[{3,b}]}]},
{P3,[{delete_object,{3,c}}]},
{P4,[{lookup,3,[{3,b}]}]}],
- ?line atomic_requests(Server, Tab, [[{3,c}]], Seq7),
- ?line true = get_replies([{P1,ok}, {P2,ok}, {P3,ok}, {P4,ok}]),
+ atomic_requests(Server, Tab, [[{3,c}]], Seq7),
+ true = get_replies([{P1,ok}, {P2,ok}, {P3,ok}, {P4,ok}]),
- ?line put_requests(Server, [{P1,stop},{P2,stop},{P3,stop},{P4,stop}]),
- ?line ok = dets:close(Tab),
- ?line file:delete(FName),
+ put_requests(Server, [{P1,stop},{P2,stop},{P3,stop},{P4,stop}]),
+ ok = dets:close(Tab),
+ file:delete(FName),
%% Check that errors are handled correctly by the streaming operators.
- ?line {ok, _} = dets:open_file(Tab,[{file, FName},{version,9}]),
- ?line ok = ins(Tab, 100),
+ {ok, _} = dets:open_file(Tab,[{file, FName},{version,9}]),
+ ok = ins(Tab, 100),
Obj = {66,{item,number,66}},
- ?line {ok, ObjPos} = dets:where(Tab, Obj),
- ?line ok = dets:close(Tab),
+ {ok, ObjPos} = dets:where(Tab, Obj),
+ ok = dets:close(Tab),
%% Damaged object.
crash(FName, ObjPos+12),
- ?line {ok, _} = dets:open_file(Tab,[{file, FName},{version,9}]),
- ?line BadObject1 = dets:lookup_keys(Tab, [65,66,67,68,69]),
- ?line bad_object(BadObject1, FName),
- ?line _Error = dets:close(Tab),
- ?line file:delete(FName),
+ {ok, _} = dets:open_file(Tab,[{file, FName},{version,9}]),
+ BadObject1 = dets:lookup_keys(Tab, [65,66,67,68,69]),
+ bad_object(BadObject1, FName),
+ _Error = dets:close(Tab),
+ file:delete(FName),
- ?line check_pps(P0),
+ check_pps(P0),
ok.
@@ -3120,7 +3119,7 @@ get_replies(L) ->
lists:all(fun({Pid,Reply}) -> Reply =:= get_reply(Pid) end, L).
get_reply(Pid) ->
- ?line receive {Pid, Reply} -> Reply end.
+ receive {Pid, Reply} -> Reply end.
new_clients(0, _Tab) ->
[];
@@ -3135,7 +3134,7 @@ client(S, Tab) ->
{S, stop} ->
exit(normal);
{S, ToDo} ->
- ?line Reply = eval(ToDo, Tab),
+ Reply = eval(ToDo, Tab),
case Reply of
{error, _} -> io:format("~p: ~p~n", [self(), Reply]);
_ -> ok
@@ -3147,55 +3146,55 @@ client(S, Tab) ->
eval([], _Tab) ->
ok;
eval([{verbose,Bool,Expected} | L], Tab) ->
- ?line case dets:verbose(Bool) of
- Expected -> eval(L, Tab);
- Error -> {error, {verbose,Error}}
- end;
+ case dets:verbose(Bool) of
+ Expected -> eval(L, Tab);
+ Error -> {error, {verbose,Error}}
+ end;
eval([sync | L], Tab) ->
- ?line case dets:sync(Tab) of
- ok -> eval(L, Tab);
- Error -> {error, {sync,Error}}
- end;
+ case dets:sync(Tab) of
+ ok -> eval(L, Tab);
+ Error -> {error, {sync,Error}}
+ end;
eval([{insert,Stuff} | L], Tab) ->
- ?line case dets:insert(Tab, Stuff) of
- ok -> eval(L, Tab);
- Error -> {error, {insert,Stuff,Error}}
- end;
+ case dets:insert(Tab, Stuff) of
+ ok -> eval(L, Tab);
+ Error -> {error, {insert,Stuff,Error}}
+ end;
eval([{lookup,Key,Expected} | L], Tab) ->
- ?line case dets:lookup(Tab, Key) of
- Expected -> eval(L, Tab);
- Else -> {error, {lookup,Key,Expected,Else}}
- end;
+ case dets:lookup(Tab, Key) of
+ Expected -> eval(L, Tab);
+ Else -> {error, {lookup,Key,Expected,Else}}
+ end;
eval([{lookup_keys,Keys,Expected} | L], Tab) ->
%% Time order is destroyed...
- ?line case dets:lookup_keys(Tab, Keys) of
- R when is_list(R) ->
- case lists:sort(Expected) =:= lists:sort(R) of
- true -> eval(L, Tab);
- false -> {error, {lookup_keys,Keys,Expected,R}}
- end;
- Else -> {error, {lookup_keys,Keys,Expected,Else}}
- end;
+ case dets:lookup_keys(Tab, Keys) of
+ R when is_list(R) ->
+ case lists:sort(Expected) =:= lists:sort(R) of
+ true -> eval(L, Tab);
+ false -> {error, {lookup_keys,Keys,Expected,R}}
+ end;
+ Else -> {error, {lookup_keys,Keys,Expected,Else}}
+ end;
eval([{member,Key,Expected} | L], Tab) ->
- ?line case dets:member(Tab, Key) of
- Expected -> eval(L, Tab);
- Else -> {error, {member,Key,Expected,Else}}
- end;
+ case dets:member(Tab, Key) of
+ Expected -> eval(L, Tab);
+ Else -> {error, {member,Key,Expected,Else}}
+ end;
eval([{delete_key,Key} | L], Tab) ->
- ?line case dets:delete(Tab, Key) of
- ok -> eval(L, Tab);
- Else -> {error, {delete_key,Key,Else}}
- end;
+ case dets:delete(Tab, Key) of
+ ok -> eval(L, Tab);
+ Else -> {error, {delete_key,Key,Else}}
+ end;
eval([{delete_object,Object} | L], Tab) ->
- ?line case dets:delete_object(Tab, Object) of
- ok -> eval(L, Tab);
- Else -> {error, {delete_object,Object,Else}}
- end;
+ case dets:delete_object(Tab, Object) of
+ ok -> eval(L, Tab);
+ Else -> {error, {delete_object,Object,Else}}
+ end;
eval([{info,Tag,Expected} | L], Tab) ->
- ?line case dets:info(Tab, Tag) of
- Expected -> eval(L, Tab);
- Else -> {error, {info,Tag,Else,Expected}}
- end;
+ case dets:info(Tab, Tag) of
+ Expected -> eval(L, Tab);
+ Else -> {error, {info,Tag,Else,Expected}}
+ end;
eval(Else, _Tab) ->
{error, {bad_request,Else}}.
@@ -3206,44 +3205,44 @@ otp_4906(suite) ->
otp_4906(Config) when is_list(Config) ->
N = 256*512 + 400,
Tab = otp_4906,
- ?line FName = filename(Tab, Config),
+ FName = filename(Tab, Config),
file:delete(FName),
- ?line {ok, Tab} = dets:open_file(Tab, [{file, FName}]),
- ?line ok = ins_small(Tab, 0, N),
- ?line ok = dets:close(Tab),
- ?line {ok, Tab} = dets:open_file(Tab, [{file, FName}]),
- ?line ok = read_4906(Tab, N-1),
- ?line ok = dets:close(Tab),
+ {ok, Tab} = dets:open_file(Tab, [{file, FName}]),
+ ok = ins_small(Tab, 0, N),
+ ok = dets:close(Tab),
+ {ok, Tab} = dets:open_file(Tab, [{file, FName}]),
+ ok = read_4906(Tab, N-1),
+ ok = dets:close(Tab),
file:delete(FName),
%% If the (only) process fixing a table updates the table, the
%% process will no longer be punished with a 1 ms delay (hm, the
%% server is delayed, it should be the client...). In this example
%% the writing process *is* delayed.
- ?line {ok,Tab} = dets:open_file(Tab, [{file,FName}]),
+ {ok,Tab} = dets:open_file(Tab, [{file,FName}]),
Parent = self(),
FixPid = spawn_link(fun() ->
dets:safe_fixtable(Tab, true),
receive {Parent, stop} -> ok end
end),
- ?line ok = ins_small(Tab, 0, 1000),
+ ok = ins_small(Tab, 0, 1000),
FixPid ! {Parent, stop},
timer:sleep(1),
- ?line ok = dets:close(Tab),
+ ok = dets:close(Tab),
file:delete(FName),
ok.
read_4906(_T, N) when N < 0 ->
ok;
read_4906(T, N) ->
- ?line [_] = dets:lookup(T, N),
+ [_] = dets:lookup(T, N),
read_4906(T, N-1).
ins_small(_T, I, N) when I =:= N ->
ok;
ins_small(T, I, N) ->
- ?line ok = dets:insert(T, {I}),
+ ok = dets:insert(T, {I}),
ins_small(T, I+1, N).
otp_5402(doc) ->
@@ -3252,28 +3251,28 @@ otp_5402(suite) ->
[];
otp_5402(Config) when is_list(Config) ->
Tab = otp_5402,
- ?line File = filename:join(["cannot", "write", "this", "file"]),
+ File = filename:join(["cannot", "write", "this", "file"]),
%% close
- ?line{ok, T} = dets:open_file(Tab, [{ram_file,true},
- {file, File}]),
- ?line ok = dets:insert(T, {1,a}),
- ?line {error,{file_error,_,_}} = dets:close(T),
+ {ok, T} = dets:open_file(Tab, [{ram_file,true},
+ {file, File}]),
+ ok = dets:insert(T, {1,a}),
+ {error,{file_error,_,_}} = dets:close(T),
%% sync
- ?line {ok, T} = dets:open_file(Tab, [{ram_file,true},
- {file, File}]),
- ?line ok = dets:insert(T, {1,a}),
- ?line {error,{file_error,_,_}} = dets:sync(T),
- ?line {error,{file_error,_,_}} = dets:close(T),
+ {ok, T} = dets:open_file(Tab, [{ram_file,true},
+ {file, File}]),
+ ok = dets:insert(T, {1,a}),
+ {error,{file_error,_,_}} = dets:sync(T),
+ {error,{file_error,_,_}} = dets:close(T),
%% auto_save
- ?line {ok, T} = dets:open_file(Tab, [{ram_file,true},
- {auto_save, 2000},
- {file, File}]),
- ?line ok = dets:insert(T, {1,a}),
- ?line timer:sleep(5000),
- ?line {error,{file_error,_,_}} = dets:close(T),
+ {ok, T} = dets:open_file(Tab, [{ram_file,true},
+ {auto_save, 2000},
+ {file, File}]),
+ ok = dets:insert(T, {1,a}),
+ timer:sleep(5000),
+ {error,{file_error,_,_}} = dets:close(T),
ok.
simultaneous_open(doc) ->
@@ -3284,12 +3283,12 @@ simultaneous_open(Config) ->
Tab = sim_open,
File = filename(Tab, Config),
- ?line ok = monit(Tab, File),
- ?line ok = kill_while_repairing(Tab, File),
- ?line ok = kill_while_init(Tab, File),
- ?line ok = open_ro(Tab, File),
- ?line ok = open_w(Tab, File, 0, Config),
- ?line ok = open_w(Tab, File, 100, Config),
+ ok = monit(Tab, File),
+ ok = kill_while_repairing(Tab, File),
+ ok = kill_while_init(Tab, File),
+ ok = open_ro(Tab, File),
+ ok = open_w(Tab, File, 0, Config),
+ ok = open_w(Tab, File, 100, Config),
ok.
%% One process logs and another process closes the log. Before
@@ -3382,9 +3381,9 @@ kill_while_init(Tab, File) ->
receive {Parent, die} -> ok end,
{error, not_owner} = dets:close(Tab)
end,
- ?line P1 = spawn(F),
- ?line P2 = spawn(F),
- ?line P3 = spawn(F),
+ P1 = spawn(F),
+ P2 = spawn(F),
+ P3 = spawn(F),
IF = fun() ->
R = dets:open_file(Tab, [{file,File}]),
Parent ! {self(), R},
@@ -3392,27 +3391,27 @@ kill_while_init(Tab, File) ->
{'EXIT', {badarg, _}} = (catch dets:init_table(Tab, Fun)),
receive {Parent, die} -> ok end
end,
- ?line P4 = spawn(IF),
- ?line receive {P1,R1} -> {ok, _} = R1 end,
- ?line receive {P2,R2} -> {ok, _} = R2 end,
- ?line receive {P3,R3} -> {ok, _} = R3 end,
- ?line receive {P4,R4} -> {ok, _} = R4 end,
+ P4 = spawn(IF),
+ receive {P1,R1} -> {ok, _} = R1 end,
+ receive {P2,R2} -> {ok, _} = R2 end,
+ receive {P3,R3} -> {ok, _} = R3 end,
+ receive {P4,R4} -> {ok, _} = R4 end,
DetsPid = find_dets_pid(),
exit(DetsPid, kill),
timer:sleep(1000),
- ?line undefined = dets:info(Tab),
- ?line P1 ! {Parent, die},
- ?line P2 ! {Parent, die},
- ?line P3 ! {Parent, die},
- ?line P4 ! {Parent, die},
+ undefined = dets:info(Tab),
+ P1 ! {Parent, die},
+ P2 ! {Parent, die},
+ P3 ! {Parent, die},
+ P4 ! {Parent, die},
file:delete(File),
timer:sleep(100),
ok.
open_ro(Tab, File) ->
- ?line create_opened_log(File),
+ create_opened_log(File),
Delay = 1000,
Parent = self(),
F = fun() ->
@@ -3420,47 +3419,47 @@ open_ro(Tab, File) ->
timer:sleep(Delay),
Parent ! {self(), R}
end,
- ?line P1 = spawn(F),
- ?line P2 = spawn(F),
- ?line P3 = spawn(F),
+ P1 = spawn(F),
+ P2 = spawn(F),
+ P3 = spawn(F),
- ?line receive {P1,R1} -> {error,{not_closed,_}} = R1 end,
- ?line receive {P2,R2} -> {error,{not_closed,_}} = R2 end,
- ?line receive {P3,R3} -> {error,{not_closed,_}} = R3 end,
+ receive {P1,R1} -> {error,{not_closed,_}} = R1 end,
+ receive {P2,R2} -> {error,{not_closed,_}} = R2 end,
+ receive {P3,R3} -> {error,{not_closed,_}} = R3 end,
ok.
open_w(Tab, File, Delay, Config) ->
- ?line create_opened_log(File),
+ create_opened_log(File),
Parent = self(),
F = fun() ->
R = dets:open_file(Tab, [{file,File}]),
timer:sleep(Delay),
Parent ! {self(), R}
end,
- ?line Pid1 = spawn(F),
- ?line Pid2 = spawn(F),
- ?line Pid3 = spawn(F),
- ?line undefined = dets:info(Tab), % is repairing now
- ?line 0 = qlen(),
+ Pid1 = spawn(F),
+ Pid2 = spawn(F),
+ Pid3 = spawn(F),
+ undefined = dets:info(Tab), % is repairing now
+ 0 = qlen(),
Tab2 = t2,
File2 = filename(Tab2, Config),
- ?line file:delete(File2),
- ?line {ok,Tab2} = dets:open_file(Tab2, [{file,File2}]),
- ?line ok = dets:close(Tab2),
- ?line file:delete(File2),
- ?line 0 = qlen(), % still repairing
-
- ?line receive {Pid1,R1} -> {ok, Tab} = R1 end,
- ?line receive {Pid2,R2} -> {ok, Tab} = R2 end,
- ?line receive {Pid3,R3} -> {ok, Tab} = R3 end,
+ file:delete(File2),
+ {ok,Tab2} = dets:open_file(Tab2, [{file,File2}]),
+ ok = dets:close(Tab2),
+ file:delete(File2),
+ 0 = qlen(), % still repairing
+
+ receive {Pid1,R1} -> {ok, Tab} = R1 end,
+ receive {Pid2,R2} -> {ok, Tab} = R2 end,
+ receive {Pid3,R3} -> {ok, Tab} = R3 end,
timer:sleep(200),
case dets:info(Tab) of
undefined ->
ok;
_Info ->
timer:sleep(5000),
- ?line undefined = dets:info(Tab)
+ undefined = dets:info(Tab)
end,
file:delete(File),
@@ -3473,10 +3472,10 @@ qlen() ->
create_opened_log(File) ->
Tab = t,
file:delete(File),
- ?line {ok, Tab} = dets:open_file(Tab, [{file,File}]),
- ?line ok = ins(Tab, 60000),
- ?line ok = dets:close(Tab),
- ?line crash(File, ?CLOSED_PROPERLY_POS+3, ?NOT_PROPERLY_CLOSED),
+ {ok, Tab} = dets:open_file(Tab, [{file,File}]),
+ ok = ins(Tab, 60000),
+ ok = dets:close(Tab),
+ crash(File, ?CLOSED_PROPERLY_POS+3, ?NOT_PROPERLY_CLOSED),
ok.
insert_new(doc) ->
@@ -3487,24 +3486,24 @@ insert_new(Config) ->
Tab = insert_new,
File = filename(Tab, Config),
file:delete(File),
- ?line {ok, T} = dets:open_file(Tab, [{file,File}]),
- ?line {'EXIT', {badarg, _}} = (catch dets:insert_new(Tab, 14)),
- ?line {'EXIT', {badarg, _}} = (catch dets:insert_new(Tab, {})),
- ?line true = dets:insert_new(Tab, {1,a}),
- ?line false = dets:insert_new(Tab, {1,a}),
- ?line true = dets:insert_new(Tab, [{2,b}, {3,c}]),
- ?line false = dets:insert_new(Tab, [{2,b}, {3,c}]),
- ?line false = dets:insert_new(Tab, [{1,a}, {4,d}]),
- ?line ok = dets:close(Tab),
+ {ok, T} = dets:open_file(Tab, [{file,File}]),
+ {'EXIT', {badarg, _}} = (catch dets:insert_new(Tab, 14)),
+ {'EXIT', {badarg, _}} = (catch dets:insert_new(Tab, {})),
+ true = dets:insert_new(Tab, {1,a}),
+ false = dets:insert_new(Tab, {1,a}),
+ true = dets:insert_new(Tab, [{2,b}, {3,c}]),
+ false = dets:insert_new(Tab, [{2,b}, {3,c}]),
+ false = dets:insert_new(Tab, [{1,a}, {4,d}]),
+ ok = dets:close(Tab),
file:delete(File),
- ?line {ok, T} = dets:open_file(Tab, [{file,File},{type,bag}]),
- ?line true = dets:insert_new(Tab, {1,a}),
- ?line false = dets:insert_new(Tab, {1,b}),
- ?line true = dets:insert_new(Tab, [{2,b}, {3,c}]),
- ?line false = dets:insert_new(Tab, [{2,a}, {3,d}]),
- ?line false = dets:insert_new(Tab, [{1,a}, {4,d}]),
- ?line ok = dets:close(Tab),
+ {ok, T} = dets:open_file(Tab, [{file,File},{type,bag}]),
+ true = dets:insert_new(Tab, {1,a}),
+ false = dets:insert_new(Tab, {1,b}),
+ true = dets:insert_new(Tab, [{2,b}, {3,c}]),
+ false = dets:insert_new(Tab, [{2,a}, {3,d}]),
+ false = dets:insert_new(Tab, [{1,a}, {4,d}]),
+ ok = dets:close(Tab),
file:delete(File),
@@ -3516,24 +3515,24 @@ repair_continuation(suite) ->
[];
repair_continuation(Config) ->
Tab = repair_continuation_table,
- ?line Fname = filename(repair_cont, Config),
- ?line file:delete(Fname),
- ?line {ok, _} = dets:open_file(Tab, [{file,Fname}]),
- ?line ok = dets:insert(Tab, [{1,a},{2,b},{3,c}]),
-
- ?line MS = [{'_',[],[true]}],
-
- ?line {[true], C1} = dets:select(Tab, MS, 1),
- ?line C2 = binary_to_term(term_to_binary(C1)),
- ?line {'EXIT', {badarg, _}} = (catch dets:select(C2)),
- ?line C3 = dets:repair_continuation(C2, MS),
- ?line {[true], C4} = dets:select(C3),
- ?line C5 = dets:repair_continuation(C4, MS),
- ?line {[true], _} = dets:select(C5),
- ?line {'EXIT', {badarg, _}} = (catch dets:repair_continuation(Tab, bu)),
-
- ?line ok = dets:close(Tab),
- ?line file:delete(Fname),
+ Fname = filename(repair_cont, Config),
+ file:delete(Fname),
+ {ok, _} = dets:open_file(Tab, [{file,Fname}]),
+ ok = dets:insert(Tab, [{1,a},{2,b},{3,c}]),
+
+ MS = [{'_',[],[true]}],
+
+ {[true], C1} = dets:select(Tab, MS, 1),
+ C2 = binary_to_term(term_to_binary(C1)),
+ {'EXIT', {badarg, _}} = (catch dets:select(C2)),
+ C3 = dets:repair_continuation(C2, MS),
+ {[true], C4} = dets:select(C3),
+ C5 = dets:repair_continuation(C4, MS),
+ {[true], _} = dets:select(C5),
+ {'EXIT', {badarg, _}} = (catch dets:repair_continuation(Tab, bu)),
+
+ ok = dets:close(Tab),
+ file:delete(Fname),
ok.
otp_5487(doc) ->
@@ -3547,20 +3546,20 @@ otp_5487(Config) ->
otp_5487(Config, Version) ->
Tab = otp_5487,
- ?line Fname = filename(otp_5487, Config),
- ?line file:delete(Fname),
- ?line Ets = ets:new(otp_5487, [public, set]),
- ?line lists:foreach(fun(I) -> ets:insert(Ets, {I,I+1}) end,
- lists:seq(0,1000)),
- ?line {ok, _} = dets:open_file(Tab, [{file,Fname},{version,Version}]),
- ?line ok = dets:from_ets(Tab, Ets),
- ?line ok = dets:sync(Tab),
- ?line ok = dets:close(Tab),
- ?line {ok, _} = dets:open_file(Tab, [{file,Fname},{access,read}]),
- ?line [{1,2}] = dets:lookup(Tab, 1),
- ?line ok = dets:close(Tab),
- ?line ets:delete(Ets),
- ?line file:delete(Fname).
+ Fname = filename(otp_5487, Config),
+ file:delete(Fname),
+ Ets = ets:new(otp_5487, [public, set]),
+ lists:foreach(fun(I) -> ets:insert(Ets, {I,I+1}) end,
+ lists:seq(0,1000)),
+ {ok, _} = dets:open_file(Tab, [{file,Fname},{version,Version}]),
+ ok = dets:from_ets(Tab, Ets),
+ ok = dets:sync(Tab),
+ ok = dets:close(Tab),
+ {ok, _} = dets:open_file(Tab, [{file,Fname},{access,read}]),
+ [{1,2}] = dets:lookup(Tab, 1),
+ ok = dets:close(Tab),
+ ets:delete(Ets),
+ file:delete(Fname).
otp_6206(doc) ->
["OTP-6206. Badly formed free lists."];
@@ -3572,15 +3571,15 @@ otp_6206(Config) ->
file:delete(File),
Options = [{file,File}],
- ?line {ok, Tab} = dets:open_file(Tab, Options),
+ {ok, Tab} = dets:open_file(Tab, Options),
NObjs = 13006,
- ?line ok = ins(Tab, NObjs),
- ?line ok = del(Tab, NObjs, 2),
- ?line ok = dets:close(Tab),
+ ok = ins(Tab, NObjs),
+ ok = del(Tab, NObjs, 2),
+ ok = dets:close(Tab),
%% Used to return {badmatch,{error,{bad_freelists,File}}.
- ?line {ok, Tab} = dets:open_file(Tab, [{repair,false}|Options]),
- ?line ok = dets:close(Tab),
+ {ok, Tab} = dets:open_file(Tab, [{repair,false}|Options]),
+ ok = dets:close(Tab),
file:delete(File),
ok.
@@ -3593,10 +3592,10 @@ otp_6359(Config) ->
File = filename(Tab, Config),
file:delete(File),
- ?line {ok, _} = dets:open_file(Tab, [{file, File}]),
+ {ok, _} = dets:open_file(Tab, [{file, File}]),
%% Used to return {[], Cont}:
- ?line '$end_of_table' = dets:match(Tab, '_', 100),
- ?line ok = dets:close(Tab),
+ '$end_of_table' = dets:match(Tab, '_', 100),
+ ok = dets:close(Tab),
file:delete(File),
ok.
@@ -3621,47 +3620,47 @@ otp_4738_dupbag(Version, Config) ->
One = 1,
FOne = float(One),
Args = [{file,File},{type,duplicate_bag},{version,Version}],
- ?line {ok, Tab} = dets:open_file(Tab, Args),
- ?line ok = dets:insert(Tab, [{I,One},{F,One},{I,FOne},{F,FOne}]),
- ?line ok = dets:sync(Tab),
- ?line [{F,One},{F,FOne}] = dets:lookup(Tab, F),
- ?line [{I,One},{I,FOne}] = dets:lookup(Tab, I),
- ?line ok = dets:insert(Tab, [{F,One},{F,FOne}]),
- ?line [{I,One},{I,FOne},{F,One},{F,FOne},{F,One},{F,FOne}] =
+ {ok, Tab} = dets:open_file(Tab, Args),
+ ok = dets:insert(Tab, [{I,One},{F,One},{I,FOne},{F,FOne}]),
+ ok = dets:sync(Tab),
+ [{F,One},{F,FOne}] = dets:lookup(Tab, F),
+ [{I,One},{I,FOne}] = dets:lookup(Tab, I),
+ ok = dets:insert(Tab, [{F,One},{F,FOne}]),
+ [{I,One},{I,FOne},{F,One},{F,FOne},{F,One},{F,FOne}] =
dets_utils:mkeysort(1, dets:match_object(Tab, '_')),
- ?line ok = dets:insert(Tab, [{F,FOne},{F,One}]),
- ?line [{I,One},{I,FOne},{F,One},{F,FOne},{F,One},
+ ok = dets:insert(Tab, [{F,FOne},{F,One}]),
+ [{I,One},{I,FOne},{F,One},{F,FOne},{F,One},
{F,FOne},{F,FOne},{F,One}] =
dets_utils:mkeysort(1, dets:match_object(Tab, '_')),
- ?line ok = dets:delete_object(Tab, {I,FOne}),
- ?line [{I,One},{F,One},{F,FOne},{F,One},{F,FOne},{F,FOne},{F,One}] =
+ ok = dets:delete_object(Tab, {I,FOne}),
+ [{I,One},{F,One},{F,FOne},{F,One},{F,FOne},{F,FOne},{F,One}] =
dets_utils:mkeysort(1, dets:match_object(Tab, '_')),
- ?line ok = dets:insert(Tab, {I,FOne}),
- ?line [{I,One},{I,FOne},{F,One},{F,FOne},{F,One},
+ ok = dets:insert(Tab, {I,FOne}),
+ [{I,One},{I,FOne},{F,One},{F,FOne},{F,One},
{F,FOne},{F,FOne},{F,One}] =
dets_utils:mkeysort(1, dets:match_object(Tab, '_')),
- ?line ok = dets:delete_object(Tab, {F,FOne}),
- ?line [{I,One},{I,FOne},{F,One},{F,One},{F,One}] =
+ ok = dets:delete_object(Tab, {F,FOne}),
+ [{I,One},{I,FOne},{F,One},{F,One},{F,One}] =
dets_utils:mkeysort(1, dets:match_object(Tab, '_')),
- ?line ok = dets:delete(Tab, F),
- ?line [{I,One},{I,FOne}] = dets:match_object(Tab, '_'),
- ?line ok = dets:close(Tab),
+ ok = dets:delete(Tab, F),
+ [{I,One},{I,FOne}] = dets:match_object(Tab, '_'),
+ ok = dets:close(Tab),
file:delete(File),
Zero = 0,
FZero = float(Zero),
- ?line {ok, Tab} = dets:open_file(Tab, Args),
- ?line ok = dets:insert(Tab, [{I,One},{F,One},{I,FOne},{F,FOne}]),
- ?line ok = dets:insert(Tab, [{I,One},{F,One},{I,FOne},{F,FOne}]),
- ?line ok = dets:insert(Tab, [{I,Zero},{F,Zero},{I,FZero},{I,FZero}]),
- ?line Objs0 = dets_utils:mkeysort(1, dets:match_object(Tab, '_')),
- ?line ok = dets:close(Tab),
+ {ok, Tab} = dets:open_file(Tab, Args),
+ ok = dets:insert(Tab, [{I,One},{F,One},{I,FOne},{F,FOne}]),
+ ok = dets:insert(Tab, [{I,One},{F,One},{I,FOne},{F,FOne}]),
+ ok = dets:insert(Tab, [{I,Zero},{F,Zero},{I,FZero},{I,FZero}]),
+ Objs0 = dets_utils:mkeysort(1, dets:match_object(Tab, '_')),
+ ok = dets:close(Tab),
crash(File, ?CLOSED_PROPERLY_POS+3, ?NOT_PROPERLY_CLOSED),
io:format("Expect repair:~n"),
- ?line {ok, Tab} = dets:open_file(Tab, Args),
- ?line Objs1 = dets_utils:mkeysort(1, dets:match_object(Tab, '_')),
- ?line ok = dets:close(Tab),
- ?line Objs1 = Objs0,
+ {ok, Tab} = dets:open_file(Tab, Args),
+ Objs1 = dets_utils:mkeysort(1, dets:match_object(Tab, '_')),
+ ok = dets:close(Tab),
+ Objs1 = Objs0,
file:delete(File),
ok.
@@ -3674,26 +3673,26 @@ otp_4738_bag(Version, Config) ->
One = 1,
FOne = float(One),
Args = [{file,File},{type,bag},{version,Version}],
- ?line {ok, Tab} = dets:open_file(Tab, Args),
- ?line ok = dets:insert(Tab, [{I,One},{F,One},{I,FOne},{F,FOne}]),
- ?line ok = dets:sync(Tab),
- ?line [{F,One},{F,FOne}] = dets:lookup(Tab, F),
- ?line [{I,One},{I,FOne}] = dets:lookup(Tab, I),
- ?line ok = dets:insert(Tab, [{F,One},{F,FOne}]),
- ?line [{I,One},{I,FOne},{F,One},{F,FOne}] =
+ {ok, Tab} = dets:open_file(Tab, Args),
+ ok = dets:insert(Tab, [{I,One},{F,One},{I,FOne},{F,FOne}]),
+ ok = dets:sync(Tab),
+ [{F,One},{F,FOne}] = dets:lookup(Tab, F),
+ [{I,One},{I,FOne}] = dets:lookup(Tab, I),
+ ok = dets:insert(Tab, [{F,One},{F,FOne}]),
+ [{I,One},{I,FOne},{F,One},{F,FOne}] =
dets_utils:mkeysort(1, dets:match_object(Tab, '_')),
- ?line ok = dets:insert(Tab, [{F,FOne},{F,One}]),
- ?line [{I,One},{I,FOne},{F,FOne},{F,One}] =
+ ok = dets:insert(Tab, [{F,FOne},{F,One}]),
+ [{I,One},{I,FOne},{F,FOne},{F,One}] =
dets_utils:mkeysort(1, dets:match_object(Tab, '_')),
- ?line ok = dets:delete_object(Tab, {I,FOne}),
- ?line [{I,One},{F,FOne},{F,One}] =
+ ok = dets:delete_object(Tab, {I,FOne}),
+ [{I,One},{F,FOne},{F,One}] =
dets_utils:mkeysort(1, dets:match_object(Tab, '_')),
- ?line ok = dets:insert(Tab, {I,FOne}),
- ?line [{I,One},{I,FOne},{F,FOne},{F,One}] =
+ ok = dets:insert(Tab, {I,FOne}),
+ [{I,One},{I,FOne},{F,FOne},{F,One}] =
dets_utils:mkeysort(1, dets:match_object(Tab, '_')),
- ?line ok = dets:delete(Tab, F),
- ?line [{I,One},{I,FOne}] = dets:match_object(Tab, '_'),
- ?line ok = dets:close(Tab),
+ ok = dets:delete(Tab, F),
+ [{I,One},{I,FOne}] = dets:match_object(Tab, '_'),
+ ok = dets:close(Tab),
file:delete(File).
otp_4738_set(Version, Config) ->
@@ -3705,53 +3704,53 @@ otp_4738_set(Version, Config) ->
%% I and F share the same slot.
I = -12857447,
F = float(I),
- ?line {ok, Tab} = dets:open_file(Tab, Args),
- ?line ok = dets:insert(Tab, [{I},{F}]),
- ?line ok = dets:sync(Tab),
- ?line [{F}] = dets:lookup(Tab, F),
- ?line [{I}] = dets:lookup(Tab, I),
- ?line ok = dets:insert(Tab, [{F}]),
- ?line [{I},{F}] = dets_utils:mkeysort(1, dets:match_object(Tab, '_')),
- ?line ok = dets:close(Tab),
+ {ok, Tab} = dets:open_file(Tab, Args),
+ ok = dets:insert(Tab, [{I},{F}]),
+ ok = dets:sync(Tab),
+ [{F}] = dets:lookup(Tab, F),
+ [{I}] = dets:lookup(Tab, I),
+ ok = dets:insert(Tab, [{F}]),
+ [{I},{F}] = dets_utils:mkeysort(1, dets:match_object(Tab, '_')),
+ ok = dets:close(Tab),
file:delete(File),
- ?line {ok, Tab} = dets:open_file(Tab, Args),
- ?line ok = dets:insert(Tab, [{I}]),
- ?line ok = dets:sync(Tab),
- ?line [] = dets:lookup(Tab, F),
- ?line [{I}] = dets:lookup(Tab, I),
- ?line ok = dets:insert(Tab, [{F}]),
- ?line [{I},{F}] = dets_utils:mkeysort(1, dets:match_object(Tab, '_')),
- ?line ok = dets:close(Tab),
+ {ok, Tab} = dets:open_file(Tab, Args),
+ ok = dets:insert(Tab, [{I}]),
+ ok = dets:sync(Tab),
+ [] = dets:lookup(Tab, F),
+ [{I}] = dets:lookup(Tab, I),
+ ok = dets:insert(Tab, [{F}]),
+ [{I},{F}] = dets_utils:mkeysort(1, dets:match_object(Tab, '_')),
+ ok = dets:close(Tab),
file:delete(File),
- ?line {ok, Tab} = dets:open_file(Tab, Args),
+ {ok, Tab} = dets:open_file(Tab, Args),
ok = dets:insert(Tab, [{I},{F}]),
%% {insert, ...} in the cache, try lookup:
- ?line [{F}] = dets:lookup(Tab, F),
- ?line [{I}] = dets:lookup(Tab, I),
+ [{F}] = dets:lookup(Tab, F),
+ [{I}] = dets:lookup(Tab, I),
%% Both were found, but that cannot be verified.
- ?line [{I},{F}] = dets_utils:mkeysort(1, dets:match_object(Tab, '_')),
- ?line ok = dets:close(Tab),
+ [{I},{F}] = dets_utils:mkeysort(1, dets:match_object(Tab, '_')),
+ ok = dets:close(Tab),
file:delete(File),
- ?line {ok, Tab} = dets:open_file(Tab, Args),
- ?line ok = dets:insert(Tab, [{I}]),
- ?line ok = dets:sync(Tab),
- ?line ok = dets:insert(Tab, [{F}]),
+ {ok, Tab} = dets:open_file(Tab, Args),
+ ok = dets:insert(Tab, [{I}]),
+ ok = dets:sync(Tab),
+ ok = dets:insert(Tab, [{F}]),
%% {insert, ...} in the cache, try lookup:
- ?line [{F}] = dets:lookup(Tab, F),
- ?line [{I}] = dets:lookup(Tab, I),
- ?line [{I},{F}] = dets_utils:mkeysort(1, dets:match_object(Tab, '_')),
- ?line ok = dets:close(Tab),
+ [{F}] = dets:lookup(Tab, F),
+ [{I}] = dets:lookup(Tab, I),
+ [{I},{F}] = dets_utils:mkeysort(1, dets:match_object(Tab, '_')),
+ ok = dets:close(Tab),
file:delete(File),
- ?line {ok, Tab} = dets:open_file(Tab, Args),
+ {ok, Tab} = dets:open_file(Tab, Args),
%% Both operations in the cache:
- ?line ok = dets:insert(Tab, [{I}]),
- ?line ok = dets:insert(Tab, [{F}]),
- ?line [{I},{F}] = dets_utils:mkeysort(1, dets:match_object(Tab, '_')),
- ?line ok = dets:close(Tab),
+ ok = dets:insert(Tab, [{I}]),
+ ok = dets:insert(Tab, [{F}]),
+ [{I},{F}] = dets_utils:mkeysort(1, dets:match_object(Tab, '_')),
+ ok = dets:close(Tab),
file:delete(File),
ok.
@@ -3765,9 +3764,9 @@ otp_7146(Config) ->
file:delete(File),
Max = 2048,
- ?line {ok, Tab} = dets:open_file(Tab, [{max_no_slots,Max}, {file,File}]),
+ {ok, Tab} = dets:open_file(Tab, [{max_no_slots,Max}, {file,File}]),
write_dets(Tab, Max),
- ?line ok = dets:close(Tab),
+ ok = dets:close(Tab),
file:delete(File),
ok.
@@ -3789,11 +3788,11 @@ otp_8070(Config) when is_list(Config) ->
Tab = otp_8070,
File = filename(Tab, Config),
file:delete(File),
- ?line {ok, _} = dets:open_file(Tab, [{file,File},{type, duplicate_bag}]),
- ?line ok = dets:insert(Tab, [{3,0}]),
- ?line false = dets:insert_new(Tab, [{3,1},{3,1}]),
- ?line [{3,0}] = dets:lookup(Tab, 3),
- ?line ok = dets:close(Tab),
+ {ok, _} = dets:open_file(Tab, [{file,File},{type, duplicate_bag}]),
+ ok = dets:insert(Tab, [{3,0}]),
+ false = dets:insert_new(Tab, [{3,1},{3,1}]),
+ [{3,0}] = dets:lookup(Tab, 3),
+ ok = dets:close(Tab),
file:delete(File),
ok.
@@ -3806,19 +3805,19 @@ otp_8856(Config) when is_list(Config) ->
File = filename(Tab, Config),
file:delete(File),
Me = self(),
- ?line {ok, _} = dets:open_file(Tab, [{type, bag}, {file, File}]),
+ {ok, _} = dets:open_file(Tab, [{type, bag}, {file, File}]),
spawn(fun()-> Me ! {1, dets:insert(Tab, [])} end),
spawn(fun()-> Me ! {2, dets:insert_new(Tab, [])} end),
- ?line ok = dets:close(Tab),
- ?line receive {1, ok} -> ok end,
- ?line receive {2, true} -> ok end,
+ ok = dets:close(Tab),
+ receive {1, ok} -> ok end,
+ receive {2, true} -> ok end,
file:delete(File),
- ?line {ok, _} = dets:open_file(Tab, [{type, set}, {file, File}]),
+ {ok, _} = dets:open_file(Tab, [{type, set}, {file, File}]),
spawn(fun() -> dets:delete(Tab, 0) end),
spawn(fun() -> Me ! {3, dets:insert_new(Tab, {0,0})} end),
- ?line ok = dets:close(Tab),
- ?line receive {3, true} -> ok end,
+ ok = dets:close(Tab),
+ receive {3, true} -> ok end,
file:delete(File),
ok.
@@ -3829,19 +3828,19 @@ otp_8903(suite) ->
otp_8903(Config) when is_list(Config) ->
Tab = otp_8903,
File = filename(Tab, Config),
- ?line {ok,T} = dets:open_file(bug, [{file,File}]),
- ?line ok = dets:insert(T, [{1,a},{2,b},{3,c}]),
- ?line dets:safe_fixtable(T, true),
- ?line {[_],C1} = dets:match_object(T, '_', 1),
- ?line {BC1,_D} = dets:bchunk(T, start),
- ?line ok = dets:close(T),
- ?line {'EXIT', {badarg, _}} = (catch {foo,dets:match_object(C1)}),
- ?line {'EXIT', {badarg, _}} = (catch {foo,dets:bchunk(T, BC1)}),
- ?line {ok,T} = dets:open_file(bug, [{file,File}]),
- ?line false = dets:info(T, safe_fixed),
- ?line {'EXIT', {badarg, _}} = (catch {foo,dets:match_object(C1)}),
- ?line {'EXIT', {badarg, _}} = (catch {foo,dets:bchunk(T, BC1)}),
- ?line ok = dets:close(T),
+ {ok,T} = dets:open_file(bug, [{file,File}]),
+ ok = dets:insert(T, [{1,a},{2,b},{3,c}]),
+ dets:safe_fixtable(T, true),
+ {[_],C1} = dets:match_object(T, '_', 1),
+ {BC1,_D} = dets:bchunk(T, start),
+ ok = dets:close(T),
+ {'EXIT', {badarg, _}} = (catch {foo,dets:match_object(C1)}),
+ {'EXIT', {badarg, _}} = (catch {foo,dets:bchunk(T, BC1)}),
+ {ok,T} = dets:open_file(bug, [{file,File}]),
+ false = dets:info(T, safe_fixed),
+ {'EXIT', {badarg, _}} = (catch {foo,dets:match_object(C1)}),
+ {'EXIT', {badarg, _}} = (catch {foo,dets:bchunk(T, BC1)}),
+ ok = dets:close(T),
file:delete(File),
ok.
@@ -3857,23 +3856,23 @@ otp_8923(Config) when is_list(Config) ->
Bin = list_to_binary([ 0 || _ <- lists:seq(1, 400) ]),
BigBin = list_to_binary([ 0 ||_ <- lists:seq(1, 4000)]),
Ets = ets:new(temp, [{keypos,1}]),
- ?line [ true = ets:insert(Ets, {C,Bin}) || C <- lists:seq(1, 700) ],
- ?line true = ets:insert(Ets, {helper_data,BigBin}),
- ?line true = ets:insert(Ets, {prim_btree,BigBin}),
- ?line true = ets:insert(Ets, {sec_btree,BigBin}),
+ [ true = ets:insert(Ets, {C,Bin}) || C <- lists:seq(1, 700) ],
+ true = ets:insert(Ets, {helper_data,BigBin}),
+ true = ets:insert(Ets, {prim_btree,BigBin}),
+ true = ets:insert(Ets, {sec_btree,BigBin}),
%% Note: too few slots; re-hash will take place
- ?line {ok, Tab} = dets:open_file(Tab, [{file,File}]),
- ?line Tab = ets:to_dets(Ets, Tab),
- ?line ok = dets:close(Tab),
- ?line true = ets:delete(Ets),
+ {ok, Tab} = dets:open_file(Tab, [{file,File}]),
+ Tab = ets:to_dets(Ets, Tab),
+ ok = dets:close(Tab),
+ true = ets:delete(Ets),
- ?line {ok,Ref} = dets:open_file(File),
- ?line [{1,_}] = dets:lookup(Ref, 1),
- ?line ok = dets:close(Ref),
+ {ok,Ref} = dets:open_file(File),
+ [{1,_}] = dets:lookup(Ref, 1),
+ ok = dets:close(Ref),
- ?line {ok,Ref2} = dets:open_file(File),
- ?line [{helper_data,_}] = dets:lookup(Ref2, helper_data),
- ?line ok = dets:close(Ref2),
+ {ok,Ref2} = dets:open_file(File),
+ [{helper_data,_}] = dets:lookup(Ref2, helper_data),
+ ok = dets:close(Ref2),
file:delete(File),
ok.
@@ -3890,14 +3889,14 @@ otp_9282(Config) when is_list(Config) ->
some_calls(Tab, Config) ->
File = filename(ref, Config),
- ?line {ok,T} = dets:open_file(Tab, [{file,File}]),
- ?line T = Tab,
- ?line false = dets:info(T, safe_fixed),
- ?line File = dets:info(T, filename),
- ?line ok = dets:insert(Tab, [{3,0}]),
- ?line [{3,0}] = dets:lookup(Tab, 3),
- ?line [{3,0}] = dets:traverse(Tab, fun(X) -> {continue, X} end),
- ?line ok = dets:close(T),
+ {ok,T} = dets:open_file(Tab, [{file,File}]),
+ T = Tab,
+ false = dets:info(T, safe_fixed),
+ File = dets:info(T, filename),
+ ok = dets:insert(Tab, [{3,0}]),
+ [{3,0}] = dets:lookup(Tab, 3),
+ [{3,0}] = dets:traverse(Tab, fun(X) -> {continue, X} end),
+ ok = dets:close(T),
file:delete(File).
otp_9607(doc) ->
@@ -3915,53 +3914,53 @@ otp_9607(Config) when is_list(Config) ->
Key = a,
Value = 1,
Args = [{file,File}],
- ?line {ok, T} = dets:open_file(T, Args),
- ?line ok = dets:insert(T, {Key, Value}),
- ?line ok = dets:close(T),
-
- ?line Call = fun(P, A) ->
- P ! {self(), A},
- receive
- {P, Ans} ->
- Ans
- after 5000 ->
- exit(other_process_dead)
- end
- end,
+ {ok, T} = dets:open_file(T, Args),
+ ok = dets:insert(T, {Key, Value}),
+ ok = dets:close(T),
+
+ Call = fun(P, A) ->
+ P ! {self(), A},
+ receive
+ {P, Ans} ->
+ Ans
+ after 5000 ->
+ exit(other_process_dead)
+ end
+ end,
%% Create a file on the modified format, read the file
%% with an emulator that doesn't know about the modified
%% format.
- ?line {ok, Node} = start_node_rel(Version, Version, slave),
- ?line Pid = rpc:call(Node, erlang, spawn,
- [?MODULE, dets_dirty_loop, []]),
- ?line {error,{needs_repair, File}} =
+ {ok, Node} = start_node_rel(Version, Version, slave),
+ Pid = rpc:call(Node, erlang, spawn,
+ [?MODULE, dets_dirty_loop, []]),
+ {error,{needs_repair, File}} =
Call(Pid, [open, T, Args++[{repair,false}]]),
io:format("Expect repair:~n"),
- ?line {ok, T} = Call(Pid, [open, T, Args]),
- ?line [{Key,Value}] = Call(Pid, [read, T, Key]),
- ?line ok = Call(Pid, [close, T]),
+ {ok, T} = Call(Pid, [open, T, Args]),
+ [{Key,Value}] = Call(Pid, [read, T, Key]),
+ ok = Call(Pid, [close, T]),
file:delete(File),
%% Create a file on the unmodified format. Modify the file
%% using an emulator that must not turn the file into the
%% modified format. Read the file and make sure it is not
%% repaired.
- ?line {ok, T} = Call(Pid, [open, T, Args]),
- ?line ok = Call(Pid, [write, T, {Key,Value}]),
- ?line [{Key,Value}] = Call(Pid, [read, T, Key]),
- ?line ok = Call(Pid, [close, T]),
+ {ok, T} = Call(Pid, [open, T, Args]),
+ ok = Call(Pid, [write, T, {Key,Value}]),
+ [{Key,Value}] = Call(Pid, [read, T, Key]),
+ ok = Call(Pid, [close, T]),
Key2 = b,
Value2 = 2,
- ?line {ok, T} = dets:open_file(T, Args),
- ?line [{Key,Value}] = dets:lookup(T, Key),
- ?line ok = dets:insert(T, {Key2,Value2}),
- ?line ok = dets:close(T),
+ {ok, T} = dets:open_file(T, Args),
+ [{Key,Value}] = dets:lookup(T, Key),
+ ok = dets:insert(T, {Key2,Value2}),
+ ok = dets:close(T),
- ?line {ok, T} = Call(Pid, [open, T, Args++[{repair,false}]]),
- ?line [{Key2,Value2}] = Call(Pid, [read, T, Key2]),
- ?line ok = Call(Pid, [close, T]),
+ {ok, T} = Call(Pid, [open, T, Args++[{repair,false}]]),
+ [{Key2,Value2}] = Call(Pid, [read, T, Key2]),
+ ok = Call(Pid, [close, T]),
?t:stop_node(Node),
file:delete(File),
@@ -3978,21 +3977,21 @@ otp_9607(Config) when is_list(Config) ->
start_node_rel(Name, Rel, How) ->
Release = [{release, atom_to_list(Rel)}],
- ?line Pa = filename:dirname(code:which(?MODULE)),
- ?line test_server:start_node(Name, How,
- [{args,
- " -kernel net_setuptime 100 "
- " -pa " ++ Pa},
- {erl, Release}]).
+ Pa = filename:dirname(code:which(?MODULE)),
+ test_server:start_node(Name, How,
+ [{args,
+ " -kernel net_setuptime 100 "
+ " -pa " ++ Pa},
+ {erl, Release}]).
crash(File, Where) ->
crash(File, Where, 10).
crash(File, Where, What) when is_integer(What) ->
- ?line {ok, Fd} = file:open(File, [read,write]),
- ?line file:position(Fd, Where),
- ?line ok = file:write(Fd, [What]),
- ?line ok = file:close(Fd).
+ {ok, Fd} = file:open(File, [read,write]),
+ file:position(Fd, Where),
+ ok = file:write(Fd, [What]),
+ ok = file:close(Fd).
args(Config) ->
{Sets, Bags, Dups} =
@@ -4047,56 +4046,56 @@ zip_filename([], [], [], S1, B1, D1, _, _Conf) ->
del_test(Tab) ->
?format("Deltest on ~p~n", [Tab]),
- ?line Objs = safe_get_all_objects(Tab),
- ?line Keys = map(fun(X) -> element(1, X) end, Objs),
- ?line foreach(fun(Key) -> dets:delete(Tab, Key) end, Keys),
- ?line 0 = length(get_all_objects(Tab)),
- ?line [] = get_all_objects_fast(Tab),
- ?line 0 = dets:info(Tab, size).
+ Objs = safe_get_all_objects(Tab),
+ Keys = map(fun(X) -> element(1, X) end, Objs),
+ foreach(fun(Key) -> dets:delete(Tab, Key) end, Keys),
+ 0 = length(get_all_objects(Tab)),
+ [] = get_all_objects_fast(Tab),
+ 0 = dets:info(Tab, size).
del_obj_test(Tab) ->
?format("Delobjtest on ~p~n", [Tab]),
- ?line Objs = safe_get_all_objects(Tab),
- ?line LL = length(Objs),
- ?line LL = dets:info(Tab, size),
- ?line foreach(fun(Obj) -> dets:delete_object(Tab, Obj) end, Objs),
- ?line 0 = length(get_all_objects(Tab)),
- ?line [] = get_all_objects_fast(Tab),
- ?line 0 = dets:info(Tab, size).
+ Objs = safe_get_all_objects(Tab),
+ LL = length(Objs),
+ LL = dets:info(Tab, size),
+ foreach(fun(Obj) -> dets:delete_object(Tab, Obj) end, Objs),
+ 0 = length(get_all_objects(Tab)),
+ [] = get_all_objects_fast(Tab),
+ 0 = dets:info(Tab, size).
match_del_test(Tab) ->
- ?line ?format("Match delete test on ~p~n", [Tab]),
- ?line ok = dets:match_delete(Tab, {'_','_','_'}),
- ?line Sz = dets:info(Tab, size),
- ?line true = Sz =:= length(dets:match_object(Tab, '_')),
- ?line ok = dets:match_delete(Tab, '_'),
- ?line 0 = dets:info(Tab, size),
- ?line 0 = length(get_all_objects(Tab)),
- ?line [] = get_all_objects_fast(Tab).
+ ?format("Match delete test on ~p~n", [Tab]),
+ ok = dets:match_delete(Tab, {'_','_','_'}),
+ Sz = dets:info(Tab, size),
+ true = Sz =:= length(dets:match_object(Tab, '_')),
+ ok = dets:match_delete(Tab, '_'),
+ 0 = dets:info(Tab, size),
+ 0 = length(get_all_objects(Tab)),
+ [] = get_all_objects_fast(Tab).
trav_test(_Data, Len, Tab) ->
?format("Travtest on ~p~n", [Tab]),
- ?line _X0 = dets:traverse(Tab, fun(_X) -> continue end),
- ?line XX = dets:traverse(Tab, fun(X) -> {continue, X} end),
- ?line case Len =:= length(XX) of
+ _X0 = dets:traverse(Tab, fun(_X) -> continue end),
+ XX = dets:traverse(Tab, fun(X) -> {continue, X} end),
+ case Len =:= length(XX) of
false -> ?format("DIFF ~p~n", [XX -- _Data]);
true -> ok
end,
- ?line 1 = length(dets:traverse(Tab, fun(X) -> {done, X} end)).
+ 1 = length(dets:traverse(Tab, fun(X) -> {done, X} end)).
match_test(Data, Tab) ->
- ?line ?format("Match test on ~p~n", [Tab]),
- ?line Data1 = sort(filter(fun(X) when tuple_size(X) =:= 3 -> true;
- (_X) -> false
- end, Data)),
- ?line Data1 = sort(dets:match_object(Tab, {'$1', '$2', '$3'})),
-
- ?line Len = length(Data),
- ?line Len = length(dets:match(Tab, '_')),
- ?line Len2 = length(Data1),
- ?line Len2 = length(dets:match(Tab, {'$1', '_', '_'})),
+ ?format("Match test on ~p~n", [Tab]),
+ Data1 = sort(filter(fun(X) when tuple_size(X) =:= 3 -> true;
+ (_X) -> false
+ end, Data)),
+ Data1 = sort(dets:match_object(Tab, {'$1', '$2', '$3'})),
+
+ Len = length(Data),
+ Len = length(dets:match(Tab, '_')),
+ Len2 = length(Data1),
+ Len2 = length(dets:match(Tab, {'$1', '_', '_'})),
- ?line Data3 =
+ Data3 =
filter(fun(X) ->
K = element(1, X),
if
@@ -4104,14 +4103,14 @@ match_test(Data, Tab) ->
true -> false
end
end, Data),
- ?line Len3 = length(Data3),
- ?line Len3 = length(dets:match(Tab, {{'$1', '$2'}, '_', '_'})),
- ?line Len3 = length(dets:match_object(Tab, {{'$1', '$2'}, '_', '_'})),
+ Len3 = length(Data3),
+ Len3 = length(dets:match(Tab, {{'$1', '$2'}, '_', '_'})),
+ Len3 = length(dets:match_object(Tab, {{'$1', '$2'}, '_', '_'})),
- ?line R = make_ref(),
- ?line dets:insert(Tab, {{R, R}, 33 ,44}),
- ?line 1 = length(dets:match(Tab, {{R, R}, '_', '_'})),
- ?line 1 = length(dets:match_object(Tab, {{R, R}, '_', '_'})).
+ R = make_ref(),
+ dets:insert(Tab, {{R, R}, 33 ,44}),
+ 1 = length(dets:match(Tab, {{R, R}, '_', '_'})),
+ 1 = length(dets:match_object(Tab, {{R, R}, '_', '_'})).
%%
%% Utilities
@@ -4123,20 +4122,20 @@ headsz(_) ->
?HEADSZ_v9.
unwritable(Fname) ->
- ?line {ok, Info} = file:read_file_info(Fname),
+ {ok, Info} = file:read_file_info(Fname),
Mode = Info#file_info.mode - 8#00200,
- ?line file:write_file_info(Fname, Info#file_info{mode = Mode}).
+ file:write_file_info(Fname, Info#file_info{mode = Mode}).
writable(Fname) ->
- ?line {ok, Info} = file:read_file_info(Fname),
+ {ok, Info} = file:read_file_info(Fname),
Mode = Info#file_info.mode bor 8#00200,
- ?line file:write_file_info(Fname, Info#file_info{mode = Mode}).
+ file:write_file_info(Fname, Info#file_info{mode = Mode}).
truncate(File, Where) ->
- ?line {ok, Fd} = file:open(File, [read,write]),
- ?line file:position(Fd, Where),
- ?line ok = file:truncate(Fd),
- ?line ok = file:close(Fd).
+ {ok, Fd} = file:open(File, [read,write]),
+ file:position(Fd, Where),
+ ok = file:truncate(Fd),
+ ok = file:close(Fd).
new_filename(Name, _Config) when is_integer(Name) ->
filename:join(?privdir(_Config),
@@ -4151,8 +4150,8 @@ open_files(_Name, [], _Version) ->
[];
open_files(Name0, [Args | Tail], Version) ->
?format("init ~p~n", [Args]),
- ?line Name = list_to_atom(integer_to_list(Name0)),
- ?line {ok, Name} = dets:open_file(Name, [{version,Version} | Args]),
+ Name = list_to_atom(integer_to_list(Name0)),
+ {ok, Name} = dets:open_file(Name, [{version,Version} | Args]),
[Name | open_files(Name0+1, Tail, Version)].
close_all(Tabs) -> foreach(fun(Tab) -> ok = dets:close(Tab) end, Tabs).
@@ -4167,11 +4166,11 @@ delete_files(Args) ->
%% Initialize all tables
initialize(Tabs, Data) ->
- ?line foreach(fun(Tab) ->
- Fun = fun(Obj) -> ok = dets:insert(Tab, Obj) end,
- foreach(Fun, Data),
- dets:sync(Tab)
- end, Tabs).
+ foreach(fun(Tab) ->
+ Fun = fun(Obj) -> ok = dets:insert(Tab, Obj) end,
+ foreach(Fun, Data),
+ dets:sync(Tab)
+ end, Tabs).
%% need more than 512 objects to really trig overflow
make_data(Kp) ->
@@ -4244,9 +4243,9 @@ ensure_node(N, Node) ->
end.
size_test(Len, Tabs) ->
- ?line foreach(fun(Tab) ->
- Len = dets:info(Tab, size)
- end, Tabs).
+ foreach(fun(Tab) ->
+ Len = dets:info(Tab, size)
+ end, Tabs).
no_keys_test([T | Ts]) ->
no_keys_test(T),
@@ -4259,15 +4258,15 @@ no_keys_test(T) ->
ok;
9 ->
Kp = dets:info(T, keypos),
- ?line All = dets:match_object(T, '_'),
- ?line L = lists:map(fun(X) -> element(Kp, X) end, All),
- ?line NoKeys = length(lists:usort(L)),
- ?line case {dets:info(T, no_keys), NoKeys} of
- {N, N} ->
- ok;
- {N1, N2} ->
- exit({no_keys_test, N1, N2})
- end
+ All = dets:match_object(T, '_'),
+ L = lists:map(fun(X) -> element(Kp, X) end, All),
+ NoKeys = length(lists:usort(L)),
+ case {dets:info(T, no_keys), NoKeys} of
+ {N, N} ->
+ ok;
+ {N1, N2} ->
+ exit({no_keys_test, N1, N2})
+ end
end.
safe_get_all_objects(Tab) ->
@@ -4282,13 +4281,13 @@ get_all_objects(Tab) -> get_all_objects(dets:first(Tab), Tab, []).
%% Assuming no key matches {error, Reason}...
get_all_objects('$end_of_table', _Tab, L) -> L;
get_all_objects({error, Reason}, _Tab, _L) ->
- exit({get_all_objects, get(line), {error, Reason}});
+ exit({get_all_objects, {error, Reason}});
get_all_objects(Key, Tab, L) ->
Objs = dets:lookup(Tab, Key),
- ?line get_all_objects(dets:next(Tab, Key), Tab, Objs ++ L).
+ get_all_objects(dets:next(Tab, Key), Tab, Objs ++ L).
count_objects_quite_fast(Tab) ->
- ?line R1 = dets:match_object(Tab, '_', 1),
+ R1 = dets:match_object(Tab, '_', 1),
count_objs_1(R1, 0).
count_objs_1('$end_of_table', N) ->
@@ -4308,42 +4307,42 @@ histogram(Tab) ->
histogram(Tab, OnePercent).
histogram(Tab, OnePercent) ->
- ?line E = ets:new(histo, []),
- ?line dets:safe_fixtable(Tab, true),
- ?line Hist = histo(Tab, E, 0, OnePercent, OnePercent),
- ?line dets:safe_fixtable(Tab, false),
- ?line case Hist of
- ok ->
- ?line H = ets:tab2list(E),
- ?line true = ets:delete(E),
- sort(H);
- Error ->
- ets:delete(E),
- Error
- end.
+ E = ets:new(histo, []),
+ dets:safe_fixtable(Tab, true),
+ Hist = histo(Tab, E, 0, OnePercent, OnePercent),
+ dets:safe_fixtable(Tab, false),
+ case Hist of
+ ok ->
+ H = ets:tab2list(E),
+ true = ets:delete(E),
+ sort(H);
+ Error ->
+ ets:delete(E),
+ Error
+ end.
histo(T, E, I, One, Count) when is_number(Count), I > Count ->
io:format("."),
histo(T, E, I, One, Count+One);
histo(T, E, I, One, Count) ->
- ?line case dets:slot(T, I) of
- '$end_of_table' when is_number(Count) ->
- io:format("~n"),
- ok;
- '$end_of_table' ->
- ok;
- Objs when is_list(Objs) ->
- L = length(Objs),
- case catch ets:update_counter(E, L, 1) of
- {'EXIT', _} ->
- ets:insert(E, {L, 1});
- _ ->
- ok
- end,
- histo(T, E, I+1, One, Count);
- Error ->
- Error
- end.
+ case dets:slot(T, I) of
+ '$end_of_table' when is_number(Count) ->
+ io:format("~n"),
+ ok;
+ '$end_of_table' ->
+ ok;
+ Objs when is_list(Objs) ->
+ L = length(Objs),
+ case catch ets:update_counter(E, L, 1) of
+ {'EXIT', _} ->
+ ets:insert(E, {L, 1});
+ _ ->
+ ok
+ end,
+ histo(T, E, I+1, One, Count);
+ Error ->
+ Error
+ end.
sum_histogram(H) ->
sum_histogram(H, 0).
generated by cgit v1.2.3 (git 2.25.1) at 2024-12-31 17:53:19 +0000