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.