1: %%
    2: %% %CopyrightBegin%
    3: %% 
    4: %% Copyright Ericsson AB 2007-2011. All Rights Reserved.
    5: %% 
    6: %% The contents of this file are subject to the Erlang Public License,
    7: %% Version 1.1, (the "License"); you may not use this file except in
    8: %% compliance with the License. You should have received a copy of the
    9: %% Erlang Public License along with this software. If not, it can be
   10: %% retrieved online at http://www.erlang.org/.
   11: %% 
   12: %% Software distributed under the License is distributed on an "AS IS"
   13: %% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
   14: %% the License for the specific language governing rights and limitations
   15: %% under the License.
   16: %% 
   17: %% %CopyrightEnd%
   18: %%
   19: 
   20: -module(array_SUITE).
   21: 
   22: -include_lib("test_server/include/test_server.hrl").
   23: 
   24: %% Default timetrap timeout (set in init_per_testcase).
   25: %% This should be set relatively high (10-15 times the expected
   26: %% max testcasetime).
   27: -define(default_timeout, ?t:seconds(60)).
   28: 
   29: %% Test server specific exports
   30: -export([all/0, suite/0,groups/0,init_per_suite/1, end_per_suite/1, 
   31: 	 init_per_group/2,end_per_group/2]).
   32: -export([init_per_testcase/2, end_per_testcase/2]).
   33: 
   34: -export([
   35:   	 new_test/1,
   36: 	 fix_test/1,
   37: 	 relax_test/1,
   38: 	 resize_test/1,
   39:   	 set_get_test/1,
   40:   	 to_list_test/1,
   41:   	 sparse_to_list_test/1,
   42:   	 from_list_test/1,
   43:   	 to_orddict_test/1,
   44:   	 sparse_to_orddict_test/1,
   45:   	 from_orddict_test/1,
   46:   	 map_test/1,
   47:   	 sparse_map_test/1,
   48:   	 foldl_test/1,
   49:   	 sparse_foldl_test/1,
   50:   	 foldr_test/1,
   51:   	 sparse_foldr_test/1
   52: 	]).
   53: 
   54: 
   55: -export([t/0,t/1,extract_tests/0]).
   56: 
   57: -import(array, 
   58: 	[new/0, new/1, new/2, is_array/1, set/3, get/2, %size/1,
   59: 	 sparse_size/1, default/1, reset/2, to_list/1, sparse_to_list/1,
   60: 	 from_list/1, from_list/2, to_orddict/1, sparse_to_orddict/1,
   61: 	 from_orddict/1, from_orddict/2, map/2, sparse_map/2, foldl/3,
   62: 	 foldr/3, sparse_foldl/3, sparse_foldr/3, fix/1, relax/1, is_fix/1,
   63: 	 resize/1, resize/2]).
   64: 
   65: %%
   66: %% all/1
   67: %%
   68: suite() -> [{ct_hooks,[ts_install_cth]}].
   69: 
   70: all() -> 
   71:     [new_test, fix_test, relax_test, resize_test,
   72:      set_get_test, to_list_test, sparse_to_list_test,
   73:      from_list_test, to_orddict_test, sparse_to_orddict_test,
   74:      from_orddict_test, map_test, sparse_map_test,
   75:      foldl_test, sparse_foldl_test, foldr_test,
   76:      sparse_foldr_test].
   77: 
   78: groups() -> 
   79:     [].
   80: 
   81: init_per_suite(Config) ->
   82:     Config.
   83: 
   84: end_per_suite(_Config) ->
   85:     ok.
   86: 
   87: init_per_group(_GroupName, Config) ->
   88:     Config.
   89: 
   90: end_per_group(_GroupName, Config) ->
   91:     Config.
   92: 
   93: 
   94: init_per_testcase(_Case, Config) ->
   95:     ?line Dog=test_server:timetrap(?default_timeout),
   96:     [{watchdog, Dog}|Config].
   97: 
   98: end_per_testcase(_Case, Config) ->
   99:     Dog=?config(watchdog, Config),
  100:     test_server:timetrap_cancel(Dog),
  101:     ok.
  102: 
  103: -define(LEAFSIZE,10).
  104: -define(NODESIZE,?LEAFSIZE).
  105: 
  106: -record(array,  {size,		%% number of defined entries
  107: 		 max,		%% maximum number of entries in current tree
  108: 		 default,	%% the default value (usually 'undefined')
  109: 		 elements	%% the tuple tree
  110: 		}).
  111: 
  112: -define(_assert(What), 
  113: 	begin ?line true = What end
  114:        ).
  115: -define(_assertNot(What), 
  116: 	begin ?line false = What end
  117:        ).
  118: 
  119: -define(_assertMatch(Res,What), 
  120: 	begin 
  121: 	    ?line case What of Res -> ok end
  122: 	end
  123:        ).
  124: -define(_assertError(Reas,What), 
  125: 	begin ?line fun() ->
  126: 			    try What of
  127: 				A_Success -> exit({test_error, A_Success})
  128: 			    catch error:Reas -> ok end
  129: 		    end()
  130: 	end
  131:        ).
  132: 
  133: -define(LET(Var,Expr, Test), begin ?line fun() -> Var = Expr, Test end() end).
  134: 
  135: -define(_test(Expr), begin ?line Expr end).
  136: 
  137: %%%%%%%%%%%%%%%%%%%%%%%%%%%%
  138: %% Some helpers to be able to run the tests without testserver
  139: %%%%%%%%%%%%%%%%%%%%%%%%%
  140: t() -> t([all]).
  141: 
  142: t(What) when not is_list(What) ->
  143:     t([What]);
  144: t(What) ->
  145:     lists:foreach(fun(T) ->
  146: 			  io:format("Test ~p ~n",[T]),
  147: 			  try 
  148: 			      ?MODULE:T([])
  149: 			  catch _E:_R ->
  150: 				  Line = get(test_server_loc),
  151: 				  io:format("Failed ~p:~p ~p ~p~n   ~p~n", 
  152: 					    [T,Line,_E,_R, erlang:get_stacktrace()])
  153: 			  end
  154: 		  end, expand(What)).
  155: 
  156: expand(All) ->
  157:     lists:reverse(expand(All,[])).
  158: expand([H|T], Acc)  -> 
  159:     case ?MODULE:H(suite) of
  160: 	[] -> expand(T,[H|Acc]);
  161: 	Cs -> 
  162: 	    R = expand(Cs, Acc),
  163: 	    expand(T, R)
  164:     end;
  165: expand([], Acc) -> Acc.
  166: 
  167: %%%%% extract tests 
  168: 
  169: extract_tests() ->
  170:     {ok, In} = file:open("../src/array.erl", [read]),
  171:     {ok, Out} = file:open("array_temp.erl", [write]),
  172:     try 
  173: 	Tests = extract_tests(In,Out,[]),
  174: 	Call = fun(Test) ->
  175: 		       io:format(Out, "~s(doc) -> [];~n", [Test]),
  176: 		       io:format(Out, "~s(suite) -> [];~n", [Test]),
  177: 		       io:format(Out, "~s(Config) when is_list(Config) -> ~s_(), ok.~n",
  178: 				 [Test, Test])
  179: 	       end,
  180: 	[Call(Test) || Test <- Tests],
  181: 	io:format("Tests ~p~n", [Tests])
  182:     catch _:Err ->
  183: 	    io:format("Error: ~p ~p~n", [Err, erlang:get_stacktrace()])
  184:     end,
  185:     file:close(In),
  186:     file:close(Out).
  187: 
  188: extract_tests(In,Out,Tests) ->
  189:     case io:get_line(In,"") of
  190: 	eof -> lists:reverse(Tests);
  191: 	"-ifdef(EUNIT)" ++ _ ->
  192: 	    Test = write_test(In,Out),
  193: 	    extract_tests(In,Out, [Test|Tests]);
  194: 	_E ->
  195: 	    extract_tests(In,Out,Tests)
  196:     end.
  197: 
  198: write_test(In,Out) ->
  199:     Line = io:get_line(In,""),
  200:     io:put_chars(Out, Line),
  201:     [$_|Test] = lists:dropwhile(fun($_) -> false;(_) -> true end,lists:reverse(Line)),
  202:     write_test_1(In,Out),
  203:     lists:reverse(Test).
  204:    
  205: write_test_1(In,Out) ->
  206:     case io:get_line(In,"") of
  207: 	"-endif" ++ _ ->
  208: 	    io:nl(Out),
  209: 	    ok;
  210: 	Line ->
  211: 	    io:put_chars(Out, Line),
  212: 	    write_test_1(In,Out)
  213:     end.	   
  214: 
  215: %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  216: %% Actual tests
  217: 
  218: new_test_() ->
  219:     N0 = ?LEAFSIZE,
  220:     N01 = N0+1,
  221:     N1 = ?NODESIZE*N0,
  222:     N11 = N1+1,
  223:     N2 = ?NODESIZE*N1,
  224:     [?_test(new()),
  225: 
  226:      ?_test(new([])),
  227:      ?_test(new(10)),
  228:      ?_test(new({size,10})),
  229:      ?_test(new(fixed)),
  230:      ?_test(new({fixed,true})),
  231:      ?_test(new({fixed,false})),
  232:      ?_test(new({default,undefined})),
  233:      ?_test(new([{size,100},{fixed,false},{default,undefined}])),
  234:      ?_test(new([100,fixed,{default,0}])),
  235: 
  236:      ?_assert(new() =:= new([])),
  237:      ?_assert(new() =:= new([{size,0},{default,undefined},{fixed,false}])),
  238:      ?_assert(new() =:= new(0, {fixed,false})),
  239:      ?_assert(new(fixed) =:= new(0)),
  240:      ?_assert(new(fixed) =:= new(0, [])),
  241:      ?_assert(new(10) =:= new([{size,0},{size,5},{size,10}])),
  242:      ?_assert(new(10) =:= new(0, {size,10})),
  243:      ?_assert(new(10, []) =:= new(10, [{default,undefined},{fixed,true}])),
  244: 
  245:      ?_assertError(badarg, new(-1)),
  246:      ?_assertError(badarg, new(10.0)),
  247:      ?_assertError(badarg, new(undefined)),
  248:      ?_assertError(badarg, new([undefined])),
  249:      ?_assertError(badarg, new([{default,0} | fixed])),
  250: 
  251:      ?_assertError(badarg, new(-1, [])),
  252:      ?_assertError(badarg, new(10.0, [])),
  253:      ?_assertError(badarg, new(undefined, [])),
  254: 
  255:      ?_assertMatch(#array{size=0,max=N0,default=undefined,elements=N0},
  256: 		   new()),
  257:      ?_assertMatch(#array{size=0,max=0,default=undefined,elements=N0},
  258: 		   new(fixed)),
  259:      ?_assertMatch(#array{size=N0,max=N0,elements=N0},
  260: 		   new(N0, {fixed,false})),
  261:      ?_assertMatch(#array{size=N01,max=N1,elements=N1},
  262: 		   new(N01, {fixed,false})),
  263:      ?_assertMatch(#array{size=N1,max=N1,elements=N1},
  264: 		   new(N1, {fixed,false})),
  265:      ?_assertMatch(#array{size=N11,max=N2,elements=N2},
  266: 		   new(N11, {fixed,false})),
  267:      ?_assertMatch(#array{size=N2, max=N2, default=42,elements=N2},
  268: 		   new(N2, [{fixed,false},{default,42}])),
  269: 
  270:      ?_assert(0 =:= array:size(new())),
  271:      ?_assert(17 =:= array:size(new(17))),
  272:      ?_assert(100 =:= array:size(array:set(99,0,new()))),
  273:      ?_assertError(badarg, array:size({bad_data,gives_error})),
  274: 
  275:      ?_assert(undefined =:= default(new())),
  276:      ?_assert(4711 =:= default(new({default,4711}))),
  277:      ?_assert(0 =:= default(new(10, {default,0}))),
  278:      ?_assertError(badarg, default({bad_data,gives_error})),
  279: 
  280:      ?_assert(is_array(new())),
  281:      ?_assert(false =:= is_array({foobar, 23, 23})),
  282:      ?_assert(false =:= is_array(#array{size=bad})),
  283:      ?_assert(false =:= is_array(#array{max=bad})),
  284:      ?_assert(is_array(new(10))),
  285:      ?_assert(is_array(new(10, {fixed,false})))
  286:     ].
  287: 
  288: fix_test_() ->
  289:     [?_assert(is_array(fix(new()))),
  290:      ?_assert(fix(new()) =:= new(fixed)),
  291: 
  292:      ?_assertNot(is_fix(new())),
  293:      ?_assertNot(is_fix(new([]))),
  294:      ?_assertNot(is_fix(new({fixed,false}))),
  295:      ?_assertNot(is_fix(new(10, {fixed,false}))),
  296:      ?_assert(is_fix(new({fixed,true}))),
  297:      ?_assert(is_fix(new(fixed))),
  298:      ?_assert(is_fix(new(10))),
  299:      ?_assert(is_fix(new(10, []))),
  300:      ?_assert(is_fix(new(10, {fixed,true}))),
  301:      ?_assert(is_fix(fix(new()))),
  302:      ?_assert(is_fix(fix(new({fixed,false})))),
  303: 
  304:      ?_test(set(0, 17, new())),
  305:      ?_assertError(badarg, set(0, 17, new(fixed))),
  306:      ?_assertError(badarg, set(1, 42, fix(set(0, 17, new())))),
  307: 
  308:      ?_test(set(9, 17, new(10))),
  309:      ?_assertError(badarg, set(10, 17, new(10))),
  310:      ?_assertError(badarg, set(10, 17, fix(new(10, {fixed,false}))))
  311:     ].
  312: 
  313: relax_test_() ->
  314:     [?_assert(is_array(relax(new(fixed)))),
  315:      ?_assertNot(is_fix(relax(fix(new())))),
  316:      ?_assertNot(is_fix(relax(new(fixed)))),
  317: 
  318:      ?_assert(new() =:= relax(new(fixed))),
  319:      ?_assert(new() =:= relax(new(0))),
  320:      ?_assert(new(17, {fixed,false}) =:= relax(new(17))),
  321:      ?_assert(new(100, {fixed,false})
  322: 	      =:= relax(fix(new(100, {fixed,false}))))
  323:     ].
  324: 
  325: resize_test_() ->
  326:     [?_assert(resize(0, new()) =:= new()),
  327:      ?_assert(resize(99, new(99)) =:= new(99)),
  328:      ?_assert(resize(99, relax(new(99))) =:= relax(new(99))),
  329:      ?_assert(is_fix(resize(100, new(10)))),
  330:      ?_assertNot(is_fix(resize(100, relax(new(10))))),
  331: 
  332:      ?_assert(array:size(resize(100, new())) =:= 100),
  333:      ?_assert(array:size(resize(0, new(100))) =:= 0),
  334:      ?_assert(array:size(resize(99, new(10))) =:= 99),
  335:      ?_assert(array:size(resize(99, new(1000))) =:= 99),
  336: 
  337:      ?_assertError(badarg, set(99, 17, new(10))),
  338:      ?_test(set(99, 17, resize(100, new(10)))),
  339:      ?_assertError(badarg, set(100, 17, resize(100, new(10)))),
  340: 
  341:      ?_assert(array:size(resize(new())) =:= 0),
  342:      ?_assert(array:size(resize(new(8))) =:= 0),
  343:      ?_assert(array:size(resize(array:set(7, 0, new()))) =:= 8),
  344:      ?_assert(array:size(resize(array:set(7, 0, new(10)))) =:= 8),
  345:      ?_assert(array:size(resize(array:set(99, 0, new(10,{fixed,false}))))
  346: 	      =:= 100),
  347:      ?_assert(array:size(resize(array:set(7, undefined, new()))) =:= 0),
  348:      ?_assert(array:size(resize(array:from_list([1,2,3,undefined])))
  349: 	      =:= 3),
  350:      ?_assert(array:size(
  351: 		resize(array:from_orddict([{3,0},{17,0},{99,undefined}])))
  352: 	      =:= 18),
  353:      ?_assertError(badarg, resize(foo, bad_argument))
  354:     ].
  355: 
  356: set_get_test_() ->
  357:     N0 = ?LEAFSIZE,
  358:     N1 = ?NODESIZE*N0,
  359:     [?_assert(array:get(0, new()) =:= undefined),
  360:      ?_assert(array:get(1, new()) =:= undefined),
  361:      ?_assert(array:get(99999, new()) =:= undefined),
  362: 
  363:      ?_assert(array:get(0, new(1)) =:= undefined),
  364:      ?_assert(array:get(0, new(1,{default,0})) =:= 0),
  365:      ?_assert(array:get(9, new(10)) =:= undefined),
  366: 
  367:      ?_assertError(badarg, array:get(0, new(fixed))),
  368:      ?_assertError(badarg, array:get(1, new(1))),
  369:      ?_assertError(badarg, array:get(-1, new(1))),
  370:      ?_assertError(badarg, array:get(10, new(10))),
  371:      ?_assertError(badarg, array:set(-1, foo, new(10))),
  372:      ?_assertError(badarg, array:set(10, foo, no_array)),
  373: 
  374:      ?_assert(array:size(set(0, 17, new())) =:= 1),
  375:      ?_assert(array:size(set(N1-1, 17, new())) =:= N1),
  376:      ?_assert(array:size(set(0, 42, set(0, 17, new()))) =:= 1),
  377:      ?_assert(array:size(set(9, 42, set(0, 17, new()))) =:= 10),
  378: 
  379:      ?_assert(array:get(0, set(0, 17, new())) =:= 17),
  380:      ?_assert(array:get(0, set(1, 17, new())) =:= undefined),
  381:      ?_assert(array:get(1, set(1, 17, new())) =:= 17),
  382: 
  383:      ?_assert(array:get(0, fix(set(0, 17, new()))) =:= 17),
  384:      ?_assertError(badarg, array:get(1, fix(set(0, 17, new())))),
  385: 
  386:      ?_assert(array:get(N1-2, set(N1-1, 17, new())) =:= undefined),
  387:      ?_assert(array:get(N1-1, set(N1-1, 17, new())) =:= 17),
  388:      ?_assertError(badarg, array:get(N1, fix(set(N1-1, 17, new())))),
  389: 
  390:      ?_assert(array:get(0, set(0, 42, set(0, 17, new()))) =:= 42),
  391: 
  392:      ?_assertError(badarg, array:get(0, reset(11, new([{size,10}])))),
  393:      ?_assertError(badarg, array:get(0, reset(-1, new([{size,10}])))),
  394:      ?_assert(array:get(0, reset(0,  new())) =:= undefined),
  395:      ?_assert(array:get(0, reset(0,  set(0,  17, new()))) =:= undefined),
  396:      ?_assert(array:get(0, reset(9,  set(9,  17, new()))) =:= undefined),
  397:      ?_assert(array:get(0, reset(11, set(11, 17, new()))) =:= undefined),
  398:      ?_assert(array:get(0, reset(11, set(12, 17, new()))) =:= undefined),
  399:      ?_assert(array:get(0, reset(1,  set(12, 17, new()))) =:= undefined),
  400:      ?_assert(array:get(0, reset(11, new())) =:= undefined),
  401:      ?_assert(array:get(0, reset(0,  set(0,  17, new({default,42})))) =:= 42),
  402:      ?_assert(array:get(0, reset(0,  new({default,42}))) =:= 42)
  403:     ].
  404: 
  405: to_list_test_() ->
  406:     N0 = ?LEAFSIZE,
  407:     [?_assert([] =:= to_list(new())),
  408:      ?_assert([undefined] =:= to_list(new(1))),
  409:      ?_assert([undefined,undefined] =:= to_list(new(2))),
  410:      ?_assert(lists:duplicate(N0,0) =:= to_list(new(N0,{default,0}))),
  411:      ?_assert(lists:duplicate(N0+1,1) =:= to_list(new(N0+1,{default,1}))),
  412:      ?_assert(lists:duplicate(N0+2,2) =:= to_list(new(N0+2,{default,2}))),
  413:      ?_assert(lists:duplicate(666,6) =:= to_list(new(666,{default,6}))),
  414:      ?_assert([1,2,3] =:= to_list(set(2,3,set(1,2,set(0,1,new()))))),
  415:      ?_assert([3,2,1] =:= to_list(set(0,3,set(1,2,set(2,1,new()))))),
  416:      ?_assert([1|lists:duplicate(N0-2,0)++[1]] =:= 
  417: 	      to_list(set(N0-1,1,set(0,1,new({default,0}))))),
  418:      ?_assert([1|lists:duplicate(N0-1,0)++[1]] =:= 
  419: 	      to_list(set(N0,1,set(0,1,new({default,0}))))),
  420:      ?_assert([1|lists:duplicate(N0,0)++[1]] =:= 
  421: 	      to_list(set(N0+1,1,set(0,1,new({default,0}))))),
  422:      ?_assert([1|lists:duplicate(N0*3,0)++[1]] =:= 
  423: 	      to_list(set((N0*3)+1,1,set(0,1,new({default,0}))))),
  424:      ?_assertError(badarg, to_list(no_array))
  425:     ].
  426: 
  427: sparse_to_list_test_() ->
  428:     N0 = ?LEAFSIZE,
  429:     [?_assert([] =:= sparse_to_list(new())),
  430:      ?_assert([] =:= sparse_to_list(new(1))),
  431:      ?_assert([] =:= sparse_to_list(new(1,{default,0}))),
  432:      ?_assert([] =:= sparse_to_list(new(2))),
  433:      ?_assert([] =:= sparse_to_list(new(2,{default,0}))),
  434:      ?_assert([] =:= sparse_to_list(new(N0,{default,0}))),
  435:      ?_assert([] =:= sparse_to_list(new(N0+1,{default,1}))),
  436:      ?_assert([] =:= sparse_to_list(new(N0+2,{default,2}))),
  437:      ?_assert([] =:= sparse_to_list(new(666,{default,6}))),
  438:      ?_assert([1,2,3] =:= sparse_to_list(set(2,3,set(1,2,set(0,1,new()))))),
  439:      ?_assert([3,2,1] =:= sparse_to_list(set(0,3,set(1,2,set(2,1,new()))))),
  440:      ?_assert([0,1] =:= sparse_to_list(set(N0-1,1,set(0,0,new())))),
  441:      ?_assert([0,1] =:= sparse_to_list(set(N0,1,set(0,0,new())))),
  442:      ?_assert([0,1] =:= sparse_to_list(set(N0+1,1,set(0,0,new())))),
  443:      ?_assert([0,1,2] =:= sparse_to_list(set(N0*10+1,2,set(N0*2+1,1,set(0,0,new()))))),
  444:      ?_assertError(badarg, sparse_to_list(no_array))
  445:     ].
  446: 
  447: from_list_test_() ->
  448:     N0 = ?LEAFSIZE,
  449:     N1 = ?NODESIZE*N0,
  450:     N2 = ?NODESIZE*N1,
  451:     N3 = ?NODESIZE*N2,
  452:     N4 = ?NODESIZE*N3,
  453:     [?_assert(array:size(from_list([])) =:= 0),
  454:      ?_assert(array:is_fix(from_list([])) =:= false),
  455:      ?_assert(array:size(from_list([undefined])) =:= 1),
  456:      ?_assert(array:is_fix(from_list([undefined])) =:= false),
  457:      ?_assert(array:size(from_list(lists:seq(1,N1))) =:= N1),
  458:      ?_assert(to_list(from_list(lists:seq(1,N0))) =:= lists:seq(1,N0)),
  459:      ?_assert(to_list(from_list(lists:seq(1,N0+1))) =:= lists:seq(1,N0+1)),
  460:      ?_assert(to_list(from_list(lists:seq(1,N0+2))) =:= lists:seq(1,N0+2)),
  461:      ?_assert(to_list(from_list(lists:seq(1,N2))) =:= lists:seq(1,N2)),
  462:      ?_assert(to_list(from_list(lists:seq(1,N2+1))) =:= lists:seq(1,N2+1)),
  463:      ?_assert(to_list(from_list(lists:seq(0,N3))) =:= lists:seq(0,N3)),
  464:      ?_assert(to_list(from_list(lists:seq(0,N4))) =:= lists:seq(0,N4)),
  465:      ?_assertError(badarg, from_list([a,b,a,c|d])),
  466:      ?_assertError(badarg, from_list(no_array))     
  467:     ].
  468: 
  469: to_orddict_test_() ->
  470:     N0 = ?LEAFSIZE,
  471:     [?_assert([] =:= to_orddict(new())),
  472:      ?_assert([{0,undefined}] =:= to_orddict(new(1))),
  473:      ?_assert([{0,undefined},{1,undefined}] =:= to_orddict(new(2))),
  474:      ?_assert([{N,0}||N<-lists:seq(0,N0-1)]
  475: 	      =:= to_orddict(new(N0,{default,0}))),
  476:      ?_assert([{N,1}||N<-lists:seq(0,N0)]
  477: 	      =:= to_orddict(new(N0+1,{default,1}))),
  478:      ?_assert([{N,2}||N<-lists:seq(0,N0+1)]
  479: 	      =:= to_orddict(new(N0+2,{default,2}))),
  480:      ?_assert([{N,6}||N<-lists:seq(0,665)]
  481: 	      =:= to_orddict(new(666,{default,6}))),
  482:      ?_assert([{0,1},{1,2},{2,3}] =:=
  483: 	      to_orddict(set(2,3,set(1,2,set(0,1,new()))))),
  484:      ?_assert([{0,3},{1,2},{2,1}] =:=
  485: 	      to_orddict(set(0,3,set(1,2,set(2,1,new()))))),
  486:      ?_assert([{0,1}|[{N,0}||N<-lists:seq(1,N0-2)]++[{N0-1,1}]]
  487: 	      =:= to_orddict(set(N0-1,1,set(0,1,new({default,0}))))),
  488:      ?_assert([{0,1}|[{N,0}||N<-lists:seq(1,N0-1)]++[{N0,1}]]
  489: 	      =:= to_orddict(set(N0,1,set(0,1,new({default,0}))))),
  490:      ?_assert([{0,1}|[{N,0}||N<-lists:seq(1,N0)]++[{N0+1,1}]]
  491: 	      =:= to_orddict(set(N0+1,1,set(0,1,new({default,0}))))),
  492:      ?_assert([{0,0} | [{N,undefined}||N<-lists:seq(1,N0*2)]] ++ 
  493: 	      [{N0*2+1,1} | [{N,undefined}||N<-lists:seq(N0*2+2,N0*10)]] ++
  494: 	      [{N0*10+1,2}] =:= 
  495: 	      to_orddict(set(N0*10+1,2,set(N0*2+1,1,set(0,0,new()))))),
  496:      ?_assertError(badarg, to_orddict(no_array))     
  497:     ].
  498: 
  499: sparse_to_orddict_test_() ->
  500:     N0 = ?LEAFSIZE,
  501:     [?_assert([] =:= sparse_to_orddict(new())),
  502:      ?_assert([] =:= sparse_to_orddict(new(1))),
  503:      ?_assert([] =:= sparse_to_orddict(new(1,{default,0}))),
  504:      ?_assert([] =:= sparse_to_orddict(new(2))),
  505:      ?_assert([] =:= sparse_to_orddict(new(2,{default,0}))),
  506:      ?_assert([] =:= sparse_to_orddict(new(N0,{default,0}))),
  507:      ?_assert([] =:= sparse_to_orddict(new(N0+1,{default,1}))),
  508:      ?_assert([] =:= sparse_to_orddict(new(N0+2,{default,2}))),
  509:      ?_assert([] =:= sparse_to_orddict(new(666,{default,6}))),
  510:      ?_assert([{0,1},{1,2},{2,3}] =:=
  511: 	      sparse_to_orddict(set(2,3,set(1,2,set(0,1,new()))))),
  512:      ?_assert([{0,3},{1,2},{2,1}] =:=
  513: 	      sparse_to_orddict(set(0,3,set(1,2,set(2,1,new()))))),
  514:      ?_assert([{0,1},{N0-1,1}] =:=
  515: 	      sparse_to_orddict(set(N0-1,1,set(0,1,new({default,0}))))),
  516:      ?_assert([{0,1},{N0,1}] =:=
  517: 	      sparse_to_orddict(set(N0,1,set(0,1,new({default,0}))))),
  518:      ?_assert([{0,1},{N0+1,1}] =:=
  519: 	      sparse_to_orddict(set(N0+1,1,set(0,1,new({default,0}))))),
  520:      ?_assert([{0,0},{N0*2+1,1},{N0*10+1,2}] =:= 
  521: 	      sparse_to_orddict(set(N0*10+1,2,set(N0*2+1,1,set(0,0,new()))))),
  522:      ?_assertError(badarg, sparse_to_orddict(no_array))     
  523:     ].
  524: 
  525: from_orddict_test_() ->
  526:     N0 = ?LEAFSIZE,
  527:     N1 = ?NODESIZE*N0,
  528:     N2 = ?NODESIZE*N1,
  529:     N3 = ?NODESIZE*N2,
  530:     N4 = ?NODESIZE*N3,
  531:     [?_assert(array:size(from_orddict([])) =:= 0),
  532:      ?_assert(array:is_fix(from_orddict([])) =:= false),
  533:      ?_assert(array:size(from_orddict([{0,undefined}])) =:= 1),
  534:      ?_assert(array:is_fix(from_orddict([{0,undefined}])) =:= false),
  535:      ?_assert(array:size(from_orddict([{N0-1,undefined}])) =:= N0),
  536:      ?_assert(array:size(from_orddict([{N,0}||N<-lists:seq(0,N1-1)]))
  537: 	      =:= N1),
  538:      ?_assertError({badarg,_}, from_orddict([foo])),
  539:      ?_assertError({badarg,_}, from_orddict([{200,foo},{1,bar}])),
  540:      ?_assertError({badarg,_}, from_orddict([{N,0}||N<-lists:seq(0,N0-1)] ++ not_a_list)),
  541:      ?_assertError(badarg, from_orddict(no_array)),
  542: 
  543: 
  544:      ?_assert(?LET(L, [{N,0}||N<-lists:seq(0,N0-1)],
  545: 		   L =:= to_orddict(from_orddict(L)))),
  546:      ?_assert(?LET(L, [{N,0}||N<-lists:seq(0,N0)],
  547: 		   L =:= to_orddict(from_orddict(L)))),
  548:      ?_assert(?LET(L, [{N,0}||N<-lists:seq(0,N2-1)],
  549: 		   L =:= to_orddict(from_orddict(L)))),
  550:      ?_assert(?LET(L, [{N,0}||N<-lists:seq(0,N2)],
  551: 		   L =:= to_orddict(from_orddict(L)))),
  552:      ?_assert(?LET(L, [{N,0}||N<-lists:seq(0,N3-1)],
  553: 		   L =:= to_orddict(from_orddict(L)))),
  554:      ?_assert(?LET(L, [{N,0}||N<-lists:seq(0,N4-1)],
  555: 		   L =:= to_orddict(from_orddict(L)))),
  556: 
  557:      %% Hole in the begining
  558:      ?_assert(?LET(L, [{0,0}],
  559: 		   L =:= sparse_to_orddict(from_orddict(L)))),
  560:      ?_assert(?LET(L, [{N0,0}],
  561: 		   L =:= sparse_to_orddict(from_orddict(L)))),
  562:      ?_assert(?LET(L, [{N1,0}],
  563: 		   L =:= sparse_to_orddict(from_orddict(L)))),
  564:      ?_assert(?LET(L, [{N3,0}],
  565: 		   L =:= sparse_to_orddict(from_orddict(L)))),
  566:      ?_assert(?LET(L, [{N4,0}],
  567: 		   L =:= sparse_to_orddict(from_orddict(L)))),
  568:      ?_assert(?LET(L, [{N0-1,0}],
  569: 		   L =:= sparse_to_orddict(from_orddict(L)))),
  570:      ?_assert(?LET(L, [{N1-1,0}],
  571: 		   L =:= sparse_to_orddict(from_orddict(L)))),
  572:      ?_assert(?LET(L, [{N3-1,0}],
  573: 		   L =:= sparse_to_orddict(from_orddict(L)))),
  574:      ?_assert(?LET(L, [{N4-1,0}],
  575: 		   L =:= sparse_to_orddict(from_orddict(L)))),
  576: 
  577:      %% Hole in middle 
  578:      
  579:      ?_assert(?LET(L, [{0,0},{N0,0}],
  580: 		   L =:= sparse_to_orddict(from_orddict(L)))),
  581:      ?_assert(?LET(L, [{0,0},{N1,0}],
  582: 		   L =:= sparse_to_orddict(from_orddict(L)))),
  583:      ?_assert(?LET(L, [{0,0},{N3,0}],
  584: 		   L =:= sparse_to_orddict(from_orddict(L)))),
  585:      ?_assert(?LET(L, [{0,0},{N4,0}],
  586: 		   L =:= sparse_to_orddict(from_orddict(L)))),
  587:      ?_assert(?LET(L, [{0,0},{N0-1,0}],
  588: 		   L =:= sparse_to_orddict(from_orddict(L)))),
  589:      ?_assert(?LET(L, [{0,0},{N1-1,0}],
  590: 		   L =:= sparse_to_orddict(from_orddict(L)))),
  591:      ?_assert(?LET(L, [{0,0},{N3-1,0}],
  592: 		   L =:= sparse_to_orddict(from_orddict(L)))),
  593:      ?_assert(?LET(L, [{0,0},{N4-1,0}],
  594: 		   L =:= sparse_to_orddict(from_orddict(L))))
  595:      
  596:     ].
  597: 
  598: map_test_() ->
  599:     N0 = ?LEAFSIZE,
  600:     Id = fun (_,X) -> X end,
  601:     Plus = fun(N) -> fun (_,X) -> X+N end end,
  602:     Default = fun(_K,undefined) ->  no_value;
  603: 		 (K,V) -> K+V
  604: 	      end,
  605:     [?_assertError(badarg, map([], new())),
  606:      ?_assertError(badarg, map([], new(10))),
  607:      ?_assert(to_list(map(Id, new())) =:= []),
  608:      ?_assert(to_list(map(Id, new(1))) =:= [undefined]),
  609:      ?_assert(to_list(map(Id, new(5,{default,0}))) =:= [0,0,0,0,0]),
  610:      ?_assert(to_list(map(Id, from_list([1,2,3,4]))) =:= [1,2,3,4]),
  611:      ?_assert(to_list(map(Plus(1), from_list([0,1,2,3]))) =:= [1,2,3,4]),
  612:      ?_assert(to_list(map(Plus(-1), from_list(lists:seq(1,11))))
  613: 	      =:= lists:seq(0,10)),
  614:      ?_assert(to_list(map(Plus(11), from_list(lists:seq(0,99999))))
  615: 	      =:= lists:seq(11,100010)),
  616:      ?_assert([{0,0},{N0*2+1,N0*2+1+1},{N0*100+1,N0*100+1+2}] =:= 
  617: 	      sparse_to_orddict((map(Default, 
  618: 				     set(N0*100+1,2,
  619: 					 set(N0*2+1,1,
  620: 					     set(0,0,new())))))#array{default = no_value}))
  621:     ].
  622: 
  623: sparse_map_test_() ->
  624:     N0 = ?LEAFSIZE,
  625:     Id = fun (_,X) -> X end,
  626:     Plus = fun(N) -> fun (_,X) -> X+N end end,
  627:     KeyPlus = fun (K,X) -> K+X end,
  628:     [?_assertError(badarg, sparse_map([], new())),
  629:      ?_assertError(badarg, sparse_map([], new(10))),
  630:      ?_assert(to_list(sparse_map(Id, new())) =:= []),
  631:      ?_assert(to_list(sparse_map(Id, new(1))) =:= [undefined]),
  632:      ?_assert(to_list(sparse_map(Id, new(5,{default,0}))) =:= [0,0,0,0,0]),
  633:      ?_assert(to_list(sparse_map(Id, from_list([1,2,3,4]))) =:= [1,2,3,4]),
  634:      ?_assert(to_list(sparse_map(Plus(1), from_list([0,1,2,3])))
  635: 	      =:= [1,2,3,4]),
  636:      ?_assert(to_list(sparse_map(Plus(-1), from_list(lists:seq(1,11))))
  637: 	      =:= lists:seq(0,10)),
  638:      ?_assert(to_list(sparse_map(Plus(11), from_list(lists:seq(0,99999))))
  639: 	      =:= lists:seq(11,100010)),
  640:      ?_assert(to_list(sparse_map(Plus(1), set(1,1,new({default,0}))))
  641: 	      =:= [0,2]),
  642:      ?_assert(to_list(sparse_map(Plus(1),
  643: 				 set(3,4,set(0,1,new({default,0})))))
  644: 	      =:= [2,0,0,5]),
  645:      ?_assert(to_list(sparse_map(Plus(1),
  646: 				 set(9,9,set(1,1,new({default,0})))))
  647: 	      =:= [0,2,0,0,0,0,0,0,0,10]),
  648:      ?_assert([{0,0},{N0*2+1,N0*2+1+1},{N0*100+1,N0*100+1+2}] =:= 
  649: 	      sparse_to_orddict(sparse_map(KeyPlus, 
  650: 					   set(N0*100+1,2,
  651: 					       set(N0*2+1,1,
  652: 						   set(0,0,new()))))))
  653: 
  654:     ].
  655: 
  656: foldl_test_() ->
  657:     N0 = ?LEAFSIZE,
  658:     Count = fun (_,_,N) -> N+1 end,
  659:     Sum = fun (_,X,N) -> N+X end,
  660:     Reverse = fun (_,X,L) -> [X|L] end,
  661:     Vals = fun(_K,undefined,{C,L}) -> {C+1,L};
  662: 	      (K,X,{C,L}) -> {C,[K+X|L]} 
  663: 	   end,
  664:     [?_assertError(badarg, foldl([], 0, new())),
  665:      ?_assertError(badarg, foldl([], 0, new(10))),
  666:      ?_assert(foldl(Count, 0, new()) =:= 0),
  667:      ?_assert(foldl(Count, 0, new(1)) =:= 1),
  668:      ?_assert(foldl(Count, 0, new(10)) =:= 10),
  669:      ?_assert(foldl(Count, 0, from_list([1,2,3,4])) =:= 4),
  670:      ?_assert(foldl(Count, 10, from_list([0,1,2,3,4,5,6,7,8,9])) =:= 20),
  671:      ?_assert(foldl(Count, 1000, from_list(lists:seq(0,999))) =:= 2000),
  672:      ?_assert(foldl(Sum, 0, from_list(lists:seq(0,10))) =:= 55),
  673:      ?_assert(foldl(Reverse, [], from_list(lists:seq(0,1000)))
  674: 	      =:= lists:reverse(lists:seq(0,1000))),
  675:      ?_assert({999,[N0*100+1+2,N0*2+1+1,0]} =:= 
  676: 	      foldl(Vals, {0,[]}, 
  677: 		    set(N0*100+1,2,
  678: 			set(N0*2+1,1,
  679: 			    set(0,0,new())))))
  680:      
  681:     ].
  682: 
  683: sparse_foldl_test_() ->
  684:     N0 = ?LEAFSIZE,
  685:     Count = fun (_,_,N) -> N+1 end,
  686:     Sum = fun (_,X,N) -> N+X end,
  687:     Reverse = fun (_,X,L) -> [X|L] end,
  688:     Vals = fun(_K,undefined,{C,L}) -> {C+1,L};
  689: 	      (K,X,{C,L}) -> {C,[K+X|L]} 
  690: 	   end,
  691:     [?_assertError(badarg, sparse_foldl([], 0, new())),
  692:      ?_assertError(badarg, sparse_foldl([], 0, new(10))),
  693:      ?_assert(sparse_foldl(Count, 0, new()) =:= 0),
  694:      ?_assert(sparse_foldl(Count, 0, new(1)) =:= 0),
  695:      ?_assert(sparse_foldl(Count, 0, new(10,{default,1})) =:= 0),
  696:      ?_assert(sparse_foldl(Count, 0, from_list([0,1,2,3,4],0)) =:= 4),
  697:      ?_assert(sparse_foldl(Count, 0, from_list([0,1,2,3,4,5,6,7,8,9,0],0))
  698: 	      =:= 9),
  699:      ?_assert(sparse_foldl(Count, 0, from_list(lists:seq(0,999),0))
  700: 	      =:= 999),
  701:      ?_assert(sparse_foldl(Sum, 0, from_list(lists:seq(0,10), 5)) =:= 50),
  702:      ?_assert(sparse_foldl(Reverse, [], from_list(lists:seq(0,1000), 0))
  703: 	      =:= lists:reverse(lists:seq(1,1000))),
  704:      ?_assert({0,[N0*100+1+2,N0*2+1+1,0]} =:= 
  705: 	      sparse_foldl(Vals, {0,[]}, 
  706: 			   set(N0*100+1,2,
  707: 			       set(N0*2+1,1,
  708: 				   set(0,0,new())))))
  709:     ].
  710: 
  711: foldr_test_() ->
  712:     N0 = ?LEAFSIZE,
  713:     Count = fun (_,_,N) -> N+1 end,
  714:     Sum = fun (_,X,N) -> N+X end,
  715:     List = fun (_,X,L) -> [X|L] end,
  716:     Vals = fun(_K,undefined,{C,L}) -> {C+1,L};
  717: 	      (K,X,{C,L}) -> {C,[K+X|L]} 
  718: 	   end,
  719:     [?_assertError(badarg, foldr([], 0, new())),
  720:      ?_assertError(badarg, foldr([], 0, new(10))),
  721:      ?_assert(foldr(Count, 0, new()) =:= 0),
  722:      ?_assert(foldr(Count, 0, new(1)) =:= 1),
  723:      ?_assert(foldr(Count, 0, new(10)) =:= 10),
  724:      ?_assert(foldr(Count, 0, from_list([1,2,3,4])) =:= 4),
  725:      ?_assert(foldr(Count, 10, from_list([0,1,2,3,4,5,6,7,8,9])) =:= 20),
  726:      ?_assert(foldr(Count, 1000, from_list(lists:seq(0,999))) =:= 2000),
  727:      ?_assert(foldr(Sum, 0, from_list(lists:seq(0,10))) =:= 55),
  728:      ?_assert(foldr(List, [], from_list(lists:seq(0,1000)))
  729:  	      =:= lists:seq(0,1000)),
  730:      ?_assert({999,[0,N0*2+1+1,N0*100+1+2]} =:= 
  731: 	      foldr(Vals, {0,[]}, 
  732: 		    set(N0*100+1,2,
  733: 			set(N0*2+1,1,
  734: 			    set(0,0,new())))))
  735:      
  736:     ].
  737: 
  738: sparse_foldr_test_() ->
  739:     N0 = ?LEAFSIZE,
  740:     Count = fun (_,_,N) -> N+1 end,
  741:     Sum = fun (_,X,N) -> N+X end,
  742:     List = fun (_,X,L) -> [X|L] end,
  743:     Vals = fun(_K,undefined,{C,L}) -> {C+1,L};
  744: 	      (K,X,{C,L}) -> {C,[K+X|L]} 
  745: 	   end,
  746:     [?_assertError(badarg, sparse_foldr([], 0, new())),
  747:      ?_assertError(badarg, sparse_foldr([], 0, new(10))),
  748:      ?_assert(sparse_foldr(Count, 0, new()) =:= 0),
  749:      ?_assert(sparse_foldr(Count, 0, new(1)) =:= 0),
  750:      ?_assert(sparse_foldr(Count, 0, new(10,{default,1})) =:= 0),
  751:      ?_assert(sparse_foldr(Count, 0, from_list([0,1,2,3,4],0)) =:= 4),
  752:      ?_assert(sparse_foldr(Count, 0, from_list([0,1,2,3,4,5,6,7,8,9,0],0))
  753: 	      =:= 9),
  754:      ?_assert(sparse_foldr(Count, 0, from_list(lists:seq(0,999),0))
  755: 	      =:= 999),
  756:      ?_assert(sparse_foldr(Sum, 0, from_list(lists:seq(0,10),5)) =:= 50),
  757:      ?_assert(sparse_foldr(List, [], from_list(lists:seq(0,1000),0))
  758:  	      =:= lists:seq(1,1000)),
  759: 
  760:      ?_assert(sparse_size(new()) =:= 0),
  761:      ?_assert(sparse_size(new(8)) =:= 0),
  762:      ?_assert(sparse_size(array:set(7, 0, new())) =:= 8),
  763:      ?_assert(sparse_size(array:set(7, 0, new(10))) =:= 8),
  764:      ?_assert(sparse_size(array:set(99, 0, new(10,{fixed,false})))
  765: 	      =:= 100),
  766:      ?_assert(sparse_size(array:set(7, undefined, new())) =:= 0),
  767:      ?_assert(sparse_size(array:from_list([1,2,3,undefined])) =:= 3),
  768:      ?_assert(sparse_size(array:from_orddict([{3,0},{17,0},{99,undefined}]))
  769: 			  =:= 18),
  770:      ?_assert({0,[0,N0*2+1+1,N0*100+1+2]} =:= 
  771: 	      sparse_foldr(Vals, {0,[]}, 
  772: 			   set(N0*100+1,2,
  773: 			       set(N0*2+1,1,
  774: 				   set(0,0,new())))))     
  775:     ].
  776: 
  777: new_test(doc) -> [];
  778: new_test(suite) -> [];
  779: new_test(Config) when is_list(Config) -> new_test_(), ok.
  780: fix_test(doc) -> [];
  781: fix_test(suite) -> [];
  782: fix_test(Config) when is_list(Config) -> fix_test_(), ok.
  783: relax_test(doc) -> [];
  784: relax_test(suite) -> [];
  785: relax_test(Config) when is_list(Config) -> relax_test_(), ok.
  786: resize_test(doc) -> [];
  787: resize_test(suite) -> [];
  788: resize_test(Config) when is_list(Config) -> resize_test_(), ok.
  789: set_get_test(doc) -> [];
  790: set_get_test(suite) -> [];
  791: set_get_test(Config) when is_list(Config) -> set_get_test_(), ok.
  792: to_list_test(doc) -> [];
  793: to_list_test(suite) -> [];
  794: to_list_test(Config) when is_list(Config) -> to_list_test_(), ok.
  795: sparse_to_list_test(doc) -> [];
  796: sparse_to_list_test(suite) -> [];
  797: sparse_to_list_test(Config) when is_list(Config) -> sparse_to_list_test_(), ok.
  798: from_list_test(doc) -> [];
  799: from_list_test(suite) -> [];
  800: from_list_test(Config) when is_list(Config) -> from_list_test_(), ok.
  801: to_orddict_test(doc) -> [];
  802: to_orddict_test(suite) -> [];
  803: to_orddict_test(Config) when is_list(Config) -> to_orddict_test_(), ok.
  804: sparse_to_orddict_test(doc) -> [];
  805: sparse_to_orddict_test(suite) -> [];
  806: sparse_to_orddict_test(Config) when is_list(Config) -> sparse_to_orddict_test_(), ok.
  807: from_orddict_test(doc) -> [];
  808: from_orddict_test(suite) -> [];
  809: from_orddict_test(Config) when is_list(Config) -> from_orddict_test_(), ok.
  810: map_test(doc) -> [];
  811: map_test(suite) -> [];
  812: map_test(Config) when is_list(Config) -> map_test_(), ok.
  813: sparse_map_test(doc) -> [];
  814: sparse_map_test(suite) -> [];
  815: sparse_map_test(Config) when is_list(Config) -> sparse_map_test_(), ok.
  816: foldl_test(doc) -> [];
  817: foldl_test(suite) -> [];
  818: foldl_test(Config) when is_list(Config) -> foldl_test_(), ok.
  819: sparse_foldl_test(doc) -> [];
  820: sparse_foldl_test(suite) -> [];
  821: sparse_foldl_test(Config) when is_list(Config) -> sparse_foldl_test_(), ok.
  822: foldr_test(doc) -> [];
  823: foldr_test(suite) -> [];
  824: foldr_test(Config) when is_list(Config) -> foldr_test_(), ok.
  825: sparse_foldr_test(doc) -> [];
  826: sparse_foldr_test(suite) -> [];
  827: sparse_foldr_test(Config) when is_list(Config) -> sparse_foldr_test_(), ok.