From 84adefa331c4159d432d22840663c38f155cd4c1 Mon Sep 17 00:00:00 2001 From: Erlang/OTP Date: Fri, 20 Nov 2009 14:54:40 +0000 Subject: The R13B03 release. --- lib/kernel/test/pdict_SUITE.erl | 323 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 323 insertions(+) create mode 100644 lib/kernel/test/pdict_SUITE.erl (limited to 'lib/kernel/test/pdict_SUITE.erl') diff --git a/lib/kernel/test/pdict_SUITE.erl b/lib/kernel/test/pdict_SUITE.erl new file mode 100644 index 0000000000..6aa434b614 --- /dev/null +++ b/lib/kernel/test/pdict_SUITE.erl @@ -0,0 +1,323 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 1999-2009. All Rights Reserved. +%% +%% The contents of this file are subject to the Erlang Public License, +%% Version 1.1, (the "License"); you may not use this file except in +%% compliance with the License. You should have received a copy of the +%% Erlang Public License along with this software. If not, it can be +%% retrieved online at http://www.erlang.org/. +%% +%% Software distributed under the License is distributed on an "AS IS" +%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See +%% the License for the specific language governing rights and limitations +%% under the License. +%% +%% %CopyrightEnd% +%% +-module(pdict_SUITE). +%% NB: The ?line macro cannot be used when testing the dictionary. + + +-include("test_server.hrl"). + +-define(M(A,B),m(A,B,?MODULE,?LINE)). +-ifdef(DEBUG). +-define(DEBUGF(A,B), io:format(A,B)). +-else. +-define(DEBUGF(A,B), noop). +-endif. + +-export([all/1, + simple/1, complicated/1, heavy/1, info/1]). +-export([init_per_testcase/2, fin_per_testcase/2]). +-export([other_process/2]). + +init_per_testcase(_Case, Config) -> + ?line Dog = ?t:timetrap(test_server:minutes(10)), + [{watchdog, Dog} | Config]. +fin_per_testcase(_Case, Config) -> + Dog = ?config(watchdog, Config), + test_server:timetrap_cancel(Dog), + ok. + +all(suite) -> + [simple, complicated, heavy, info]. + +simple(doc) -> + ["Tests simple functionality in process dictionary."]; +simple(suite) -> + []; +simple(Config) when list(Config) -> + XX = get(), + erase(), + L = [a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p, + q,r,s,t,u,v,x,y,z,'A','B','C','D'], + ins_list_0(L), + ins_list_1(L), + L2 = lists:keysort(1, lists:map(fun(X) -> + {X, atom_to_list(X)} + end, + L)), + ?DEBUGF("~p~n",[L2]), + ?M(L2,lists:keysort(1, get())), + ins_list_2(L), + L3 = lists:keysort(1, lists:map(fun(X) -> + {hd(atom_to_list(X)) - $a, + atom_to_list(X)} + end, + L) ++ L2), + ?DEBUGF("~p~n",[L3]), + ?M(L3, lists:keysort(1, get())), + L4 = lists:map(fun(X) -> + lists:sort(get_keys(atom_to_list(X))) + end, + L), + ?DEBUGF("~p~n",[L4]), + ?M(L4,lists:map(fun(X) -> + lists:sort([X, hd(atom_to_list(X)) - $a]) + end, + L)), + erase(), + ?M([],get()), + [put(Key, Value) || {Key,Value} <- XX], + ok. + +complicated(Config) when is_list(Config) -> + Previous = get(), + Previous = erase(), + N = case ?t:is_debug() of + false -> 500000; + true -> 5000 + end, + comp_1(N), + comp_2(N), + N = comp_3(lists:sort(get()), 1), + comp_4(get()), + [] = get(), + [put(Key, Value) || {Key,Value} <- Previous], + ok. + +comp_1(0) -> ok; +comp_1(N) -> + undefined = put({key,N}, {value,N}), + comp_1(N-1). + +comp_2(0) -> ok; +comp_2(N) -> + {value,N} = put({key,N}, {value,N*N}), + comp_2(N-1). + +comp_3([{{key,K},{value,V}}], K) when V =:= K*K -> + K; +comp_3([{{key,K},{value,V}}|T], K) when V =:= K*K -> + comp_3(T, K+1). + +comp_4([{{key,_}=K,{value,_}=Val}|T]) -> + Val = erase(K), + comp_4(T); +comp_4([]) -> ok. + +heavy(doc) -> + ["Tests heavy usage of the process dictionary"]; +heavy(suite) -> + []; +heavy(Config) when is_list(Config) -> + XX = get(), + erase(), + time(50), + ?M([],get()), + time(500), + ?M([],get()), + time(5000), + ?M([],get()), + case {os:type(),?t:is_debug()} of + {vxworks,_} -> ok; + {_,true} -> ok; + _ -> + time(50000), + ?M([], get()) + end, + [put(Key, Value) || {Key,Value} <- XX], + ok. + +info(doc) -> + ["Tests process_info(Pid, dictionary)"]; +info(suite) -> + []; +info(Config) when list(Config) -> + L = [a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p, + q,r,s,t,u,v,x,y,z,'A','B','C','D'], + process_flag(trap_exit,true), + Pid = spawn_link(?MODULE, other_process, [L,self()]), + Dict = receive + {Pid, D} -> + D + end, + ?M({dictionary, Dict}, process_info(Pid, dictionary)), + Pid ! bye, + receive + {'EXIT', Pid, _} -> + ok + end, + ok. + +other_process(List,From) -> + erase(), + ins_list_1(List), + From ! {self(), get()}, + receive + bye -> + ok + end. + +ins_list_2([]) -> + done; +ins_list_2([H|T]) -> + X = {hd(atom_to_list(H)) - $a, atom_to_list(H)}, + _Y = put(element(1,X), element(2,X)), + ?DEBUGF("Inserting ~w: ~w~n",[X,_Y]), + ins_list_2(T). + +ins_list_1([]) -> + done; +ins_list_1([H|T]) -> + X = {H, atom_to_list(H)}, + _Y = put(element(1,X), element(2,X)), + ?DEBUGF("Inserting ~w: ~w~n",[X,_Y]), + ins_list_1(T). + +ins_list_0([]) -> + done; +ins_list_0([H|T]) -> + X = {H, H}, + _Y = put(element(1,X), element(2,X)), + ?DEBUGF("Inserting ~w: ~w~n",[X,_Y]), + ins_list_0(T). + +time(N) -> + ?DEBUGF("~p~n",[erlang:process_info(self())]), + TT1 = erlang:now(), + T1 = insert_testloop(N,N,0), + TT2 = erlang:now(), + T2 = lookup_testloop(N,N,0), + TT3 = erlang:now(), + T5 = delete_testloop(N,N,0), + TT6 = erlang:now(), + io:format("~p inserts took ~.2f(~.2f) seconds~n", + [N, nowdiff3(TT1,TT2), T1 / 100]), + io:format("~p lookups took ~.2f(~.2f) seconds~n", + [N, nowdiff3(TT2,TT3), T2 / 100]), + io:format("~p deletes took ~.2f(~.2f) seconds~n", + [N, nowdiff3(TT3,TT6), T5 / 100]), + io:format("Total time for ~p elements is ~.2f(~.2f) seconds~n", + [N, nowdiff3(TT1,TT6), (T1+T2+T5) / 100]), + ok. + +key_to_object(Key) -> + {Key, Key,[Key, Key, {Key, banan}]}. + +time_call(Fun,Acc) -> + T1 = erlang:now(), + Ret = Fun(), + T2 = erlang:now(), + {nowdiff2(T1,T2)+Acc,Ret}. + +delete_testloop(0, _X, Acc) -> + ?DEBUGF("all ~p deleted~n",[_X]), + Acc; + +delete_testloop(N, X, Acc) -> + Key = gen_key(N), + Obj = key_to_object(Key), + case get(Key) of + Obj -> + ok; + Y -> + io:format("Error - Object ~p does not exist when we are " + "gonna delete!(N=~p, result=~p)~n",[Obj,N,Y]), + exit({inconsistent_1, delete_testloop, Obj, N, Y}) + end, + + {T, Obj2} = time_call(fun() -> erase(Key) end, Acc), + ?M(Obj,Obj2), + case {(X-N) rem 10000,(X-N)} of + {_,0} -> + ok; + {0,_} -> + ?DEBUGF("~p~n",[X-N]); + _ -> + ok + end, + case get(Key) of + undefined -> + ok; + Else -> + io:format("Error - Object ~p does still exist after " + "delete!(N=~p, result=~p)~n",[Obj,N,Else]), + exit({inconsistent_2, delete_testloop, Obj, N, Else}) + end, + delete_testloop(N-1,X,T). + +lookup_testloop(0, X, Acc) -> + io:format("all ~p looked up~n",[X]), + Acc; +lookup_testloop(N, X, Acc) -> + Key = gen_key(N), + D = key_to_object(Key), + {T, D2} = time_call(fun() -> get(Key) end, Acc), + ?M(D,D2), + case {(X-N) rem 10000,(X-N)} of + {_,0} -> + ok; + {0,_} -> + ?DEBUGF("~p~n",[X-N]); + _ -> + ok + end, + lookup_testloop(N-1,X,T). + +insert_testloop(0,X,Acc) -> + io:format("all ~p inserted~n",[X]), + Acc; +insert_testloop(N,X,Acc) -> + Key = gen_key(N), + D = key_to_object(Key), + {T,_} = time_call(fun() -> put(Key,D) end, Acc), + case {(X-N) rem 10000,(X-N)} of + {_,0} -> + ok; + {0,_} -> + ?DEBUGF("~p~n",[X-N]); + _ -> + ok + end, + insert_testloop(N-1,X,T). + + +gen_key(0,A)-> + A; +gen_key(N,A) -> + X = ((N-1) rem 26) + $a, + gen_key((N-1) div 26, [X|A]). +gen_key(N) -> + gen_key(N+1,[]). + +nowtonumber({Mega, Secs, Milli}) -> + Milli div 10000 + Secs * 100 + Mega * 100000000. + +nowdiff2(T1,T2) -> + nowtonumber(T2) - nowtonumber(T1). +nowdiff3(T1,T2) -> + (nowtonumber(T2) - nowtonumber(T1)) / 100. + +m(A,B,Module,Line) -> + case A == B of + true -> + ok; + _ -> + io:format("~p does not match ~p in module ~p, line ~p, exit.~n", + [A,B,Module,Line]), + exit({no_match,{A,B},Module,Line}) + end. -- cgit v1.2.3