aboutsummaryrefslogtreecommitdiffstats
path: root/lib/stdlib/test
diff options
context:
space:
mode:
Diffstat (limited to 'lib/stdlib/test')
-rw-r--r--lib/stdlib/test/Makefile1
-rw-r--r--lib/stdlib/test/dets_SUITE.erl3920
-rw-r--r--lib/stdlib/test/erl_eval_SUITE.erl3
-rw-r--r--lib/stdlib/test/erl_scan_SUITE.erl28
-rw-r--r--lib/stdlib/test/escript_SUITE.erl5
-rw-r--r--lib/stdlib/test/escript_SUITE_data/archive_script_file_access/archive_script_file_access.erl4
-rwxr-xr-xlib/stdlib/test/escript_SUITE_data/unicode32
-rwxr-xr-xlib/stdlib/test/escript_SUITE_data/unicode412
-rwxr-xr-xlib/stdlib/test/escript_SUITE_data/unicode512
-rwxr-xr-xlib/stdlib/test/escript_SUITE_data/unicode613
-rw-r--r--lib/stdlib/test/ets_SUITE.erl27
-rw-r--r--lib/stdlib/test/gen_event_SUITE.erl47
-rw-r--r--lib/stdlib/test/gen_fsm_SUITE.erl38
-rw-r--r--lib/stdlib/test/gen_server_SUITE.erl48
-rw-r--r--lib/stdlib/test/io_proto_SUITE.erl31
-rw-r--r--lib/stdlib/test/qlc_SUITE_data/join_info_compat.erl215
-rw-r--r--lib/stdlib/test/shell_SUITE.erl19
-rw-r--r--lib/stdlib/test/supervisor_3.erl45
-rw-r--r--lib/stdlib/test/supervisor_SUITE.erl106
19 files changed, 2427 insertions, 2149 deletions
diff --git a/lib/stdlib/test/Makefile b/lib/stdlib/test/Makefile
index 6aa09d7bd0..af82f22b21 100644
--- a/lib/stdlib/test/Makefile
+++ b/lib/stdlib/test/Makefile
@@ -66,6 +66,7 @@ MODULES= \
string_SUITE \
supervisor_1 \
supervisor_2 \
+ supervisor_3 \
supervisor_deadlock \
naughty_child \
shell_SUITE \
diff --git a/lib/stdlib/test/dets_SUITE.erl b/lib/stdlib/test/dets_SUITE.erl
index 66799f4d05..8ff7c3ccc9 100644
--- a/lib/stdlib/test/dets_SUITE.erl
+++ b/lib/stdlib/test/dets_SUITE.erl
@@ -1,7 +1,7 @@
%%
%% %CopyrightBegin%
%%
-%% Copyright Ericsson AB 1996-2012. All Rights Reserved.
+%% Copyright Ericsson AB 1996-2013. All Rights Reserved.
%%
%% The contents of this file are subject to the Erlang Public License,
%% Version 1.1, (the "License"); you may not use this file except in
@@ -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").
@@ -34,8 +33,6 @@
-define(datadir(Conf), ?config(data_dir, Conf)).
-endif.
--compile(r13). % OTP-9607
-
-export([all/0, suite/0,groups/0,init_per_suite/1, end_per_suite/1,
init_per_group/2,end_per_group/2,
newly_started/1, basic_v8/1, basic_v9/1,
@@ -55,7 +52,7 @@
simultaneous_open/1, insert_new/1, repair_continuation/1,
otp_5487/1, otp_6206/1, otp_6359/1, otp_4738/1, otp_7146/1,
otp_8070/1, otp_8856/1, otp_8898/1, otp_8899/1, otp_8903/1,
- otp_8923/1, otp_9282/1, otp_9607/1]).
+ otp_8923/1, otp_9282/1]).
-export([dets_dirty_loop/0]).
@@ -112,7 +109,7 @@ all() ->
many_clients, otp_4906, otp_5402, simultaneous_open,
insert_new, repair_continuation, otp_5487, otp_6206,
otp_6359, otp_4738, otp_7146, otp_8070, otp_8856, otp_8898,
- otp_8899, otp_8903, otp_8923, otp_9282, otp_9607
+ otp_8899, otp_8903, otp_8923, otp_9282
].
groups() ->
@@ -135,10 +132,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 +153,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 +201,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 +232,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 +282,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 +325,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 +365,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 +409,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 +437,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 +462,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 +489,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 +513,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 +567,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 +612,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 +635,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 +651,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 +695,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 +727,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 +796,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 +813,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 +876,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 +906,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 +951,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 +1087,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 +1180,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 +1265,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 +1361,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 +1620,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 +1701,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 +1771,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 +1822,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 +1849,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 +1925,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 +2101,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 +2205,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 +2242,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 +2404,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 +2417,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 +2480,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 +2520,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 +2559,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 +2572,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 +2631,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 +2684,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 +2740,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 +2754,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 +2821,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 +2842,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 +2856,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 +2909,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 +2931,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 +2962,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 +2985,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 +3013,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 +3031,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 +3117,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 +3132,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 +3144,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 +3203,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 +3249,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 +3281,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
@@ -3303,8 +3300,7 @@ monit(Tab, File) ->
timer:sleep(100),
spawn(F1),
dets:close(Tab),
- file:delete(File),
- ok.
+ ok = file:delete(File).
do_log(Tab) ->
case catch dets:insert(Tab, {hej,san,sa}) of
@@ -3314,7 +3310,7 @@ do_log(Tab) ->
%% Kill the Dets process while repair is in progress.
kill_while_repairing(Tab, File) ->
- ?line create_opened_log(File),
+ create_opened_log(File),
Delay = 1000,
dets:start(),
Parent = self(),
@@ -3324,16 +3320,22 @@ kill_while_repairing(Tab, File) ->
timer:sleep(Delay),
Parent ! {self(), R}
end,
- ?line P1 = spawn(F), % will repair
- timer:sleep(100),
- ?line P2 = spawn(F), % pending...
- ?line P3 = spawn(F), % pending...
- ?line DetsPid = find_dets_pid([P1, P2, P3 | Ps]),
+ %% One of these will open the file, the other will be pending
+ %% until the file has been repaired:
+ P1 = spawn(F),
+ P2 = spawn(F),
+ P3 = spawn(F),
+ DetsPid = find_dets_pid([P1, P2, P3 | Ps]),
exit(DetsPid, kill),
- ?line receive {P1,R1} -> {'EXIT', {dets_process_died, _}} = R1 end,
- ?line receive {P2,R2} -> {ok, _} = R2 end,
- ?line receive {P3,R3} -> {ok, _} = R3 end,
+ receive {P1,R1} -> R1 end,
+ receive {P2,R2} -> R2 end,
+ receive {P3,R3} -> R3 end,
+ io:format("Killed pid: ~p~n", [DetsPid]),
+ io:format("Remaining Dets-pids (should be nil): ~p~n",
+ [find_dets_pids()]),
+ {replies,[{'EXIT', {dets_process_died, _}}, {ok,_}, {ok, _}]} =
+ {replies,lists:sort([R1, R2, R3])},
timer:sleep(200),
case dets:info(Tab) of
@@ -3341,7 +3343,7 @@ kill_while_repairing(Tab, File) ->
ok;
_Info ->
timer:sleep(5000),
- ?line undefined = dets:info(Tab)
+ undefined = dets:info(Tab)
end,
file:delete(File),
@@ -3353,6 +3355,19 @@ find_dets_pid(P0) ->
_ -> timer:sleep(100), find_dets_pid(P0)
end.
+find_dets_pid() ->
+ case find_dets_pids() of
+ [] ->
+ timer:sleep(100),
+ find_dets_pid();
+ [Pid] ->
+ Pid
+ end.
+
+find_dets_pids() ->
+ lists:filter(fun(P) -> dets:pid2name(P) =/= undefined end,
+ erlang:processes()).
+
%% Kill the Dets process when there are users and an on-going
%% initiailization.
kill_while_init(Tab, File) ->
@@ -3364,9 +3379,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},
@@ -3374,29 +3389,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,
- ?line [DetsPid] =
- lists:filter(fun(P) -> dets:pid2name(P) =/= undefined end,
- erlang:processes()),
+ 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() ->
@@ -3404,47 +3417,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),
@@ -3457,10 +3470,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) ->
@@ -3471,24 +3484,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),
@@ -3500,24 +3513,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) ->
@@ -3531,20 +3544,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."];
@@ -3556,15 +3569,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.
@@ -3577,10 +3590,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.
@@ -3605,47 +3618,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.
@@ -3658,26 +3671,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) ->
@@ -3689,53 +3702,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.
@@ -3749,9 +3762,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.
@@ -3773,11 +3786,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.
@@ -3790,19 +3803,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.
@@ -3813,19 +3826,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.
@@ -3841,23 +3854,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.
@@ -3874,87 +3887,16 @@ 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) ->
- ["OTP-9607. Test downgrading the slightly changed format."];
-otp_9607(suite) ->
- [];
-otp_9607(Config) when is_list(Config) ->
- %% Note: the bug is about almost full tables. The fix of that
- %% problem is *not* tested here.
- Version = r13b,
- case ?t:is_release_available(atom_to_list(Version)) of
- true ->
- T = otp_9607,
- File = filename(T, 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,
- %% 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}} =
- 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]),
- 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]),
-
- 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),
-
- ?line {ok, T} = Call(Pid, [open, T, Args++[{repair,false}]]),
- ?line [{Key2,Value2}] = Call(Pid, [read, T, Key2]),
- ?line ok = Call(Pid, [close, T]),
-
- ?t:stop_node(Node),
- file:delete(File),
- ok;
- false ->
- {skipped, "No support for old node"}
- end.
-
-
%%
%% Parts common to several test cases
@@ -3962,21 +3904,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} =
@@ -4031,56 +3973,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
@@ -4088,14 +4030,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
@@ -4107,20 +4049,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),
@@ -4135,8 +4077,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).
@@ -4151,11 +4093,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) ->
@@ -4228,9 +4170,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),
@@ -4243,15 +4185,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) ->
@@ -4266,13 +4208,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) ->
@@ -4292,42 +4234,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).
diff --git a/lib/stdlib/test/erl_eval_SUITE.erl b/lib/stdlib/test/erl_eval_SUITE.erl
index 7ff4c81ea6..18ec17a4bf 100644
--- a/lib/stdlib/test/erl_eval_SUITE.erl
+++ b/lib/stdlib/test/erl_eval_SUITE.erl
@@ -1,3 +1,4 @@
+%% -*- coding: utf-8 -*-
%%
%% %CopyrightBegin%
%%
@@ -992,7 +993,7 @@ otp_10622(Config) when is_list(Config) ->
<<0>>),
check(fun() -> <<"\x{aa}ff"/utf8>> = <<"\x{aa}ff"/utf8>> end,
"<<\"\\x{aa}ff\"/utf8>> = <<\"\\x{aa}ff\"/utf8>>. ",
- <<"�\xaaff">>),
+ <<"Â\xaaff">>),
%% The same bug as last example:
check(fun() -> case <<"foo"/utf8>> of
<<"foo"/utf8>> -> true
diff --git a/lib/stdlib/test/erl_scan_SUITE.erl b/lib/stdlib/test/erl_scan_SUITE.erl
index ecd181e87c..361abbb771 100644
--- a/lib/stdlib/test/erl_scan_SUITE.erl
+++ b/lib/stdlib/test/erl_scan_SUITE.erl
@@ -21,7 +21,8 @@
-export([all/0, suite/0,groups/0,init_per_suite/1, end_per_suite/1,
init_per_group/2,end_per_group/2]).
--export([ error_1/1, error_2/1, iso88591/1, otp_7810/1, otp_10302/1]).
+-export([ error_1/1, error_2/1, iso88591/1, otp_7810/1, otp_10302/1,
+ otp_10990/1, otp_10992/1]).
-import(lists, [nth/2,flatten/1]).
-import(io_lib, [print/1]).
@@ -60,7 +61,7 @@ end_per_testcase(_Case, Config) ->
suite() -> [{ct_hooks,[ts_install_cth]}].
all() ->
- [{group, error}, iso88591, otp_7810, otp_10302].
+ [{group, error}, iso88591, otp_7810, otp_10302, otp_10990, otp_10992].
groups() ->
[{error, [], [error_1, error_2]}].
@@ -1121,6 +1122,29 @@ otp_10302(Config) when is_list(Config) ->
erl_parse:abstract("a"++[1024]++"c", [{encoding,latin1}]),
ok.
+otp_10990(doc) ->
+ "OTP-10990. Floating point number in input string.";
+otp_10990(suite) ->
+ [];
+otp_10990(Config) when is_list(Config) ->
+ {'EXIT',_} = (catch {foo, erl_scan:string([$",42.0,$"],1)}),
+ ok.
+
+otp_10992(doc) ->
+ "OTP-10992. List of floats to abstract format.";
+otp_10992(suite) ->
+ [];
+otp_10992(Config) when is_list(Config) ->
+ {cons,0,{float,0,42.0},{nil,0}} =
+ erl_parse:abstract([42.0], [{encoding,unicode}]),
+ {cons,0,{float,0,42.0},{nil,0}} =
+ erl_parse:abstract([42.0], [{encoding,utf8}]),
+ {cons,0,{integer,0,65},{cons,0,{float,0,42.0},{nil,0}}} =
+ erl_parse:abstract([$A,42.0], [{encoding,unicode}]),
+ {cons,0,{integer,0,65},{cons,0,{float,0,42.0},{nil,0}}} =
+ erl_parse:abstract([$A,42.0], [{encoding,utf8}]),
+ ok.
+
test_string(String, Expected) ->
{ok, Expected, _End} = erl_scan:string(String),
test(String).
diff --git a/lib/stdlib/test/escript_SUITE.erl b/lib/stdlib/test/escript_SUITE.erl
index cf5fb12686..eebfec3336 100644
--- a/lib/stdlib/test/escript_SUITE.erl
+++ b/lib/stdlib/test/escript_SUITE.erl
@@ -615,7 +615,7 @@ archive_script_file_access(Config) when is_list(Config) ->
%% 3. If symlinks are supported, run one of the scripts via a symlink.
%%
%% This is in order to test error b) described above this test case.
- case file:read_link(Symlink2) of
+ case element(1,os:type()) =:= win32 orelse file:read_link(Symlink2) of
{ok,_} ->
run(PrivDir, "./" ++ SymlinkName2 ++ " " ++ ScriptName2,
[<<"ExitCode:0">>]);
@@ -919,6 +919,9 @@ unicode(Config) when is_list(Config) ->
" an arithmetic expression\n in operator '/'/2\n "
"called as <<\"\xaa\">> / <<\"\xaa\">>\nExitCode:127">>]),
run(Dir, "unicode3", [<<"ExitCode:0">>]),
+ run(Dir, "unicode4", [<<"ExitCode:0">>]),
+ run(Dir, "unicode5", [<<"ExitCode:0">>]),
+ run(Dir, "unicode6", [<<"ExitCode:0">>]),
ok.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
diff --git a/lib/stdlib/test/escript_SUITE_data/archive_script_file_access/archive_script_file_access.erl b/lib/stdlib/test/escript_SUITE_data/archive_script_file_access/archive_script_file_access.erl
index b03c8ba70d..523621e4f3 100644
--- a/lib/stdlib/test/escript_SUITE_data/archive_script_file_access/archive_script_file_access.erl
+++ b/lib/stdlib/test/escript_SUITE_data/archive_script_file_access/archive_script_file_access.erl
@@ -1,7 +1,7 @@
%%
%% %CopyrightBegin%
%%
-%% Copyright Ericsson AB 2012. All Rights Reserved.
+%% Copyright Ericsson AB 2012-2013. All Rights Reserved.
%%
%% The contents of this file are subject to the Erlang Public License,
%% Version 1.1, (the "License"); you may not use this file except in
@@ -56,7 +56,7 @@ main([RelArchiveFile]) ->
%% If symlinks are supported on this platform...
RelSymlinkArchiveFile = "symlink_to_" ++ RelArchiveFile,
- case file:read_link(RelSymlinkArchiveFile) of
+ case element(1,os:type()) =:= win32 orelse file:read_link(RelSymlinkArchiveFile) of
{ok,_} ->
DotSlashSymlinkArchiveFile = "./" ++ RelSymlinkArchiveFile,
AbsSymlinkArchiveFile=filename:join(filename:dirname(AbsArchiveFile),
diff --git a/lib/stdlib/test/escript_SUITE_data/unicode3 b/lib/stdlib/test/escript_SUITE_data/unicode3
index 944487dcae..0702ecf309 100755
--- a/lib/stdlib/test/escript_SUITE_data/unicode3
+++ b/lib/stdlib/test/escript_SUITE_data/unicode3
@@ -1,5 +1,5 @@
#!/usr/bin/env escript
-%% -*- erlang; coding: utf-8 -*-
+%% -*- erlang; coding: latin-1 -*-
-export([main/1]).
diff --git a/lib/stdlib/test/escript_SUITE_data/unicode4 b/lib/stdlib/test/escript_SUITE_data/unicode4
new file mode 100755
index 0000000000..a7563a613a
--- /dev/null
+++ b/lib/stdlib/test/escript_SUITE_data/unicode4
@@ -0,0 +1,12 @@
+#!/usr/bin/env escript
+%% -*- erlang; encoding:utf-8 -*-
+
+-export([main/1]).
+
+main(_) ->
+ ok = io:setopts([{encoding,unicode}]),
+ Bin1 = <<"örn_Ѐ שלום-שלום+של 日本語">>,
+ L = [246,114,110,95,1024,32,1513,1500,1493,1501,45,1513,1500,1493,
+ 1501,43,1513,1500,32,26085,26412,35486],
+ L = unicode:characters_to_list(Bin1, utf8),
+ ok.
diff --git a/lib/stdlib/test/escript_SUITE_data/unicode5 b/lib/stdlib/test/escript_SUITE_data/unicode5
new file mode 100755
index 0000000000..e95da3361d
--- /dev/null
+++ b/lib/stdlib/test/escript_SUITE_data/unicode5
@@ -0,0 +1,12 @@
+#!/usr/bin/env escript
+%% -*- erlang -*-
+-export([main/1]).
+%% -*- encoding:latin-1 -*-
+
+main(_) ->
+ ok = io:setopts([{encoding,unicode}]),
+ Bin1 = <<"örn_Ѐ שלום-שלום+של 日本語">>,
+ L = [246,114,110,95,1024,32,1513,1500,1493,1501,45,1513,1500,1493,
+ 1501,43,1513,1500,32,26085,26412,35486],
+ L = unicode:characters_to_list(Bin1, utf8),
+ ok.
diff --git a/lib/stdlib/test/escript_SUITE_data/unicode6 b/lib/stdlib/test/escript_SUITE_data/unicode6
new file mode 100755
index 0000000000..8027a2a08c
--- /dev/null
+++ b/lib/stdlib/test/escript_SUITE_data/unicode6
@@ -0,0 +1,13 @@
+#!/usr/bin/env escript
+%% -*- erlang -*-
+%%! +pc unicode
+-export([main/1]).
+%% -*- encoding:utf-8 -*-
+
+main(_) ->
+ ok = io:setopts([{encoding,unicode}]),
+ Bin1 = <<"örn_Ѐ שלום-שלום+של 日本語">>,
+ L = [246,114,110,95,1024,32,1513,1500,1493,1501,45,1513,1500,1493,
+ 1501,43,1513,1500,32,26085,26412,35486],
+ L = unicode:characters_to_list(Bin1, utf8),
+ ok.
diff --git a/lib/stdlib/test/ets_SUITE.erl b/lib/stdlib/test/ets_SUITE.erl
index b6c94a6f6d..af5d5a8f21 100644
--- a/lib/stdlib/test/ets_SUITE.erl
+++ b/lib/stdlib/test/ets_SUITE.erl
@@ -3218,6 +3218,7 @@ delete_large_tab_1(Name, Flags, Data, Fix) ->
end
end,
0),
+ SchedTracerMon = monitor(process, SchedTracer),
?line Loopers = start_loopers(erlang:system_info(schedulers),
Prio,
fun (_) -> erlang:yield() end,
@@ -3237,12 +3238,14 @@ delete_large_tab_1(Name, Flags, Data, Fix) ->
N >= 5 -> ?line ok;
true -> ?line ?t:fail()
end
- end.
+ end,
+ receive {'DOWN',SchedTracerMon,process,SchedTracer,_} -> ok end,
+ ok.
delete_large_named_table(doc) ->
"Delete a large name table and try to create a new table with the same name in another process.";
delete_large_named_table(Config) when is_list(Config) ->
- ?line Data = [{erlang:phash2(I, 16#ffffff),I} || I <- lists:seq(1, 500000)],
+ ?line Data = [{erlang:phash2(I, 16#ffffff),I} || I <- lists:seq(1, 200000)],
?line EtsMem = etsmem(),
repeat_for_opts(fun(Opts) -> delete_large_named_table_do(Opts,Data) end),
?line verify_etsmem(EtsMem),
@@ -3264,16 +3267,16 @@ delete_large_named_table_1(Name, Flags, Data, Fix) ->
?line lists:foreach(fun({K,_}) -> ets:delete(Tab, K) end, Data)
end,
Parent = self(),
- Pid = my_spawn_link(fun() ->
- receive
- {trace,Parent,call,_} ->
- ets_new(Name, [named_table])
- end
- end),
- ?line erlang:trace(self(), true, [call,{tracer,Pid}]),
- ?line erlang:trace_pattern({ets,delete,1}, true, [global]),
- ?line erlang:yield(), true = ets:delete(Tab),
- ?line erlang:trace_pattern({ets,delete,1}, false, [global]),
+ {Pid, MRef} = my_spawn_opt(fun() ->
+ receive
+ ets_new ->
+ ets_new(Name, [named_table])
+ end
+ end,
+ [link, monitor]),
+ true = ets:delete(Tab),
+ Pid ! ets_new,
+ receive {'DOWN',MRef,process,Pid,_} -> ok end,
ok.
evil_delete(doc) ->
diff --git a/lib/stdlib/test/gen_event_SUITE.erl b/lib/stdlib/test/gen_event_SUITE.erl
index 5c51e12e35..6be5a299b6 100644
--- a/lib/stdlib/test/gen_event_SUITE.erl
+++ b/lib/stdlib/test/gen_event_SUITE.erl
@@ -26,13 +26,14 @@
delete_handler/1, swap_handler/1, swap_sup_handler/1,
notify/1, sync_notify/1, call/1, info/1, hibernate/1,
call_format_status/1, call_format_status_anon/1,
- error_format_status/1]).
+ error_format_status/1, get_state/1, replace_state/1]).
suite() -> [{ct_hooks,[ts_install_cth]}].
all() ->
[start, {group, test_all}, hibernate,
- call_format_status, call_format_status_anon, error_format_status].
+ call_format_status, call_format_status_anon, error_format_status,
+ get_state, replace_state].
groups() ->
[{test_all, [],
@@ -956,3 +957,45 @@ error_format_status(Config) when is_list(Config) ->
?line ok = gen_event:stop(Pid),
process_flag(trap_exit, OldFl),
ok.
+
+get_state(suite) ->
+ [];
+get_state(doc) ->
+ ["Test that sys:get_state/1,2 return the gen_event state"];
+get_state(Config) when is_list(Config) ->
+ {ok, Pid} = gen_event:start({local, my_dummy_handler}),
+ State1 = self(),
+ ok = gen_event:add_handler(my_dummy_handler, dummy1_h, [State1]),
+ [{dummy1_h,false,State1}] = sys:get_state(Pid),
+ [{dummy1_h,false,State1}] = sys:get_state(Pid, 5000),
+ State2 = {?MODULE, self()},
+ ok = gen_event:add_handler(my_dummy_handler, {dummy1_h,id}, [State2]),
+ Result1 = sys:get_state(Pid),
+ [{dummy1_h,false,State1},{dummy1_h,id,State2}] = lists:sort(Result1),
+ Result2 = sys:get_state(Pid, 5000),
+ [{dummy1_h,false,State1},{dummy1_h,id,State2}] = lists:sort(Result2),
+ ok = gen_event:stop(Pid),
+ ok.
+
+replace_state(suite) ->
+ [];
+replace_state(doc) ->
+ ["Test that replace_state/2,3 replace the gen_event state"];
+replace_state(Config) when is_list(Config) ->
+ {ok, Pid} = gen_event:start({local, my_dummy_handler}),
+ State1 = self(),
+ ok = gen_event:add_handler(my_dummy_handler, dummy1_h, [State1]),
+ [{dummy1_h,false,State1}] = sys:get_state(Pid),
+ NState1 = "replaced",
+ Replace1 = fun({dummy1_h,false,_}=S) -> setelement(3,S,NState1) end,
+ [{dummy1_h,false,NState1}] = sys:replace_state(Pid, Replace1),
+ [{dummy1_h,false,NState1}] = sys:get_state(Pid),
+ NState2 = "replaced again",
+ Replace2 = fun({dummy1_h,false,_}=S) -> setelement(3,S,NState2) end,
+ [{dummy1_h,false,NState2}] = sys:replace_state(Pid, Replace2, 5000),
+ [{dummy1_h,false,NState2}] = sys:get_state(Pid),
+ %% verify no change in state if replace function crashes
+ Replace3 = fun(_) -> exit(fail) end,
+ [{dummy1_h,false,NState2}] = sys:replace_state(Pid, Replace3),
+ [{dummy1_h,false,NState2}] = sys:get_state(Pid),
+ ok.
diff --git a/lib/stdlib/test/gen_fsm_SUITE.erl b/lib/stdlib/test/gen_fsm_SUITE.erl
index a637a8543b..fd15838b7d 100644
--- a/lib/stdlib/test/gen_fsm_SUITE.erl
+++ b/lib/stdlib/test/gen_fsm_SUITE.erl
@@ -31,7 +31,7 @@
-export([shutdown/1]).
--export([ sys1/1, call_format_status/1, error_format_status/1]).
+-export([ sys1/1, call_format_status/1, error_format_status/1, get_state/1, replace_state/1]).
-export([hibernate/1,hiber_idle/3,hiber_wakeup/3,hiber_idle/2,hiber_wakeup/2]).
@@ -66,7 +66,7 @@ groups() ->
start8, start9, start10, start11, start12]},
{abnormal, [], [abnormal1, abnormal2]},
{sys, [],
- [sys1, call_format_status, error_format_status]}].
+ [sys1, call_format_status, error_format_status, get_state, replace_state]}].
init_per_suite(Config) ->
Config.
@@ -413,6 +413,40 @@ error_format_status(Config) when is_list(Config) ->
process_flag(trap_exit, OldFl),
ok.
+get_state(Config) when is_list(Config) ->
+ State = self(),
+ {ok, Pid} = gen_fsm:start(?MODULE, {state_data, State}, []),
+ {idle, State} = sys:get_state(Pid),
+ {idle, State} = sys:get_state(Pid, 5000),
+ stop_it(Pid),
+
+ %% check that get_state can handle a name being an atom (pid is
+ %% already checked by the previous test)
+ {ok, Pid2} = gen_fsm:start({local, gfsm}, gen_fsm_SUITE, {state_data, State}, []),
+ {idle, State} = sys:get_state(gfsm),
+ {idle, State} = sys:get_state(gfsm, 5000),
+ stop_it(Pid2),
+ ok.
+
+replace_state(Config) when is_list(Config) ->
+ State = self(),
+ {ok, Pid} = gen_fsm:start(?MODULE, {state_data, State}, []),
+ {idle, State} = sys:get_state(Pid),
+ NState1 = "replaced",
+ Replace1 = fun({StateName, _}) -> {StateName, NState1} end,
+ {idle, NState1} = sys:replace_state(Pid, Replace1),
+ {idle, NState1} = sys:get_state(Pid),
+ NState2 = "replaced again",
+ Replace2 = fun({idle, _}) -> {state0, NState2} end,
+ {state0, NState2} = sys:replace_state(Pid, Replace2, 5000),
+ {state0, NState2} = sys:get_state(Pid),
+ %% verify no change in state if replace function crashes
+ Replace3 = fun(_) -> error(fail) end,
+ {state0, NState2} = sys:replace_state(Pid, Replace3),
+ {state0, NState2} = sys:get_state(Pid),
+ stop_it(Pid),
+ ok.
+
%% Hibernation
hibernate(suite) -> [];
hibernate(Config) when is_list(Config) ->
diff --git a/lib/stdlib/test/gen_server_SUITE.erl b/lib/stdlib/test/gen_server_SUITE.erl
index dffeadb423..3b6a3f38bc 100644
--- a/lib/stdlib/test/gen_server_SUITE.erl
+++ b/lib/stdlib/test/gen_server_SUITE.erl
@@ -32,7 +32,7 @@
spec_init_local_registered_parent/1,
spec_init_global_registered_parent/1,
otp_5854/1, hibernate/1, otp_7669/1, call_format_status/1,
- error_format_status/1, call_with_huge_message_queue/1
+ error_format_status/1, get_state/1, replace_state/1, call_with_huge_message_queue/1
]).
% spawn export
@@ -57,6 +57,7 @@ all() ->
spec_init_local_registered_parent,
spec_init_global_registered_parent, otp_5854, hibernate,
otp_7669, call_format_status, error_format_status,
+ get_state, replace_state,
call_with_huge_message_queue].
groups() ->
@@ -1033,6 +1034,51 @@ error_format_status(Config) when is_list(Config) ->
process_flag(trap_exit, OldFl),
ok.
+%% Verify that sys:get_state correctly returns gen_server state
+%%
+get_state(suite) ->
+ [];
+get_state(doc) ->
+ ["Test that sys:get_state/1,2 return the gen_server state"];
+get_state(Config) when is_list(Config) ->
+ State = self(),
+ {ok, _Pid} = gen_server:start_link({local, get_state},
+ ?MODULE, {state,State}, []),
+ State = sys:get_state(get_state),
+ State = sys:get_state(get_state, 5000),
+ {ok, Pid} = gen_server:start_link(?MODULE, {state,State}, []),
+ State = sys:get_state(Pid),
+ State = sys:get_state(Pid, 5000),
+ ok.
+
+%% Verify that sys:replace_state correctly replaces gen_server state
+%%
+replace_state(suite) ->
+ [];
+replace_state(doc) ->
+ ["Test that sys:replace_state/1,2 replace the gen_server state"];
+replace_state(Config) when is_list(Config) ->
+ State = self(),
+ {ok, _Pid} = gen_server:start_link({local, replace_state},
+ ?MODULE, {state,State}, []),
+ State = sys:get_state(replace_state),
+ NState1 = "replaced",
+ Replace1 = fun(_) -> NState1 end,
+ NState1 = sys:replace_state(replace_state, Replace1),
+ NState1 = sys:get_state(replace_state),
+ {ok, Pid} = gen_server:start_link(?MODULE, {state,NState1}, []),
+ NState1 = sys:get_state(Pid),
+ Suffix = " again",
+ NState2 = NState1 ++ Suffix,
+ Replace2 = fun(S) -> S ++ Suffix end,
+ NState2 = sys:replace_state(Pid, Replace2, 5000),
+ NState2 = sys:get_state(Pid, 5000),
+ %% verify no change in state if replace function crashes
+ Replace3 = fun(_) -> throw(fail) end,
+ NState2 = sys:replace_state(Pid, Replace3),
+ NState2 = sys:get_state(Pid, 5000),
+ ok.
+
%% Test that the time for a huge message queue is not
%% significantly slower than with an empty message queue.
call_with_huge_message_queue(Config) when is_list(Config) ->
diff --git a/lib/stdlib/test/io_proto_SUITE.erl b/lib/stdlib/test/io_proto_SUITE.erl
index 4ca8680fc9..76a8109a8d 100644
--- a/lib/stdlib/test/io_proto_SUITE.erl
+++ b/lib/stdlib/test/io_proto_SUITE.erl
@@ -147,8 +147,7 @@ unicode_prompt(Config) when is_list(Config) ->
%% And one with oldshell
?line rtnode([{putline,""},
{putline, "2."},
- {getline_re, ".*2."},
- {getline, "2"},
+ {getline_re, ".*2$"},
{putline, "shell:prompt_func({io_proto_SUITE,uprompt})."},
{getline_re, ".*default"},
{putline, "io:get_line('')."},
@@ -263,8 +262,7 @@ setopts_getopts(Config) when is_list(Config) ->
%% And one with oldshell
?line rtnode([{putline,""},
{putline, "2."},
- {getline_re, ".*2."},
- {getline, "2"},
+ {getline_re, ".*2$"},
{putline, "lists:keyfind(binary,1,io:getopts())."},
{getline_re, ".*{binary,false}"},
{putline, "io:get_line('')."},
@@ -467,8 +465,7 @@ unicode_options(Config) when is_list(Config) ->
end,
?line rtnode([{putline,""},
{putline, "2."},
- {getline_re, ".*2."},
- {getline, "2"},
+ {getline_re, ".*2$"},
{putline, "lists:keyfind(encoding,1,io:getopts())."},
{getline_re, ".*{encoding,latin1}"},
{putline, "io:format(\"~ts~n\",[[1024]])."},
@@ -701,8 +698,7 @@ binary_options(Config) when is_list(Config) ->
old ->
ok;
new ->
- ?line rtnode([{putline,""},
- {putline, "2."},
+ ?line rtnode([{putline, "2."},
{getline, "2"},
{putline, "lists:keyfind(binary,1,io:getopts())."},
{getline, "{binary,false}"},
@@ -720,10 +716,8 @@ binary_options(Config) when is_list(Config) ->
],[])
end,
%% And one with oldshell
- ?line rtnode([{putline,""},
- {putline, "2."},
- {getline_re, ".*2."},
- {getline, "2"},
+ ?line rtnode([{putline, "2."},
+ {getline_re, ".*2$"},
{putline, "lists:keyfind(binary,1,io:getopts())."},
{getline_re, ".*{binary,false}"},
{putline, "io:get_line('')."},
@@ -935,8 +929,8 @@ bc_with_r12_gl_1(_Config,Machine) ->
TestDataLine1BinUtf = unicode:characters_to_binary(TestDataLine1),
TestDataLine1BinLatin = list_to_binary(TestDataLine1),
- N2List = create_nodename(),
- MyNodeList = atom_to_list(node()),
+ {ok,N2List} = create_nodename(),
+ MyNodeList = atom2list(node()),
register(io_proto_suite,self()),
AM1 = spawn(?MODULE,Machine,
[MyNodeList, "io_proto_suite", N2List]),
@@ -1182,8 +1176,8 @@ read_modes_gl_1(_Config,Machine) ->
TestDataLine1BinUtf = unicode:characters_to_binary(TestDataLine1),
TestDataLine1BinLatin = list_to_binary(TestDataLine1),
- N2List = create_nodename(),
- MyNodeList = atom_to_list(node()),
+ {ok,N2List} = create_nodename(),
+ MyNodeList = atom2list(node()),
register(io_proto_suite,self()),
AM1 = spawn(?MODULE,Machine,
[MyNodeList, "io_proto_suite", N2List]),
@@ -1609,7 +1603,7 @@ create_nodename(X) ->
case file:read_file_info(filename:join(["/tmp",NN])) of
{error,enoent} ->
Host = lists:nth(2,string:tokens(atom_to_list(node()),"@")),
- NN++"@"++Host;
+ {ok,NN++"@"++Host};
_ ->
create_nodename(X+1)
end.
@@ -1925,6 +1919,9 @@ from(H, [H | T]) -> T;
from(H, [_ | T]) -> from(H, T);
from(_, []) -> [].
+atom2list(A) ->
+ lists:flatten(io_lib:format("~w", [A])).
+
chomp([]) ->
[];
chomp([$\n]) ->
diff --git a/lib/stdlib/test/qlc_SUITE_data/join_info_compat.erl b/lib/stdlib/test/qlc_SUITE_data/join_info_compat.erl
index e0db132c47..b93b907392 100644
--- a/lib/stdlib/test/qlc_SUITE_data/join_info_compat.erl
+++ b/lib/stdlib/test/qlc_SUITE_data/join_info_compat.erl
@@ -1,3 +1,4 @@
+%% -*- coding: utf-8 -*-
%%
%% %CopyrightBegin%
%%
@@ -515,7 +516,7 @@ create_handle() ->
$.:8/integer-unit:1-unsigned-big,
$x:8/integer-unit:1-unsigned-big,
$\234:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
+ $Ë:8/integer-unit:1-unsigned-big,
$`:8/integer-unit:1-unsigned-big,
$N:8/integer-unit:1-unsigned-big,
$a:8/integer-unit:1-unsigned-big,
@@ -523,16 +524,16 @@ create_handle() ->
$-:8/integer-unit:1-unsigned-big,
$):8/integer-unit:1-unsigned-big,
$-:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
+ $È:8/integer-unit:1-unsigned-big,
$I:8/integer-unit:1-unsigned-big,
$M:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
+ $ä:8/integer-unit:1-unsigned-big,
+ $Ê:8/integer-unit:1-unsigned-big,
$a:8/integer-unit:1-unsigned-big,
$`:8/integer-unit:1-unsigned-big,
$`:8/integer-unit:1-unsigned-big,
$`:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
+ $Ê:8/integer-unit:1-unsigned-big,
$\000:8/integer-unit:1-unsigned-big,
$\n:8/integer-unit:1-unsigned-big,
$0:8/integer-unit:1-unsigned-big,
@@ -541,19 +542,19 @@ create_handle() ->
$\026:8/integer-unit:1-unsigned-big,
$%:8/integer-unit:1-unsigned-big,
$r:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
+ $¥:8/integer-unit:1-unsigned-big,
$0:8/integer-unit:1-unsigned-big,
$0:8/integer-unit:1-unsigned-big,
$F:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
+ $ :8/integer-unit:1-unsigned-big,
+ $ð:8/integer-unit:1-unsigned-big,
$":8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
+ $³:8/integer-unit:1-unsigned-big,
$\000:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
+ $þ:8/integer-unit:1-unsigned-big,
+ $Ì:8/integer-unit:1-unsigned-big,
$\n:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big>>,
+ $É:8/integer-unit:1-unsigned-big>>,
<<$\203:8/integer-unit:1-unsigned-big,
$P:8/integer-unit:1-unsigned-big,
$\000:8/integer-unit:1-unsigned-big,
@@ -562,7 +563,7 @@ create_handle() ->
$<:8/integer-unit:1-unsigned-big,
$x:8/integer-unit:1-unsigned-big,
$\234:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
+ $Ë:8/integer-unit:1-unsigned-big,
$`:8/integer-unit:1-unsigned-big,
$N:8/integer-unit:1-unsigned-big,
$a:8/integer-unit:1-unsigned-big,
@@ -570,16 +571,16 @@ create_handle() ->
$-:8/integer-unit:1-unsigned-big,
$):8/integer-unit:1-unsigned-big,
$-:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
+ $È:8/integer-unit:1-unsigned-big,
$I:8/integer-unit:1-unsigned-big,
$M:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
+ $ä:8/integer-unit:1-unsigned-big,
+ $Ê:8/integer-unit:1-unsigned-big,
$a:8/integer-unit:1-unsigned-big,
$`:8/integer-unit:1-unsigned-big,
$`:8/integer-unit:1-unsigned-big,
$`:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
+ $Î:8/integer-unit:1-unsigned-big,
$\000:8/integer-unit:1-unsigned-big,
$\n:8/integer-unit:1-unsigned-big,
$0:8/integer-unit:1-unsigned-big,
@@ -588,22 +589,22 @@ create_handle() ->
$\026:8/integer-unit:1-unsigned-big,
$%:8/integer-unit:1-unsigned-big,
$r:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
+ $¥:8/integer-unit:1-unsigned-big,
$0:8/integer-unit:1-unsigned-big,
$0:8/integer-unit:1-unsigned-big,
$::8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
+ $¡:8/integer-unit:1-unsigned-big,
+ $ð:8/integer-unit:1-unsigned-big,
$":8/integer-unit:1-unsigned-big,
$P:8/integer-unit:1-unsigned-big,
$x:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
+ $ñ:8/integer-unit:1-unsigned-big,
$Y:8/integer-unit:1-unsigned-big,
$\000:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
+ $ª:8/integer-unit:1-unsigned-big,
$9:8/integer-unit:1-unsigned-big,
$\r:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big>>,
+ $ý:8/integer-unit:1-unsigned-big>>,
<<$\203:8/integer-unit:1-unsigned-big,
$P:8/integer-unit:1-unsigned-big,
$\000:8/integer-unit:1-unsigned-big,
@@ -612,51 +613,51 @@ create_handle() ->
$I:8/integer-unit:1-unsigned-big,
$x:8/integer-unit:1-unsigned-big,
$\234:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
+ $Ë:8/integer-unit:1-unsigned-big,
$`:8/integer-unit:1-unsigned-big,
$M:8/integer-unit:1-unsigned-big,
$a:8/integer-unit:1-unsigned-big,
$`:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
+ $Ê:8/integer-unit:1-unsigned-big,
$/:8/integer-unit:1-unsigned-big,
$H:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
+ $ä:8/integer-unit:1-unsigned-big,
$N:8/integer-unit:1-unsigned-big,
$a:8/integer-unit:1-unsigned-big,
$`:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
+ $¶:8/integer-unit:1-unsigned-big,
+ $µ:8/integer-unit:1-unsigned-big,
+ $²:8/integer-unit:1-unsigned-big,
+ $Í:8/integer-unit:1-unsigned-big,
$`:8/integer-unit:1-unsigned-big,
$\006:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
+ $Ò:8/integer-unit:1-unsigned-big,
$e:8/integer-unit:1-unsigned-big,
$\211:8/integer-unit:1-unsigned-big,
$E:8/integer-unit:1-unsigned-big,
$\s:8/integer-unit:1-unsigned-big,
$>:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
+ $£:8/integer-unit:1-unsigned-big,
$\023:8/integer-unit:1-unsigned-big,
$\210:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
+ $Ç:8/integer-unit:1-unsigned-big,
$\232:8/integer-unit:1-unsigned-big,
$\226:8/integer-unit:1-unsigned-big,
$\223:8/integer-unit:1-unsigned-big,
$\237:8/integer-unit:1-unsigned-big,
$X:8/integer-unit:1-unsigned-big,
$\222:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
+ $È:8/integer-unit:1-unsigned-big,
$\235:8/integer-unit:1-unsigned-big,
$l:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
+ $¨:8/integer-unit:1-unsigned-big,
$g:8/integer-unit:1-unsigned-big,
$i:8/integer-unit:1-unsigned-big,
$d:8/integer-unit:1-unsigned-big,
$\200:8/integer-unit:1-unsigned-big,
$\001:8/integer-unit:1-unsigned-big,
$R:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
+ $µ:8/integer-unit:1-unsigned-big,
$\r:8/integer-unit:1-unsigned-big,
$\214:8/integer-unit:1-unsigned-big,
$\030:8/integer-unit:1-unsigned-big,
@@ -664,7 +665,7 @@ create_handle() ->
$\000:8/integer-unit:1-unsigned-big,
$\000:8/integer-unit:1-unsigned-big,
$c:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
+ $Ö:8/integer-unit:1-unsigned-big,
$\017:8/integer-unit:1-unsigned-big,
$=:8/integer-unit:1-unsigned-big>>,
<<$\203:8/integer-unit:1-unsigned-big,
@@ -708,24 +709,24 @@ create_handle() ->
$*:8/integer-unit:1-unsigned-big,
$x:8/integer-unit:1-unsigned-big,
$\234:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
+ $Ë:8/integer-unit:1-unsigned-big,
$`:8/integer-unit:1-unsigned-big,
$M:8/integer-unit:1-unsigned-big,
$a:8/integer-unit:1-unsigned-big,
$`:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
+ $Ê:8/integer-unit:1-unsigned-big,
$/:8/integer-unit:1-unsigned-big,
$H:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
+ $ä:8/integer-unit:1-unsigned-big,
$\005:8/integer-unit:1-unsigned-big,
$R:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
+ $¶:8/integer-unit:1-unsigned-big,
+ $¶:8/integer-unit:1-unsigned-big,
$\031:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
+ $Ì:8/integer-unit:1-unsigned-big,
$):8/integer-unit:1-unsigned-big,
$\f:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
+ $Ì:8/integer-unit:1-unsigned-big,
$e:8/integer-unit:1-unsigned-big,
$\211:8/integer-unit:1-unsigned-big,
$E:8/integer-unit:1-unsigned-big,
@@ -737,7 +738,7 @@ create_handle() ->
$/:8/integer-unit:1-unsigned-big,
$\022:8/integer-unit:1-unsigned-big,
$\000:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
+ $Ì:8/integer-unit:1-unsigned-big,
$\205:8/integer-unit:1-unsigned-big,
$\t:8/integer-unit:1-unsigned-big,
$\216:8/integer-unit:1-unsigned-big>>,
@@ -749,33 +750,33 @@ create_handle() ->
$j:8/integer-unit:1-unsigned-big,
$x:8/integer-unit:1-unsigned-big,
$\234:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
+ $Ë:8/integer-unit:1-unsigned-big,
$`:8/integer-unit:1-unsigned-big,
$I:8/integer-unit:1-unsigned-big,
$a:8/integer-unit:1-unsigned-big,
$`:8/integer-unit:1-unsigned-big,
$I:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
+ $Î:8/integer-unit:1-unsigned-big,
+ $Ï:8/integer-unit:1-unsigned-big,
$+:8/integer-unit:1-unsigned-big,
$N:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
+ $ú:8/integer-unit:1-unsigned-big,
+ $ÿ:8/integer-unit:1-unsigned-big,
+ $ÿ:8/integer-unit:1-unsigned-big,
+ $ÿ:8/integer-unit:1-unsigned-big,
+ $·:8/integer-unit:1-unsigned-big,
$\f:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
+ $æ:8/integer-unit:1-unsigned-big,
$\024:8/integer-unit:1-unsigned-big,
$\006:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
+ $Ö:8/integer-unit:1-unsigned-big,
$\222:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
+ $Ò:8/integer-unit:1-unsigned-big,
$\202:8/integer-unit:1-unsigned-big,
$\234:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
+ $Ô:8/integer-unit:1-unsigned-big,
$D:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
+ $®:8/integer-unit:1-unsigned-big,
$\034:8/integer-unit:1-unsigned-big,
$\006:8/integer-unit:1-unsigned-big,
$\006:8/integer-unit:1-unsigned-big,
@@ -791,7 +792,7 @@ create_handle() ->
$W:8/integer-unit:1-unsigned-big,
$\n:8/integer-unit:1-unsigned-big,
$\003:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
+ $£:8/integer-unit:1-unsigned-big,
$\023:8/integer-unit:1-unsigned-big,
$\n:8/integer-unit:1-unsigned-big,
$/:8/integer-unit:1-unsigned-big,
@@ -800,18 +801,18 @@ create_handle() ->
$\027:8/integer-unit:1-unsigned-big,
$\237:8/integer-unit:1-unsigned-big,
$\205:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
+ $¤:8/integer-unit:1-unsigned-big,
$\227:8/integer-unit:1-unsigned-big,
$\007:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
+ $¤:8/integer-unit:1-unsigned-big,
$\227:8/integer-unit:1-unsigned-big,
$\021:8/integer-unit:1-unsigned-big,
$.:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
+ $Ï:8/integer-unit:1-unsigned-big,
$\003:8/integer-unit:1-unsigned-big,
$\224:8/integer-unit:1-unsigned-big,
$\217:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
+ $Ì:8/integer-unit:1-unsigned-big,
$\002:8/integer-unit:1-unsigned-big,
$\000:8/integer-unit:1-unsigned-big,
$\203:8/integer-unit:1-unsigned-big,
@@ -1398,7 +1399,7 @@ lookup_handle() ->
$.:8/integer-unit:1-unsigned-big,
$x:8/integer-unit:1-unsigned-big,
$\234:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
+ $Ë:8/integer-unit:1-unsigned-big,
$`:8/integer-unit:1-unsigned-big,
$N:8/integer-unit:1-unsigned-big,
$a:8/integer-unit:1-unsigned-big,
@@ -1406,16 +1407,16 @@ lookup_handle() ->
$-:8/integer-unit:1-unsigned-big,
$):8/integer-unit:1-unsigned-big,
$-:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
+ $È:8/integer-unit:1-unsigned-big,
$I:8/integer-unit:1-unsigned-big,
$M:8/integer-unit:1-unsigned-big,
$\024:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
+ $Ì:8/integer-unit:1-unsigned-big,
$a:8/integer-unit:1-unsigned-big,
$`:8/integer-unit:1-unsigned-big,
$`:8/integer-unit:1-unsigned-big,
$`:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
+ $Ê:8/integer-unit:1-unsigned-big,
$\000:8/integer-unit:1-unsigned-big,
$\n:8/integer-unit:1-unsigned-big,
$0:8/integer-unit:1-unsigned-big,
@@ -1424,19 +1425,19 @@ lookup_handle() ->
$\026:8/integer-unit:1-unsigned-big,
$%:8/integer-unit:1-unsigned-big,
$\n:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
+ $¦:8/integer-unit:1-unsigned-big,
$0:8/integer-unit:1-unsigned-big,
$0:8/integer-unit:1-unsigned-big,
$F:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
+ $ :8/integer-unit:1-unsigned-big,
+ $ð:8/integer-unit:1-unsigned-big,
$":8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
+ $³:8/integer-unit:1-unsigned-big,
$\000:8/integer-unit:1-unsigned-big,
$\000:8/integer-unit:1-unsigned-big,
$\206:8/integer-unit:1-unsigned-big,
$\n:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big>>,
+ $Þ:8/integer-unit:1-unsigned-big>>,
<<$\203:8/integer-unit:1-unsigned-big,
$P:8/integer-unit:1-unsigned-big,
$\000:8/integer-unit:1-unsigned-big,
@@ -1445,7 +1446,7 @@ lookup_handle() ->
$.:8/integer-unit:1-unsigned-big,
$x:8/integer-unit:1-unsigned-big,
$\234:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
+ $Ë:8/integer-unit:1-unsigned-big,
$`:8/integer-unit:1-unsigned-big,
$N:8/integer-unit:1-unsigned-big,
$a:8/integer-unit:1-unsigned-big,
@@ -1453,16 +1454,16 @@ lookup_handle() ->
$-:8/integer-unit:1-unsigned-big,
$):8/integer-unit:1-unsigned-big,
$-:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
+ $È:8/integer-unit:1-unsigned-big,
$I:8/integer-unit:1-unsigned-big,
$M:8/integer-unit:1-unsigned-big,
$\024:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
+ $Ì:8/integer-unit:1-unsigned-big,
$a:8/integer-unit:1-unsigned-big,
$`:8/integer-unit:1-unsigned-big,
$`:8/integer-unit:1-unsigned-big,
$`:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
+ $Ê:8/integer-unit:1-unsigned-big,
$\000:8/integer-unit:1-unsigned-big,
$\n:8/integer-unit:1-unsigned-big,
$0:8/integer-unit:1-unsigned-big,
@@ -1471,19 +1472,19 @@ lookup_handle() ->
$\026:8/integer-unit:1-unsigned-big,
$%:8/integer-unit:1-unsigned-big,
$\n:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
+ $¦:8/integer-unit:1-unsigned-big,
$0:8/integer-unit:1-unsigned-big,
$0:8/integer-unit:1-unsigned-big,
$F:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
+ $ :8/integer-unit:1-unsigned-big,
+ $ð:8/integer-unit:1-unsigned-big,
+ $â:8/integer-unit:1-unsigned-big,
+ $³:8/integer-unit:1-unsigned-big,
$\000:8/integer-unit:1-unsigned-big,
$\000:8/integer-unit:1-unsigned-big,
$\222:8/integer-unit:1-unsigned-big,
$\n:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big>>,
+ $ä:8/integer-unit:1-unsigned-big>>,
<<$\203:8/integer-unit:1-unsigned-big,
$h:8/integer-unit:1-unsigned-big,
$\003:8/integer-unit:1-unsigned-big,
@@ -1525,25 +1526,25 @@ lookup_handle() ->
$+:8/integer-unit:1-unsigned-big,
$x:8/integer-unit:1-unsigned-big,
$\234:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
+ $Ë:8/integer-unit:1-unsigned-big,
$`:8/integer-unit:1-unsigned-big,
$M:8/integer-unit:1-unsigned-big,
$a:8/integer-unit:1-unsigned-big,
$`:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
+ $Ê:8/integer-unit:1-unsigned-big,
$/:8/integer-unit:1-unsigned-big,
$H:8/integer-unit:1-unsigned-big,
$\024:8/integer-unit:1-unsigned-big,
$N:8/integer-unit:1-unsigned-big,
$a:8/integer-unit:1-unsigned-big,
$`:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
+ $¶:8/integer-unit:1-unsigned-big,
+ $µ:8/integer-unit:1-unsigned-big,
+ $²:8/integer-unit:1-unsigned-big,
+ $Í:8/integer-unit:1-unsigned-big,
$`:8/integer-unit:1-unsigned-big,
$\006:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
+ $Ò:8/integer-unit:1-unsigned-big,
$e:8/integer-unit:1-unsigned-big,
$\211:8/integer-unit:1-unsigned-big,
$E:8/integer-unit:1-unsigned-big,
@@ -1555,10 +1556,10 @@ lookup_handle() ->
$/:8/integer-unit:1-unsigned-big,
$\022:8/integer-unit:1-unsigned-big,
$\000:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
+ $×:8/integer-unit:1-unsigned-big,
$\227:8/integer-unit:1-unsigned-big,
$\t:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big>>,
+ $Û:8/integer-unit:1-unsigned-big>>,
<<$\203:8/integer-unit:1-unsigned-big,
$P:8/integer-unit:1-unsigned-big,
$\000:8/integer-unit:1-unsigned-big,
@@ -1567,33 +1568,33 @@ lookup_handle() ->
$\\:8/integer-unit:1-unsigned-big,
$x:8/integer-unit:1-unsigned-big,
$\234:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
+ $Ë:8/integer-unit:1-unsigned-big,
$`:8/integer-unit:1-unsigned-big,
$I:8/integer-unit:1-unsigned-big,
$a:8/integer-unit:1-unsigned-big,
$`:8/integer-unit:1-unsigned-big,
$I:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
+ $Î:8/integer-unit:1-unsigned-big,
+ $Ï:8/integer-unit:1-unsigned-big,
$+:8/integer-unit:1-unsigned-big,
$N:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
+ $ú:8/integer-unit:1-unsigned-big,
+ $ÿ:8/integer-unit:1-unsigned-big,
+ $ÿ:8/integer-unit:1-unsigned-big,
+ $ÿ:8/integer-unit:1-unsigned-big,
+ $û:8/integer-unit:1-unsigned-big,
$\f:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
+ $æ:8/integer-unit:1-unsigned-big,
$\024:8/integer-unit:1-unsigned-big,
$\006:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
+ $Ö:8/integer-unit:1-unsigned-big,
$\222:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
+ $Ò:8/integer-unit:1-unsigned-big,
$\202:8/integer-unit:1-unsigned-big,
$\234:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
+ $Ô:8/integer-unit:1-unsigned-big,
$D:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
+ $Á:8/integer-unit:1-unsigned-big,
$\034:8/integer-unit:1-unsigned-big,
$\006:8/integer-unit:1-unsigned-big,
$\006:8/integer-unit:1-unsigned-big,
@@ -1605,7 +1606,7 @@ lookup_handle() ->
$Y:8/integer-unit:1-unsigned-big,
$b:8/integer-unit:1-unsigned-big,
$Q:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
+ $¢:8/integer-unit:1-unsigned-big,
$`:8/integer-unit:1-unsigned-big,
$\n:8/integer-unit:1-unsigned-big,
$\003:8/integer-unit:1-unsigned-big,
@@ -1616,7 +1617,7 @@ lookup_handle() ->
$>:8/integer-unit:1-unsigned-big,
$\v:8/integer-unit:1-unsigned-big,
$I:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
+ $µ:8/integer-unit:1-unsigned-big,
$\020:8/integer-unit:1-unsigned-big,
$H:8/integer-unit:1-unsigned-big,
$5:8/integer-unit:1-unsigned-big,
@@ -1630,7 +1631,7 @@ lookup_handle() ->
$\005:8/integer-unit:1-unsigned-big,
$\000:8/integer-unit:1-unsigned-big,
$\024:8/integer-unit:1-unsigned-big,
- $�:8/integer-unit:1-unsigned-big,
+ $Ù:8/integer-unit:1-unsigned-big,
$\031:8/integer-unit:1-unsigned-big,
$M:8/integer-unit:1-unsigned-big>>}
end,
diff --git a/lib/stdlib/test/shell_SUITE.erl b/lib/stdlib/test/shell_SUITE.erl
index 990b1f5eb2..3c49aaa103 100644
--- a/lib/stdlib/test/shell_SUITE.erl
+++ b/lib/stdlib/test/shell_SUITE.erl
@@ -1,3 +1,4 @@
+%% -*- coding: utf-8 -*-
%%
%% %CopyrightBegin%
%%
@@ -122,7 +123,7 @@ start_restricted_from_shell(Config) when is_list(Config) ->
"test_restricted.erl"),
Contents = <<"-module(test_restricted).
-export([local_allowed/3, non_local_allowed/3]).
- local_allowed(i,[],State) ->
+ local_allowed(m,[],State) ->
{true,State};
local_allowed(ugly,[],_State) ->
non_conforming_reply;
@@ -146,7 +147,7 @@ start_restricted_from_shell(Config) when is_list(Config) ->
"test_restricted) end.">>),
?line {ok, test_restricted} =
application:get_env(stdlib, restricted_shell),
- ?line "Pid" ++ _ = t(<<"begin i() end.">>),
+ ?line "Module" ++ _ = t(<<"begin m() end.">>),
?line "exception exit: restricted shell does not allow c(foo)" =
comm_err(<<"begin c(foo) end.">>),
?line "exception exit: restricted shell does not allow init:stop()" =
@@ -199,9 +200,9 @@ start_restricted_on_command_line(Config) when is_list(Config) ->
"-pa "++?config(priv_dir,Config)++
" -stdlib restricted_shell foo"),
?line "Warning! Restricted shell module foo not found: nofile"++_ =
- t({Node, <<"begin i() end.">>}),
- ?line "exception exit: restricted shell does not allow i()" =
- comm_err({Node, <<"begin i() end.">>}),
+ t({Node, <<"begin m() end.">>}),
+ ?line "exception exit: restricted shell does not allow m()" =
+ comm_err({Node, <<"begin m() end.">>}),
?line [ok] =
(catch scan({Node, <<"begin q() end.">>})),
?line test_server:stop_node(Node),
@@ -209,7 +210,7 @@ start_restricted_on_command_line(Config) when is_list(Config) ->
"test_restricted2.erl"),
Contents = <<"-module(test_restricted2).
-export([local_allowed/3, non_local_allowed/3]).
- local_allowed(i,[],State) ->
+ local_allowed(m,[],State) ->
{true,State};
local_allowed(_,_,State) ->
{false,State}.
@@ -225,7 +226,7 @@ start_restricted_on_command_line(Config) when is_list(Config) ->
?line {ok,Node2} = start_node(shell_suite_helper_2,
"-pa "++?config(priv_dir,Config)++
" -stdlib restricted_shell test_restricted2"),
- ?line "Pid" ++ _ = t({Node2,<<"begin i() end.">>}),
+ ?line "Module" ++ _ = t({Node2,<<"begin m() end.">>}),
?line "exception exit: restricted shell does not allow c(foo)" =
comm_err({Node2,<<"begin c(foo) end.">>}),
?line "exception exit: restricted shell does not allow init:stop()" =
@@ -254,7 +255,7 @@ restricted_local(Config) when is_list(Config) ->
"test_restricted_local.erl"),
Contents = <<"-module(test_restricted_local).
-export([local_allowed/3, non_local_allowed/3]).
- local_allowed(i,[],State) ->
+ local_allowed(m,[],State) ->
{true,State};
local_allowed(banan,_,State) ->
{true,State};
@@ -2820,7 +2821,7 @@ otp_10302(Config) when is_list(Config) ->
"ok.\n** exception error: an error occurred when evaluating"
" an arithmetic expression\n in operator '/'/2\n"
- " called as <<\"�\">> / <<\"�\">>.\n" = t({Node,Test7}),
+ " called as <<\"ª\">> / <<\"ª\">>.\n" = t({Node,Test7}),
Test8 =
<<"begin
A = [1089],
diff --git a/lib/stdlib/test/supervisor_3.erl b/lib/stdlib/test/supervisor_3.erl
new file mode 100644
index 0000000000..31b3037d6f
--- /dev/null
+++ b/lib/stdlib/test/supervisor_3.erl
@@ -0,0 +1,45 @@
+%%
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 1996-2011. All Rights Reserved.
+%%
+%% The contents of this file are subject to the Erlang Public License,
+%% Version 1.1, (the "License"); you may not use this file except in
+%% compliance with the License. You should have received a copy of the
+%% Erlang Public License along with this software. If not, it can be
+%% retrieved online at http://www.erlang.org/.
+%%
+%% Software distributed under the License is distributed on an "AS IS"
+%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+%% the License for the specific language governing rights and limitations
+%% under the License.
+%%
+%% %CopyrightEnd%
+%%
+%% Description: Simulates the behaviour that a child process may have.
+%% Is used by the supervisor_SUITE test suite.
+-module(supervisor_3).
+
+-export([start_child/2, init/1]).
+
+-export([handle_call/3, handle_info/2, terminate/2]).
+
+start_child(Name, Caller) ->
+ gen_server:start_link(?MODULE, [Name, Caller], []).
+
+init([Name, Caller]) ->
+ Caller ! {Name, self()},
+ receive
+ {Result, Caller} ->
+ Result
+ end.
+
+handle_call(Req, _From, State) ->
+ {reply, Req, State}.
+
+handle_info(_, State) ->
+ {noreply, State}.
+
+terminate(_Reason, Time) ->
+ timer:sleep(Time),
+ ok.
diff --git a/lib/stdlib/test/supervisor_SUITE.erl b/lib/stdlib/test/supervisor_SUITE.erl
index 569c66959e..ff5be6bb95 100644
--- a/lib/stdlib/test/supervisor_SUITE.erl
+++ b/lib/stdlib/test/supervisor_SUITE.erl
@@ -53,9 +53,10 @@
%% Restart strategy tests
-export([ one_for_one/1,
one_for_one_escalation/1, one_for_all/1,
- one_for_all_escalation/1,
+ one_for_all_escalation/1, one_for_all_other_child_fails_restart/1,
simple_one_for_one/1, simple_one_for_one_escalation/1,
rest_for_one/1, rest_for_one_escalation/1,
+ rest_for_one_other_child_fails_restart/1,
simple_one_for_one_extra/1, simple_one_for_one_shutdown/1]).
%% Misc tests
@@ -107,12 +108,14 @@ groups() ->
{restart_one_for_one, [],
[one_for_one, one_for_one_escalation]},
{restart_one_for_all, [],
- [one_for_all, one_for_all_escalation]},
+ [one_for_all, one_for_all_escalation,
+ one_for_all_other_child_fails_restart]},
{restart_simple_one_for_one, [],
[simple_one_for_one, simple_one_for_one_shutdown,
simple_one_for_one_extra, simple_one_for_one_escalation]},
{restart_rest_for_one, [],
- [rest_for_one, rest_for_one_escalation]}].
+ [rest_for_one, rest_for_one_escalation,
+ rest_for_one_other_child_fails_restart]}].
init_per_suite(Config) ->
Config.
@@ -879,6 +882,57 @@ one_for_all_escalation(Config) when is_list(Config) ->
%%-------------------------------------------------------------------------
+%% Test that the supervisor terminates a restarted child when a different
+%% child fails to start.
+one_for_all_other_child_fails_restart(Config) when is_list(Config) ->
+ process_flag(trap_exit, true),
+ Self = self(),
+ Child1 = {child1, {supervisor_3, start_child, [child1, Self]},
+ permanent, 1000, worker, []},
+ Child2 = {child2, {supervisor_3, start_child, [child2, Self]},
+ permanent, 1000, worker, []},
+ Children = [Child1, Child2],
+ StarterFun = fun() ->
+ {ok, SupPid} = start_link({ok, {{one_for_all, 3, 3600}, Children}}),
+ Self ! {sup_pid, SupPid},
+ receive {stop, Self} -> ok end
+ end,
+ StarterPid = spawn_link(StarterFun),
+ Ok = {{ok, undefined}, Self},
+ %% Let the children start.
+ Child1Pid = receive {child1, Pid1} -> Pid1 end,
+ Child1Pid ! Ok,
+ Child2Pid = receive {child2, Pid2} -> Pid2 end,
+ Child2Pid ! Ok,
+ %% Supervisor started.
+ SupPid = receive {sup_pid, Pid} -> Pid end,
+ link(SupPid),
+ exit(Child1Pid, die),
+ %% Let child1 restart but don't let child2.
+ Child1Pid2 = receive {child1, Pid3} -> Pid3 end,
+ Child1Pid2Ref = erlang:monitor(process, Child1Pid2),
+ Child1Pid2 ! Ok,
+ Child2Pid2 = receive {child2, Pid4} -> Pid4 end,
+ Child2Pid2 ! {{stop, normal}, Self},
+ %% Check child1 is terminated.
+ receive
+ {'DOWN', Child1Pid2Ref, _, _, shutdown} ->
+ ok;
+ {_childName, _Pid} ->
+ exit(SupPid, kill),
+ check_exit([StarterPid, SupPid]),
+ test_server:fail({restarting_child_not_terminated, Child1Pid2})
+ end,
+ %% Let the restart complete.
+ Child1Pid3 = receive {child1, Pid5} -> Pid5 end,
+ Child1Pid3 ! Ok,
+ Child2Pid3 = receive {child2, Pid6} -> Pid6 end,
+ Child2Pid3 ! Ok,
+ StarterPid ! {stop, Self},
+ check_exit([StarterPid, SupPid]).
+
+
+%%-------------------------------------------------------------------------
%% Test the simple_one_for_one base case.
simple_one_for_one(Config) when is_list(Config) ->
process_flag(trap_exit, true),
@@ -1044,6 +1098,52 @@ rest_for_one_escalation(Config) when is_list(Config) ->
terminate(SupPid, CPid1, child1, abnormal),
check_exit([CPid2, SupPid]).
+
+%%-------------------------------------------------------------------------
+%% Test that the supervisor terminates a restarted child when a different
+%% child fails to start.
+rest_for_one_other_child_fails_restart(Config) when is_list(Config) ->
+ process_flag(trap_exit, true),
+ Self = self(),
+ Child1 = {child1, {supervisor_3, start_child, [child1, Self]},
+ permanent, 1000, worker, []},
+ Child2 = {child2, {supervisor_3, start_child, [child2, Self]},
+ permanent, 1000, worker, []},
+ Children = [Child1, Child2],
+ StarterFun = fun() ->
+ {ok, SupPid} = start_link({ok, {{rest_for_one, 3, 3600}, Children}}),
+ Self ! {sup_pid, SupPid},
+ receive {stop, Self} -> ok end
+ end,
+ StarterPid = spawn_link(StarterFun),
+ Ok = {{ok, undefined}, Self},
+ %% Let the children start.
+ Child1Pid = receive {child1, Pid1} -> Pid1 end,
+ Child1Pid ! Ok,
+ Child2Pid = receive {child2, Pid2} -> Pid2 end,
+ Child2Pid ! Ok,
+ %% Supervisor started.
+ SupPid = receive {sup_pid, Pid} -> Pid end,
+ link(SupPid),
+ exit(Child1Pid, die),
+ %% Let child1 restart but don't let child2.
+ Child1Pid2 = receive {child1, Pid3} -> Pid3 end,
+ Child1Pid2 ! Ok,
+ Child2Pid2 = receive {child2, Pid4} -> Pid4 end,
+ Child2Pid2 ! {{stop, normal}, Self},
+ %% Let child2 restart.
+ receive
+ {child2, Child2Pid3} ->
+ Child2Pid3 ! Ok;
+ {child1, _Child1Pid3} ->
+ exit(SupPid, kill),
+ check_exit([StarterPid, SupPid]),
+ test_server:fail({restarting_started_child, Child1Pid2})
+ end,
+ StarterPid ! {stop, Self},
+ check_exit([StarterPid, SupPid]).
+
+
%%-------------------------------------------------------------------------
%% Test that the supervisor does not hang forever if the child unliks
%% and then is terminated by the supervisor.