Last active
April 12, 2016 06:10
-
-
Save DRMacIver/7976220 to your computer and use it in GitHub Desktop.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| #include "intmap.c" | |
| #include "assert.h" | |
| #undef NDEBUG | |
| int main (){ | |
| intmap_allocator a = intmap_allocator_new(); | |
| // im1 = intmap((2, 'd39ea5b710')); | |
| intmap im1 = intmap_singleton(a, 2UL, 10UL, "d39ea5b710"); | |
| // im2 = intmap((5, '89eaa69a8f')); | |
| intmap im2 = intmap_singleton(a, 5UL, 10UL, "89eaa69a8f"); | |
| // im3 = intmap((2625011179408469742, 'f7cb')); | |
| intmap im3 = intmap_singleton(a, 2625011179408469742UL, 4UL, "f7cb"); | |
| // im4 = intmap((13443926201081858053L, 'c1a2')); | |
| intmap im4 = intmap_singleton(a, 13443926201081858053UL, 4UL, "c1a2"); | |
| // im5 = intmap((17716769152692975850L, '2a')); | |
| intmap im5 = intmap_singleton(a, 17716769152692975850UL, 2UL, "2a"); | |
| // im6 = intmap((5, '0a')); | |
| intmap im6 = intmap_singleton(a, 5UL, 2UL, "0a"); | |
| // im7 = intmap((13443926201081858053L, '29')); | |
| intmap im7 = intmap_singleton(a, 13443926201081858053UL, 2UL, "29"); | |
| // im8 = intmap((13443926201081858053L, 'c085e4a6')); | |
| intmap im8 = intmap_singleton(a, 13443926201081858053UL, 8UL, "c085e4a6"); | |
| // im9 = intmap((5, '37')); | |
| intmap im9 = intmap_singleton(a, 5UL, 2UL, "37"); | |
| // im10 = intmap((5, '6b95')); | |
| intmap im10 = intmap_singleton(a, 5UL, 4UL, "6b95"); | |
| // im11 = intmap((5, 'e41d981864')); | |
| intmap im11 = intmap_singleton(a, 5UL, 10UL, "e41d981864"); | |
| // im12 = intmap((17716769152692975850L, '8c310b')); | |
| intmap im12 = intmap_singleton(a, 17716769152692975850UL, 6UL, "8c310b"); | |
| // im13 = intmap((761643042849108716, '59')); | |
| intmap im13 = intmap_singleton(a, 761643042849108716UL, 2UL, "59"); | |
| // im14 = intmap((2667557012157109398, '8d54a229')); | |
| intmap im14 = intmap_singleton(a, 2667557012157109398UL, 8UL, "8d54a229"); | |
| // im15 = intmap((14490036593423678000L, '22')); | |
| intmap im15 = intmap_singleton(a, 14490036593423678000UL, 2UL, "22"); | |
| // im16 = intmap((5, '0a'), (17716769152692975850L, '2a')); | |
| intmap im16 = intmap_union(a, im6, im5); | |
| // im17 = intmap((5, 'e41d981864'), (17716769152692975850L, '2a')); | |
| intmap im17 = intmap_union(a, im16, im11); | |
| // im18 = intmap((5, '0a'), (13443926201081858053L, '29')); | |
| intmap im18 = intmap_union(a, im7, im6); | |
| // im19 = intmap((761643042849108716, '59'), (14490036593423678000L, '22')); | |
| intmap im19 = intmap_union(a, im15, im13); | |
| // im20 = intmap((5, '0a'), (13443926201081858053L, '29')); | |
| intmap im20 = intmap_union(a, NULL, im18); | |
| // im21 = intmap((5, '0a'), (2667557012157109398, '8d54a229'), (13443926201081858053L, '29')); | |
| intmap im21 = intmap_union(a, im14, im20); | |
| // im22 = intmap((5, '0a'), (17716769152692975850L, '2a')); | |
| intmap im22 = intmap_union(a, im5, im6); | |
| // im23 = intmap((14490036593423678000L, '22')); | |
| intmap im23 = intmap_union(a, NULL, im15); | |
| // im24 = intmap((2, 'd39ea5b710'), (5, '89eaa69a8f')); | |
| intmap im24 = intmap_union(a, im2, im1); | |
| // im25 = intmap((761643042849108716, '59'), (14490036593423678000L, '22')); | |
| intmap im25 = intmap_union(a, im15, im19); | |
| // im26 = intmap((17716769152692975850L, '2a')); | |
| intmap im26 = intmap_union(a, im5, NULL); | |
| // im27 = intmap((5, '37')); | |
| intmap im27 = intmap_union(a, NULL, im9); | |
| // im28 = intmap((2667557012157109398, '8d54a229')); | |
| intmap im28 = intmap_union(a, NULL, im14); | |
| // im29 = intmap((761643042849108716, '59'), (13443926201081858053L, 'c085e4a6')); | |
| intmap im29 = intmap_union(a, im8, im13); | |
| // im30 = intmap((2, 'd39ea5b710'), (5, '89eaa69a8f')); | |
| intmap im30 = intmap_union(a, im1, im24); | |
| // im31 = intmap((2, 'd39ea5b710'), (5, '89eaa69a8f')); | |
| intmap im31 = intmap_union(a, im1, im2); | |
| // im32 = intmap((14490036593423678000L, '22')); | |
| intmap im32 = intmap_union(a, NULL, im15); | |
| // im33 = intmap((5, 'e41d981864'), (2625011179408469742, 'f7cb')); | |
| intmap im33 = intmap_union(a, im3, im11); | |
| // im34 = intmap((2, 'd39ea5b710'), (5, '0a'), (2667557012157109398, '8d54a229'), (13443926201081858053L, '29')); | |
| intmap im34 = intmap_union(a, im30, im21); | |
| // im35 = intmap((17716769152692975850L, '2a')); | |
| intmap im35 = intmap_union(a, NULL, im5); | |
| // im36 = intmap((5, '0a'), (2625011179408469742, 'f7cb'), (13443926201081858053L, '29')); | |
| intmap im36 = intmap_union(a, im20, im3); | |
| // im37 = intmap((2667557012157109398, '8d54a229'), (13443926201081858053L, '29')); | |
| intmap im37 = intmap_union(a, im28, im7); | |
| // im38 = intmap((5, '37'), (13443926201081858053L, 'c085e4a6')); | |
| intmap im38 = intmap_union(a, im8, im9); | |
| // im39 = intmap((5, '0a'), (2667557012157109398, '8d54a229'), (13443926201081858053L, '29')); | |
| intmap im39 = intmap_union(a, im14, im20); | |
| // im40 = intmap((2667557012157109398, '8d54a229'), (17716769152692975850L, '8c310b')); | |
| intmap im40 = intmap_union(a, im28, im12); | |
| // im41 = intmap((14490036593423678000L, '22')); | |
| intmap im41 = intmap_union(a, im23, im15); | |
| // im42 = intmap((5, '0a'), (2625011179408469742, 'f7cb'), (13443926201081858053L, '29')); | |
| intmap im42 = intmap_union(a, im20, im36); | |
| // im43 = intmap((5, '0a'), (2667557012157109398, '8d54a229')); | |
| intmap im43 = intmap_union(a, im14, im6); | |
| // im44 = intmap((5, '0a'), (13443926201081858053L, '29')); | |
| intmap im44 = intmap_union(a, im18, NULL); | |
| // im45 = intmap((2, 'd39ea5b710'), (5, 'e41d981864'), (2625011179408469742, 'f7cb')); | |
| intmap im45 = intmap_union(a, im33, im1); | |
| // im46 = intmap(); | |
| intmap im46 = intmap_intersection(a, im12, im19); | |
| // im47 = intmap(); | |
| intmap im47 = intmap_intersection(a, im8, im17); | |
| // im48 = intmap((5, '0a')); | |
| intmap im48 = intmap_intersection(a, im21, im6); | |
| // im49 = intmap(); | |
| intmap im49 = intmap_intersection(a, NULL, NULL); | |
| // im50 = intmap((2667557012157109398, '8d54a229')); | |
| intmap im50 = intmap_intersection(a, im43, im37); | |
| // im51 = intmap(); | |
| intmap im51 = intmap_intersection(a, im41, im50); | |
| // im52 = intmap(); | |
| intmap im52 = intmap_intersection(a, im1, im27); | |
| // im53 = intmap(); | |
| intmap im53 = intmap_intersection(a, im12, im10); | |
| // im54 = intmap(); | |
| intmap im54 = intmap_intersection(a, im41, im35); | |
| // im55 = intmap(); | |
| intmap im55 = intmap_intersection(a, im38, NULL); | |
| // im56 = intmap(); | |
| intmap im56 = intmap_intersection(a, im1, NULL); | |
| // im57 = intmap(); | |
| intmap im57 = intmap_intersection(a, im19, im6); | |
| // im58 = intmap(); | |
| intmap im58 = intmap_intersection(a, im3, NULL); | |
| // im59 = intmap(); | |
| intmap im59 = intmap_intersection(a, im15, NULL); | |
| // im60 = intmap(); | |
| intmap im60 = intmap_intersection(a, im50, im45); | |
| // im61 = intmap((5, '0a'), (2667557012157109398, '8d54a229'), (13443926201081858053L, '29')); | |
| intmap im61 = intmap_union(a, NULL, im39); | |
| // im62 = intmap((5, '0a'), (13443926201081858053L, '29')); | |
| intmap im62 = intmap_union(a, im44, NULL); | |
| // im63 = intmap(); | |
| intmap im63 = intmap_intersection(a, im13, im48); | |
| // im64 = intmap(); | |
| intmap im64 = intmap_intersection(a, im63, im39); | |
| // im65 = intmap((5, '89eaa69a8f')); | |
| intmap im65 = intmap_intersection(a, im31, im20); | |
| // im66 = intmap(); | |
| intmap im66 = intmap_intersection(a, im65, im51); | |
| // im67 = intmap(); | |
| intmap im67 = intmap_intersection(a, im27, im52); | |
| // im68 = intmap((2, 'd39ea5b710'), (5, '0a'), (2667557012157109398, '8d54a229'), (13443926201081858053L, '29')); | |
| intmap im68 = intmap_union(a, im34, NULL); | |
| // im69 = intmap((5, '0a'), (13443926201081858053L, '29'), (14490036593423678000L, '22')); | |
| intmap im69 = intmap_union(a, im20, im15); | |
| // im70 = intmap(); | |
| intmap im70 = intmap_intersection(a, im45, NULL); | |
| // im71 = intmap(); | |
| intmap im71 = intmap_intersection(a, im30, im67); | |
| // im72 = intmap(); | |
| intmap im72 = intmap_intersection(a, im13, im1); | |
| // im73 = intmap((2667557012157109398, '8d54a229'), (17716769152692975850L, '8c310b')); | |
| intmap im73 = intmap_union(a, im59, im40); | |
| // im74 = intmap(); | |
| intmap im74 = intmap_intersection(a, im26, im41); | |
| // im75 = intmap((5, '0a')); | |
| intmap im75 = intmap_intersection(a, im42, im24); | |
| assert(intmap_size(im70) == 0LU); | |
| assert(intmap_size(im75) == 1LU); | |
| assert(intmap_size(im64) == 0LU); | |
| assert(intmap_size(im65) == 1LU); | |
| assert(intmap_size(im51) == 0LU); | |
| assert(intmap_size(im50) == 1LU); | |
| assert(intmap_size(im53) == 0LU); | |
| assert(intmap_size(im52) == 0LU); | |
| assert(intmap_size(im55) == 0LU); | |
| assert(intmap_size(im39) == 3LU); | |
| assert(intmap_size(im57) == 0LU); | |
| assert(intmap_size(im56) == 0LU); | |
| assert(intmap_size(im59) == 0LU); | |
| assert(intmap_size(im58) == 0LU); | |
| assert(intmap_size(im38) == 2LU); | |
| assert(intmap_size(im37) == 2LU); | |
| assert(intmap_size(im36) == 3LU); | |
| assert(intmap_size(im35) == 1LU); | |
| assert(intmap_size(im34) == 4LU); | |
| assert(intmap_size(im19) == 2LU); | |
| assert(intmap_size(im18) == 2LU); | |
| assert(intmap_size(im31) == 2LU); | |
| assert(intmap_size(im30) == 2LU); | |
| assert(intmap_size(im15) == 1LU); | |
| assert(intmap_size(im14) == 1LU); | |
| assert(intmap_size(im17) == 2LU); | |
| assert(intmap_size(im16) == 2LU); | |
| assert(intmap_size(im11) == 1LU); | |
| assert(intmap_size(im10) == 1LU); | |
| assert(intmap_size(im13) == 1LU); | |
| assert(intmap_size(im12) == 1LU); | |
| assert(intmap_size(im49) == 0LU); | |
| assert(intmap_size(im68) == 4LU); | |
| assert(intmap_size(im74) == 0LU); | |
| assert(intmap_size(im69) == 3LU); | |
| assert(intmap_size(im72) == 0LU); | |
| assert(intmap_size(im46) == 0LU); | |
| assert(intmap_size(im47) == 0LU); | |
| assert(intmap_size(im44) == 2LU); | |
| assert(intmap_size(im45) == 3LU); | |
| assert(intmap_size(im42) == 3LU); | |
| assert(intmap_size(im43) == 2LU); | |
| assert(intmap_size(im40) == 2LU); | |
| assert(intmap_size(im41) == 1LU); | |
| assert(intmap_size(im33) == 2LU); | |
| assert(intmap_size(im48) == 1LU); | |
| assert(intmap_size(im32) == 1LU); | |
| assert(intmap_size(im24) == 2LU); | |
| assert(intmap_size(im25) == 2LU); | |
| assert(intmap_size(im26) == 1LU); | |
| assert(intmap_size(im27) == 1LU); | |
| assert(intmap_size(im20) == 2LU); | |
| assert(intmap_size(im21) == 3LU); | |
| assert(intmap_size(im22) == 2LU); | |
| assert(intmap_size(im23) == 1LU); | |
| assert(intmap_size(im60) == 0LU); | |
| assert(intmap_size(im61) == 3LU); | |
| assert(intmap_size(im62) == 2LU); | |
| assert(intmap_size(im63) == 0LU); | |
| assert(intmap_size(im28) == 1LU); | |
| assert(intmap_size(im29) == 2LU); | |
| assert(intmap_size(im66) == 0LU); | |
| assert(intmap_size(im67) == 0LU); | |
| assert(intmap_size(im1) == 1LU); | |
| assert(intmap_size(im73) == 2LU); | |
| assert(intmap_size(im3) == 1LU); | |
| assert(intmap_size(im2) == 1LU); | |
| assert(intmap_size(im5) == 1LU); | |
| assert(intmap_size(im4) == 1LU); | |
| assert(intmap_size(im7) == 1LU); | |
| assert(intmap_size(im6) == 1LU); | |
| assert(intmap_size(im9) == 1LU); | |
| assert(intmap_size(im8) == 1LU); | |
| assert(intmap_size(im71) == 0LU); | |
| assert(intmap_size(im54) == 0LU); | |
| intmap_value v; | |
| intmap_value *vp; | |
| // check intmap_all values; | |
| vp = intmap_all(a, im70); | |
| intmap_allocator_free(a, vp); | |
| vp = intmap_all(a, im75); | |
| assert(vp[0].length == 2); | |
| assert(vp[0].key == 5LU); | |
| assert(vp[0].data == intmap_lookup(im75, 5LU).data); | |
| intmap_allocator_free(a, vp); | |
| vp = intmap_all(a, im64); | |
| intmap_allocator_free(a, vp); | |
| vp = intmap_all(a, im65); | |
| assert(vp[0].length == 10); | |
| assert(vp[0].key == 5LU); | |
| assert(vp[0].data == intmap_lookup(im65, 5LU).data); | |
| intmap_allocator_free(a, vp); | |
| vp = intmap_all(a, im51); | |
| intmap_allocator_free(a, vp); | |
| vp = intmap_all(a, im50); | |
| assert(vp[0].length == 8); | |
| assert(vp[0].key == 2667557012157109398LU); | |
| assert(vp[0].data == intmap_lookup(im50, 2667557012157109398LU).data); | |
| intmap_allocator_free(a, vp); | |
| vp = intmap_all(a, im53); | |
| intmap_allocator_free(a, vp); | |
| vp = intmap_all(a, im52); | |
| intmap_allocator_free(a, vp); | |
| vp = intmap_all(a, im55); | |
| intmap_allocator_free(a, vp); | |
| vp = intmap_all(a, im39); | |
| assert(vp[0].length == 2); | |
| assert(vp[0].key == 5LU); | |
| assert(vp[0].data == intmap_lookup(im39, 5LU).data); | |
| assert(vp[1].length == 8); | |
| assert(vp[1].key == 2667557012157109398LU); | |
| assert(vp[1].data == intmap_lookup(im39, 2667557012157109398LU).data); | |
| assert(vp[2].length == 2); | |
| assert(vp[2].key == 13443926201081858053LU); | |
| assert(vp[2].data == intmap_lookup(im39, 13443926201081858053LU).data); | |
| intmap_allocator_free(a, vp); | |
| vp = intmap_all(a, im57); | |
| intmap_allocator_free(a, vp); | |
| vp = intmap_all(a, im56); | |
| intmap_allocator_free(a, vp); | |
| vp = intmap_all(a, im59); | |
| intmap_allocator_free(a, vp); | |
| vp = intmap_all(a, im58); | |
| intmap_allocator_free(a, vp); | |
| vp = intmap_all(a, im38); | |
| assert(vp[0].length == 2); | |
| assert(vp[0].key == 5LU); | |
| assert(vp[0].data == intmap_lookup(im38, 5LU).data); | |
| assert(vp[1].length == 8); | |
| assert(vp[1].key == 13443926201081858053LU); | |
| assert(vp[1].data == intmap_lookup(im38, 13443926201081858053LU).data); | |
| intmap_allocator_free(a, vp); | |
| vp = intmap_all(a, im37); | |
| assert(vp[0].length == 8); | |
| assert(vp[0].key == 2667557012157109398LU); | |
| assert(vp[0].data == intmap_lookup(im37, 2667557012157109398LU).data); | |
| assert(vp[1].length == 2); | |
| assert(vp[1].key == 13443926201081858053LU); | |
| assert(vp[1].data == intmap_lookup(im37, 13443926201081858053LU).data); | |
| intmap_allocator_free(a, vp); | |
| vp = intmap_all(a, im36); | |
| assert(vp[0].length == 2); | |
| assert(vp[0].key == 5LU); | |
| assert(vp[0].data == intmap_lookup(im36, 5LU).data); | |
| assert(vp[1].length == 4); | |
| assert(vp[1].key == 2625011179408469742LU); | |
| assert(vp[1].data == intmap_lookup(im36, 2625011179408469742LU).data); | |
| assert(vp[2].length == 2); | |
| assert(vp[2].key == 13443926201081858053LU); | |
| assert(vp[2].data == intmap_lookup(im36, 13443926201081858053LU).data); | |
| intmap_allocator_free(a, vp); | |
| vp = intmap_all(a, im35); | |
| assert(vp[0].length == 2); | |
| assert(vp[0].key == 17716769152692975850LU); | |
| assert(vp[0].data == intmap_lookup(im35, 17716769152692975850LU).data); | |
| intmap_allocator_free(a, vp); | |
| vp = intmap_all(a, im34); | |
| assert(vp[0].length == 10); | |
| assert(vp[0].key == 2LU); | |
| assert(vp[0].data == intmap_lookup(im34, 2LU).data); | |
| assert(vp[1].length == 2); | |
| assert(vp[1].key == 5LU); | |
| assert(vp[1].data == intmap_lookup(im34, 5LU).data); | |
| assert(vp[2].length == 8); | |
| assert(vp[2].key == 2667557012157109398LU); | |
| assert(vp[2].data == intmap_lookup(im34, 2667557012157109398LU).data); | |
| assert(vp[3].length == 2); | |
| assert(vp[3].key == 13443926201081858053LU); | |
| assert(vp[3].data == intmap_lookup(im34, 13443926201081858053LU).data); | |
| intmap_allocator_free(a, vp); | |
| vp = intmap_all(a, im19); | |
| assert(vp[0].length == 2); | |
| assert(vp[0].key == 761643042849108716LU); | |
| assert(vp[0].data == intmap_lookup(im19, 761643042849108716LU).data); | |
| assert(vp[1].length == 2); | |
| assert(vp[1].key == 14490036593423678000LU); | |
| assert(vp[1].data == intmap_lookup(im19, 14490036593423678000LU).data); | |
| intmap_allocator_free(a, vp); | |
| vp = intmap_all(a, im18); | |
| assert(vp[0].length == 2); | |
| assert(vp[0].key == 5LU); | |
| assert(vp[0].data == intmap_lookup(im18, 5LU).data); | |
| assert(vp[1].length == 2); | |
| assert(vp[1].key == 13443926201081858053LU); | |
| assert(vp[1].data == intmap_lookup(im18, 13443926201081858053LU).data); | |
| intmap_allocator_free(a, vp); | |
| vp = intmap_all(a, im31); | |
| assert(vp[0].length == 10); | |
| assert(vp[0].key == 2LU); | |
| assert(vp[0].data == intmap_lookup(im31, 2LU).data); | |
| assert(vp[1].length == 10); | |
| assert(vp[1].key == 5LU); | |
| assert(vp[1].data == intmap_lookup(im31, 5LU).data); | |
| intmap_allocator_free(a, vp); | |
| vp = intmap_all(a, im30); | |
| assert(vp[0].length == 10); | |
| assert(vp[0].key == 2LU); | |
| assert(vp[0].data == intmap_lookup(im30, 2LU).data); | |
| assert(vp[1].length == 10); | |
| assert(vp[1].key == 5LU); | |
| assert(vp[1].data == intmap_lookup(im30, 5LU).data); | |
| intmap_allocator_free(a, vp); | |
| vp = intmap_all(a, im15); | |
| assert(vp[0].length == 2); | |
| assert(vp[0].key == 14490036593423678000LU); | |
| assert(vp[0].data == intmap_lookup(im15, 14490036593423678000LU).data); | |
| intmap_allocator_free(a, vp); | |
| vp = intmap_all(a, im14); | |
| assert(vp[0].length == 8); | |
| assert(vp[0].key == 2667557012157109398LU); | |
| assert(vp[0].data == intmap_lookup(im14, 2667557012157109398LU).data); | |
| intmap_allocator_free(a, vp); | |
| vp = intmap_all(a, im17); | |
| assert(vp[0].length == 10); | |
| assert(vp[0].key == 5LU); | |
| assert(vp[0].data == intmap_lookup(im17, 5LU).data); | |
| assert(vp[1].length == 2); | |
| assert(vp[1].key == 17716769152692975850LU); | |
| assert(vp[1].data == intmap_lookup(im17, 17716769152692975850LU).data); | |
| intmap_allocator_free(a, vp); | |
| vp = intmap_all(a, im16); | |
| assert(vp[0].length == 2); | |
| assert(vp[0].key == 5LU); | |
| assert(vp[0].data == intmap_lookup(im16, 5LU).data); | |
| assert(vp[1].length == 2); | |
| assert(vp[1].key == 17716769152692975850LU); | |
| assert(vp[1].data == intmap_lookup(im16, 17716769152692975850LU).data); | |
| intmap_allocator_free(a, vp); | |
| vp = intmap_all(a, im11); | |
| assert(vp[0].length == 10); | |
| assert(vp[0].key == 5LU); | |
| assert(vp[0].data == intmap_lookup(im11, 5LU).data); | |
| intmap_allocator_free(a, vp); | |
| vp = intmap_all(a, im10); | |
| assert(vp[0].length == 4); | |
| assert(vp[0].key == 5LU); | |
| assert(vp[0].data == intmap_lookup(im10, 5LU).data); | |
| intmap_allocator_free(a, vp); | |
| vp = intmap_all(a, im13); | |
| assert(vp[0].length == 2); | |
| assert(vp[0].key == 761643042849108716LU); | |
| assert(vp[0].data == intmap_lookup(im13, 761643042849108716LU).data); | |
| intmap_allocator_free(a, vp); | |
| vp = intmap_all(a, im12); | |
| assert(vp[0].length == 6); | |
| assert(vp[0].key == 17716769152692975850LU); | |
| assert(vp[0].data == intmap_lookup(im12, 17716769152692975850LU).data); | |
| intmap_allocator_free(a, vp); | |
| vp = intmap_all(a, im49); | |
| intmap_allocator_free(a, vp); | |
| vp = intmap_all(a, im68); | |
| assert(vp[0].length == 10); | |
| assert(vp[0].key == 2LU); | |
| assert(vp[0].data == intmap_lookup(im68, 2LU).data); | |
| assert(vp[1].length == 2); | |
| assert(vp[1].key == 5LU); | |
| assert(vp[1].data == intmap_lookup(im68, 5LU).data); | |
| assert(vp[2].length == 8); | |
| assert(vp[2].key == 2667557012157109398LU); | |
| assert(vp[2].data == intmap_lookup(im68, 2667557012157109398LU).data); | |
| assert(vp[3].length == 2); | |
| assert(vp[3].key == 13443926201081858053LU); | |
| assert(vp[3].data == intmap_lookup(im68, 13443926201081858053LU).data); | |
| intmap_allocator_free(a, vp); | |
| vp = intmap_all(a, im74); | |
| intmap_allocator_free(a, vp); | |
| vp = intmap_all(a, im69); | |
| assert(vp[0].length == 2); | |
| assert(vp[0].key == 5LU); | |
| assert(vp[0].data == intmap_lookup(im69, 5LU).data); | |
| assert(vp[1].length == 2); | |
| assert(vp[1].key == 13443926201081858053LU); | |
| assert(vp[1].data == intmap_lookup(im69, 13443926201081858053LU).data); | |
| assert(vp[2].length == 2); | |
| assert(vp[2].key == 14490036593423678000LU); | |
| assert(vp[2].data == intmap_lookup(im69, 14490036593423678000LU).data); | |
| intmap_allocator_free(a, vp); | |
| vp = intmap_all(a, im72); | |
| intmap_allocator_free(a, vp); | |
| vp = intmap_all(a, im46); | |
| intmap_allocator_free(a, vp); | |
| vp = intmap_all(a, im47); | |
| intmap_allocator_free(a, vp); | |
| vp = intmap_all(a, im44); | |
| assert(vp[0].length == 2); | |
| assert(vp[0].key == 5LU); | |
| assert(vp[0].data == intmap_lookup(im44, 5LU).data); | |
| assert(vp[1].length == 2); | |
| assert(vp[1].key == 13443926201081858053LU); | |
| assert(vp[1].data == intmap_lookup(im44, 13443926201081858053LU).data); | |
| intmap_allocator_free(a, vp); | |
| vp = intmap_all(a, im45); | |
| assert(vp[0].length == 10); | |
| assert(vp[0].key == 2LU); | |
| assert(vp[0].data == intmap_lookup(im45, 2LU).data); | |
| assert(vp[1].length == 10); | |
| assert(vp[1].key == 5LU); | |
| assert(vp[1].data == intmap_lookup(im45, 5LU).data); | |
| assert(vp[2].length == 4); | |
| assert(vp[2].key == 2625011179408469742LU); | |
| assert(vp[2].data == intmap_lookup(im45, 2625011179408469742LU).data); | |
| intmap_allocator_free(a, vp); | |
| vp = intmap_all(a, im42); | |
| assert(vp[0].length == 2); | |
| assert(vp[0].key == 5LU); | |
| assert(vp[0].data == intmap_lookup(im42, 5LU).data); | |
| assert(vp[1].length == 4); | |
| assert(vp[1].key == 2625011179408469742LU); | |
| assert(vp[1].data == intmap_lookup(im42, 2625011179408469742LU).data); | |
| assert(vp[2].length == 2); | |
| assert(vp[2].key == 13443926201081858053LU); | |
| assert(vp[2].data == intmap_lookup(im42, 13443926201081858053LU).data); | |
| intmap_allocator_free(a, vp); | |
| vp = intmap_all(a, im43); | |
| assert(vp[0].length == 2); | |
| assert(vp[0].key == 5LU); | |
| assert(vp[0].data == intmap_lookup(im43, 5LU).data); | |
| assert(vp[1].length == 8); | |
| assert(vp[1].key == 2667557012157109398LU); | |
| assert(vp[1].data == intmap_lookup(im43, 2667557012157109398LU).data); | |
| intmap_allocator_free(a, vp); | |
| vp = intmap_all(a, im40); | |
| assert(vp[0].length == 8); | |
| assert(vp[0].key == 2667557012157109398LU); | |
| assert(vp[0].data == intmap_lookup(im40, 2667557012157109398LU).data); | |
| assert(vp[1].length == 6); | |
| assert(vp[1].key == 17716769152692975850LU); | |
| assert(vp[1].data == intmap_lookup(im40, 17716769152692975850LU).data); | |
| intmap_allocator_free(a, vp); | |
| vp = intmap_all(a, im41); | |
| assert(vp[0].length == 2); | |
| assert(vp[0].key == 14490036593423678000LU); | |
| assert(vp[0].data == intmap_lookup(im41, 14490036593423678000LU).data); | |
| intmap_allocator_free(a, vp); | |
| vp = intmap_all(a, im33); | |
| assert(vp[0].length == 10); | |
| assert(vp[0].key == 5LU); | |
| assert(vp[0].data == intmap_lookup(im33, 5LU).data); | |
| assert(vp[1].length == 4); | |
| assert(vp[1].key == 2625011179408469742LU); | |
| assert(vp[1].data == intmap_lookup(im33, 2625011179408469742LU).data); | |
| intmap_allocator_free(a, vp); | |
| vp = intmap_all(a, im48); | |
| assert(vp[0].length == 2); | |
| assert(vp[0].key == 5LU); | |
| assert(vp[0].data == intmap_lookup(im48, 5LU).data); | |
| intmap_allocator_free(a, vp); | |
| vp = intmap_all(a, im32); | |
| assert(vp[0].length == 2); | |
| assert(vp[0].key == 14490036593423678000LU); | |
| assert(vp[0].data == intmap_lookup(im32, 14490036593423678000LU).data); | |
| intmap_allocator_free(a, vp); | |
| vp = intmap_all(a, im24); | |
| assert(vp[0].length == 10); | |
| assert(vp[0].key == 2LU); | |
| assert(vp[0].data == intmap_lookup(im24, 2LU).data); | |
| assert(vp[1].length == 10); | |
| assert(vp[1].key == 5LU); | |
| assert(vp[1].data == intmap_lookup(im24, 5LU).data); | |
| intmap_allocator_free(a, vp); | |
| vp = intmap_all(a, im25); | |
| assert(vp[0].length == 2); | |
| assert(vp[0].key == 761643042849108716LU); | |
| assert(vp[0].data == intmap_lookup(im25, 761643042849108716LU).data); | |
| assert(vp[1].length == 2); | |
| assert(vp[1].key == 14490036593423678000LU); | |
| assert(vp[1].data == intmap_lookup(im25, 14490036593423678000LU).data); | |
| intmap_allocator_free(a, vp); | |
| vp = intmap_all(a, im26); | |
| assert(vp[0].length == 2); | |
| assert(vp[0].key == 17716769152692975850LU); | |
| assert(vp[0].data == intmap_lookup(im26, 17716769152692975850LU).data); | |
| intmap_allocator_free(a, vp); | |
| vp = intmap_all(a, im27); | |
| assert(vp[0].length == 2); | |
| assert(vp[0].key == 5LU); | |
| assert(vp[0].data == intmap_lookup(im27, 5LU).data); | |
| intmap_allocator_free(a, vp); | |
| vp = intmap_all(a, im20); | |
| assert(vp[0].length == 2); | |
| assert(vp[0].key == 5LU); | |
| assert(vp[0].data == intmap_lookup(im20, 5LU).data); | |
| assert(vp[1].length == 2); | |
| assert(vp[1].key == 13443926201081858053LU); | |
| assert(vp[1].data == intmap_lookup(im20, 13443926201081858053LU).data); | |
| intmap_allocator_free(a, vp); | |
| vp = intmap_all(a, im21); | |
| assert(vp[0].length == 2); | |
| assert(vp[0].key == 5LU); | |
| assert(vp[0].data == intmap_lookup(im21, 5LU).data); | |
| assert(vp[1].length == 8); | |
| assert(vp[1].key == 2667557012157109398LU); | |
| assert(vp[1].data == intmap_lookup(im21, 2667557012157109398LU).data); | |
| assert(vp[2].length == 2); | |
| assert(vp[2].key == 13443926201081858053LU); | |
| assert(vp[2].data == intmap_lookup(im21, 13443926201081858053LU).data); | |
| intmap_allocator_free(a, vp); | |
| vp = intmap_all(a, im22); | |
| assert(vp[0].length == 2); | |
| assert(vp[0].key == 5LU); | |
| assert(vp[0].data == intmap_lookup(im22, 5LU).data); | |
| assert(vp[1].length == 2); | |
| assert(vp[1].key == 17716769152692975850LU); | |
| assert(vp[1].data == intmap_lookup(im22, 17716769152692975850LU).data); | |
| intmap_allocator_free(a, vp); | |
| vp = intmap_all(a, im23); | |
| assert(vp[0].length == 2); | |
| assert(vp[0].key == 14490036593423678000LU); | |
| assert(vp[0].data == intmap_lookup(im23, 14490036593423678000LU).data); | |
| intmap_allocator_free(a, vp); | |
| vp = intmap_all(a, im60); | |
| intmap_allocator_free(a, vp); | |
| vp = intmap_all(a, im61); | |
| assert(vp[0].length == 2); | |
| assert(vp[0].key == 5LU); | |
| assert(vp[0].data == intmap_lookup(im61, 5LU).data); | |
| assert(vp[1].length == 8); | |
| assert(vp[1].key == 2667557012157109398LU); | |
| assert(vp[1].data == intmap_lookup(im61, 2667557012157109398LU).data); | |
| assert(vp[2].length == 2); | |
| assert(vp[2].key == 13443926201081858053LU); | |
| assert(vp[2].data == intmap_lookup(im61, 13443926201081858053LU).data); | |
| intmap_allocator_free(a, vp); | |
| vp = intmap_all(a, im62); | |
| assert(vp[0].length == 2); | |
| assert(vp[0].key == 5LU); | |
| assert(vp[0].data == intmap_lookup(im62, 5LU).data); | |
| assert(vp[1].length == 2); | |
| assert(vp[1].key == 13443926201081858053LU); | |
| assert(vp[1].data == intmap_lookup(im62, 13443926201081858053LU).data); | |
| intmap_allocator_free(a, vp); | |
| vp = intmap_all(a, im63); | |
| intmap_allocator_free(a, vp); | |
| vp = intmap_all(a, im28); | |
| assert(vp[0].length == 8); | |
| assert(vp[0].key == 2667557012157109398LU); | |
| assert(vp[0].data == intmap_lookup(im28, 2667557012157109398LU).data); | |
| intmap_allocator_free(a, vp); | |
| vp = intmap_all(a, im29); | |
| assert(vp[0].length == 2); | |
| assert(vp[0].key == 761643042849108716LU); | |
| assert(vp[0].data == intmap_lookup(im29, 761643042849108716LU).data); | |
| assert(vp[1].length == 8); | |
| assert(vp[1].key == 13443926201081858053LU); | |
| assert(vp[1].data == intmap_lookup(im29, 13443926201081858053LU).data); | |
| intmap_allocator_free(a, vp); | |
| vp = intmap_all(a, im66); | |
| intmap_allocator_free(a, vp); | |
| vp = intmap_all(a, im67); | |
| intmap_allocator_free(a, vp); | |
| vp = intmap_all(a, im1); | |
| assert(vp[0].length == 10); | |
| assert(vp[0].key == 2LU); | |
| assert(vp[0].data == intmap_lookup(im1, 2LU).data); | |
| intmap_allocator_free(a, vp); | |
| vp = intmap_all(a, im73); | |
| assert(vp[0].length == 8); | |
| assert(vp[0].key == 2667557012157109398LU); | |
| assert(vp[0].data == intmap_lookup(im73, 2667557012157109398LU).data); | |
| assert(vp[1].length == 6); | |
| assert(vp[1].key == 17716769152692975850LU); | |
| assert(vp[1].data == intmap_lookup(im73, 17716769152692975850LU).data); | |
| intmap_allocator_free(a, vp); | |
| vp = intmap_all(a, im3); | |
| assert(vp[0].length == 4); | |
| assert(vp[0].key == 2625011179408469742LU); | |
| assert(vp[0].data == intmap_lookup(im3, 2625011179408469742LU).data); | |
| intmap_allocator_free(a, vp); | |
| vp = intmap_all(a, im2); | |
| assert(vp[0].length == 10); | |
| assert(vp[0].key == 5LU); | |
| assert(vp[0].data == intmap_lookup(im2, 5LU).data); | |
| intmap_allocator_free(a, vp); | |
| vp = intmap_all(a, im5); | |
| assert(vp[0].length == 2); | |
| assert(vp[0].key == 17716769152692975850LU); | |
| assert(vp[0].data == intmap_lookup(im5, 17716769152692975850LU).data); | |
| intmap_allocator_free(a, vp); | |
| vp = intmap_all(a, im4); | |
| assert(vp[0].length == 4); | |
| assert(vp[0].key == 13443926201081858053LU); | |
| assert(vp[0].data == intmap_lookup(im4, 13443926201081858053LU).data); | |
| intmap_allocator_free(a, vp); | |
| vp = intmap_all(a, im7); | |
| assert(vp[0].length == 2); | |
| assert(vp[0].key == 13443926201081858053LU); | |
| assert(vp[0].data == intmap_lookup(im7, 13443926201081858053LU).data); | |
| intmap_allocator_free(a, vp); | |
| vp = intmap_all(a, im6); | |
| assert(vp[0].length == 2); | |
| assert(vp[0].key == 5LU); | |
| assert(vp[0].data == intmap_lookup(im6, 5LU).data); | |
| intmap_allocator_free(a, vp); | |
| vp = intmap_all(a, im9); | |
| assert(vp[0].length == 2); | |
| assert(vp[0].key == 5LU); | |
| assert(vp[0].data == intmap_lookup(im9, 5LU).data); | |
| intmap_allocator_free(a, vp); | |
| vp = intmap_all(a, im8); | |
| assert(vp[0].length == 8); | |
| assert(vp[0].key == 13443926201081858053LU); | |
| assert(vp[0].data == intmap_lookup(im8, 13443926201081858053LU).data); | |
| intmap_allocator_free(a, vp); | |
| vp = intmap_all(a, im71); | |
| intmap_allocator_free(a, vp); | |
| vp = intmap_all(a, im54); | |
| intmap_allocator_free(a, vp); | |
| // check all plausible memberships; | |
| v = intmap_lookup(im70, 2UL); | |
| assert(!intmap_lookup(im70, 2UL).present); | |
| v = intmap_lookup(im70, 5UL); | |
| assert(!intmap_lookup(im70, 5UL).present); | |
| v = intmap_lookup(im70, 2625011179408469742UL); | |
| assert(!intmap_lookup(im70, 2625011179408469742UL).present); | |
| v = intmap_lookup(im75, 2UL); | |
| assert(!intmap_lookup(im75, 2UL).present); | |
| v = intmap_lookup(im75, 13443926201081858053UL); | |
| assert(!intmap_lookup(im75, 13443926201081858053UL).present); | |
| v = intmap_lookup(im75, 2625011179408469742UL); | |
| assert(!intmap_lookup(im75, 2625011179408469742UL).present); | |
| v = intmap_lookup(im75, 5UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "0a", 2UL) == 0); | |
| v = intmap_lookup(im64, 13443926201081858053UL); | |
| assert(!intmap_lookup(im64, 13443926201081858053UL).present); | |
| v = intmap_lookup(im64, 2667557012157109398UL); | |
| assert(!intmap_lookup(im64, 2667557012157109398UL).present); | |
| v = intmap_lookup(im64, 761643042849108716UL); | |
| assert(!intmap_lookup(im64, 761643042849108716UL).present); | |
| v = intmap_lookup(im64, 5UL); | |
| assert(!intmap_lookup(im64, 5UL).present); | |
| v = intmap_lookup(im65, 2UL); | |
| assert(!intmap_lookup(im65, 2UL).present); | |
| v = intmap_lookup(im65, 5UL); | |
| assert(v.present); | |
| assert(v.length == 10UL); | |
| assert(memcmp(v.data, "89eaa69a8f", 10UL) == 0); | |
| v = intmap_lookup(im65, 13443926201081858053UL); | |
| assert(!intmap_lookup(im65, 13443926201081858053UL).present); | |
| v = intmap_lookup(im51, 14490036593423678000UL); | |
| assert(!intmap_lookup(im51, 14490036593423678000UL).present); | |
| v = intmap_lookup(im51, 5UL); | |
| assert(!intmap_lookup(im51, 5UL).present); | |
| v = intmap_lookup(im51, 2667557012157109398UL); | |
| assert(!intmap_lookup(im51, 2667557012157109398UL).present); | |
| v = intmap_lookup(im51, 13443926201081858053UL); | |
| assert(!intmap_lookup(im51, 13443926201081858053UL).present); | |
| v = intmap_lookup(im50, 5UL); | |
| assert(!intmap_lookup(im50, 5UL).present); | |
| v = intmap_lookup(im50, 2667557012157109398UL); | |
| assert(v.present); | |
| assert(v.length == 8UL); | |
| assert(memcmp(v.data, "8d54a229", 8UL) == 0); | |
| v = intmap_lookup(im50, 13443926201081858053UL); | |
| assert(!intmap_lookup(im50, 13443926201081858053UL).present); | |
| v = intmap_lookup(im53, 17716769152692975850UL); | |
| assert(!intmap_lookup(im53, 17716769152692975850UL).present); | |
| v = intmap_lookup(im53, 5UL); | |
| assert(!intmap_lookup(im53, 5UL).present); | |
| v = intmap_lookup(im52, 2UL); | |
| assert(!intmap_lookup(im52, 2UL).present); | |
| v = intmap_lookup(im52, 5UL); | |
| assert(!intmap_lookup(im52, 5UL).present); | |
| v = intmap_lookup(im55, 13443926201081858053UL); | |
| assert(!intmap_lookup(im55, 13443926201081858053UL).present); | |
| v = intmap_lookup(im55, 5UL); | |
| assert(!intmap_lookup(im55, 5UL).present); | |
| v = intmap_lookup(im39, 13443926201081858053UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "29", 2UL) == 0); | |
| v = intmap_lookup(im39, 2667557012157109398UL); | |
| assert(v.present); | |
| assert(v.length == 8UL); | |
| assert(memcmp(v.data, "8d54a229", 8UL) == 0); | |
| v = intmap_lookup(im39, 5UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "0a", 2UL) == 0); | |
| v = intmap_lookup(im57, 14490036593423678000UL); | |
| assert(!intmap_lookup(im57, 14490036593423678000UL).present); | |
| v = intmap_lookup(im57, 761643042849108716UL); | |
| assert(!intmap_lookup(im57, 761643042849108716UL).present); | |
| v = intmap_lookup(im57, 5UL); | |
| assert(!intmap_lookup(im57, 5UL).present); | |
| v = intmap_lookup(im56, 2UL); | |
| assert(!intmap_lookup(im56, 2UL).present); | |
| v = intmap_lookup(im59, 14490036593423678000UL); | |
| assert(!intmap_lookup(im59, 14490036593423678000UL).present); | |
| v = intmap_lookup(im58, 2625011179408469742UL); | |
| assert(!intmap_lookup(im58, 2625011179408469742UL).present); | |
| v = intmap_lookup(im38, 13443926201081858053UL); | |
| assert(v.present); | |
| assert(v.length == 8UL); | |
| assert(memcmp(v.data, "c085e4a6", 8UL) == 0); | |
| v = intmap_lookup(im38, 5UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "37", 2UL) == 0); | |
| v = intmap_lookup(im37, 13443926201081858053UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "29", 2UL) == 0); | |
| v = intmap_lookup(im37, 2667557012157109398UL); | |
| assert(v.present); | |
| assert(v.length == 8UL); | |
| assert(memcmp(v.data, "8d54a229", 8UL) == 0); | |
| v = intmap_lookup(im36, 13443926201081858053UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "29", 2UL) == 0); | |
| v = intmap_lookup(im36, 2625011179408469742UL); | |
| assert(v.present); | |
| assert(v.length == 4UL); | |
| assert(memcmp(v.data, "f7cb", 4UL) == 0); | |
| v = intmap_lookup(im36, 5UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "0a", 2UL) == 0); | |
| v = intmap_lookup(im35, 17716769152692975850UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "2a", 2UL) == 0); | |
| v = intmap_lookup(im34, 2UL); | |
| assert(v.present); | |
| assert(v.length == 10UL); | |
| assert(memcmp(v.data, "d39ea5b710", 10UL) == 0); | |
| v = intmap_lookup(im34, 5UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "0a", 2UL) == 0); | |
| v = intmap_lookup(im34, 2667557012157109398UL); | |
| assert(v.present); | |
| assert(v.length == 8UL); | |
| assert(memcmp(v.data, "8d54a229", 8UL) == 0); | |
| v = intmap_lookup(im34, 13443926201081858053UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "29", 2UL) == 0); | |
| v = intmap_lookup(im19, 14490036593423678000UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "22", 2UL) == 0); | |
| v = intmap_lookup(im19, 761643042849108716UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "59", 2UL) == 0); | |
| v = intmap_lookup(im18, 13443926201081858053UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "29", 2UL) == 0); | |
| v = intmap_lookup(im18, 5UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "0a", 2UL) == 0); | |
| v = intmap_lookup(im31, 2UL); | |
| assert(v.present); | |
| assert(v.length == 10UL); | |
| assert(memcmp(v.data, "d39ea5b710", 10UL) == 0); | |
| v = intmap_lookup(im31, 5UL); | |
| assert(v.present); | |
| assert(v.length == 10UL); | |
| assert(memcmp(v.data, "89eaa69a8f", 10UL) == 0); | |
| v = intmap_lookup(im30, 2UL); | |
| assert(v.present); | |
| assert(v.length == 10UL); | |
| assert(memcmp(v.data, "d39ea5b710", 10UL) == 0); | |
| v = intmap_lookup(im30, 5UL); | |
| assert(v.present); | |
| assert(v.length == 10UL); | |
| assert(memcmp(v.data, "89eaa69a8f", 10UL) == 0); | |
| v = intmap_lookup(im15, 14490036593423678000UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "22", 2UL) == 0); | |
| v = intmap_lookup(im14, 2667557012157109398UL); | |
| assert(v.present); | |
| assert(v.length == 8UL); | |
| assert(memcmp(v.data, "8d54a229", 8UL) == 0); | |
| v = intmap_lookup(im17, 17716769152692975850UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "2a", 2UL) == 0); | |
| v = intmap_lookup(im17, 5UL); | |
| assert(v.present); | |
| assert(v.length == 10UL); | |
| assert(memcmp(v.data, "e41d981864", 10UL) == 0); | |
| v = intmap_lookup(im16, 17716769152692975850UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "2a", 2UL) == 0); | |
| v = intmap_lookup(im16, 5UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "0a", 2UL) == 0); | |
| v = intmap_lookup(im11, 5UL); | |
| assert(v.present); | |
| assert(v.length == 10UL); | |
| assert(memcmp(v.data, "e41d981864", 10UL) == 0); | |
| v = intmap_lookup(im10, 5UL); | |
| assert(v.present); | |
| assert(v.length == 4UL); | |
| assert(memcmp(v.data, "6b95", 4UL) == 0); | |
| v = intmap_lookup(im13, 761643042849108716UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "59", 2UL) == 0); | |
| v = intmap_lookup(im12, 17716769152692975850UL); | |
| assert(v.present); | |
| assert(v.length == 6UL); | |
| assert(memcmp(v.data, "8c310b", 6UL) == 0); | |
| v = intmap_lookup(im68, 2UL); | |
| assert(v.present); | |
| assert(v.length == 10UL); | |
| assert(memcmp(v.data, "d39ea5b710", 10UL) == 0); | |
| v = intmap_lookup(im68, 5UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "0a", 2UL) == 0); | |
| v = intmap_lookup(im68, 2667557012157109398UL); | |
| assert(v.present); | |
| assert(v.length == 8UL); | |
| assert(memcmp(v.data, "8d54a229", 8UL) == 0); | |
| v = intmap_lookup(im68, 13443926201081858053UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "29", 2UL) == 0); | |
| v = intmap_lookup(im74, 14490036593423678000UL); | |
| assert(!intmap_lookup(im74, 14490036593423678000UL).present); | |
| v = intmap_lookup(im74, 17716769152692975850UL); | |
| assert(!intmap_lookup(im74, 17716769152692975850UL).present); | |
| v = intmap_lookup(im69, 14490036593423678000UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "22", 2UL) == 0); | |
| v = intmap_lookup(im69, 13443926201081858053UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "29", 2UL) == 0); | |
| v = intmap_lookup(im69, 5UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "0a", 2UL) == 0); | |
| v = intmap_lookup(im72, 2UL); | |
| assert(!intmap_lookup(im72, 2UL).present); | |
| v = intmap_lookup(im72, 761643042849108716UL); | |
| assert(!intmap_lookup(im72, 761643042849108716UL).present); | |
| v = intmap_lookup(im46, 14490036593423678000UL); | |
| assert(!intmap_lookup(im46, 14490036593423678000UL).present); | |
| v = intmap_lookup(im46, 17716769152692975850UL); | |
| assert(!intmap_lookup(im46, 17716769152692975850UL).present); | |
| v = intmap_lookup(im46, 761643042849108716UL); | |
| assert(!intmap_lookup(im46, 761643042849108716UL).present); | |
| v = intmap_lookup(im47, 17716769152692975850UL); | |
| assert(!intmap_lookup(im47, 17716769152692975850UL).present); | |
| v = intmap_lookup(im47, 13443926201081858053UL); | |
| assert(!intmap_lookup(im47, 13443926201081858053UL).present); | |
| v = intmap_lookup(im47, 5UL); | |
| assert(!intmap_lookup(im47, 5UL).present); | |
| v = intmap_lookup(im44, 13443926201081858053UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "29", 2UL) == 0); | |
| v = intmap_lookup(im44, 5UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "0a", 2UL) == 0); | |
| v = intmap_lookup(im45, 2UL); | |
| assert(v.present); | |
| assert(v.length == 10UL); | |
| assert(memcmp(v.data, "d39ea5b710", 10UL) == 0); | |
| v = intmap_lookup(im45, 5UL); | |
| assert(v.present); | |
| assert(v.length == 10UL); | |
| assert(memcmp(v.data, "e41d981864", 10UL) == 0); | |
| v = intmap_lookup(im45, 2625011179408469742UL); | |
| assert(v.present); | |
| assert(v.length == 4UL); | |
| assert(memcmp(v.data, "f7cb", 4UL) == 0); | |
| v = intmap_lookup(im42, 13443926201081858053UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "29", 2UL) == 0); | |
| v = intmap_lookup(im42, 2625011179408469742UL); | |
| assert(v.present); | |
| assert(v.length == 4UL); | |
| assert(memcmp(v.data, "f7cb", 4UL) == 0); | |
| v = intmap_lookup(im42, 5UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "0a", 2UL) == 0); | |
| v = intmap_lookup(im43, 5UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "0a", 2UL) == 0); | |
| v = intmap_lookup(im43, 2667557012157109398UL); | |
| assert(v.present); | |
| assert(v.length == 8UL); | |
| assert(memcmp(v.data, "8d54a229", 8UL) == 0); | |
| v = intmap_lookup(im40, 17716769152692975850UL); | |
| assert(v.present); | |
| assert(v.length == 6UL); | |
| assert(memcmp(v.data, "8c310b", 6UL) == 0); | |
| v = intmap_lookup(im40, 2667557012157109398UL); | |
| assert(v.present); | |
| assert(v.length == 8UL); | |
| assert(memcmp(v.data, "8d54a229", 8UL) == 0); | |
| v = intmap_lookup(im41, 14490036593423678000UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "22", 2UL) == 0); | |
| v = intmap_lookup(im33, 5UL); | |
| assert(v.present); | |
| assert(v.length == 10UL); | |
| assert(memcmp(v.data, "e41d981864", 10UL) == 0); | |
| v = intmap_lookup(im33, 2625011179408469742UL); | |
| assert(v.present); | |
| assert(v.length == 4UL); | |
| assert(memcmp(v.data, "f7cb", 4UL) == 0); | |
| v = intmap_lookup(im48, 13443926201081858053UL); | |
| assert(!intmap_lookup(im48, 13443926201081858053UL).present); | |
| v = intmap_lookup(im48, 2667557012157109398UL); | |
| assert(!intmap_lookup(im48, 2667557012157109398UL).present); | |
| v = intmap_lookup(im48, 5UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "0a", 2UL) == 0); | |
| v = intmap_lookup(im32, 14490036593423678000UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "22", 2UL) == 0); | |
| v = intmap_lookup(im24, 2UL); | |
| assert(v.present); | |
| assert(v.length == 10UL); | |
| assert(memcmp(v.data, "d39ea5b710", 10UL) == 0); | |
| v = intmap_lookup(im24, 5UL); | |
| assert(v.present); | |
| assert(v.length == 10UL); | |
| assert(memcmp(v.data, "89eaa69a8f", 10UL) == 0); | |
| v = intmap_lookup(im25, 14490036593423678000UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "22", 2UL) == 0); | |
| v = intmap_lookup(im25, 761643042849108716UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "59", 2UL) == 0); | |
| v = intmap_lookup(im26, 17716769152692975850UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "2a", 2UL) == 0); | |
| v = intmap_lookup(im27, 5UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "37", 2UL) == 0); | |
| v = intmap_lookup(im20, 13443926201081858053UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "29", 2UL) == 0); | |
| v = intmap_lookup(im20, 5UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "0a", 2UL) == 0); | |
| v = intmap_lookup(im21, 13443926201081858053UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "29", 2UL) == 0); | |
| v = intmap_lookup(im21, 2667557012157109398UL); | |
| assert(v.present); | |
| assert(v.length == 8UL); | |
| assert(memcmp(v.data, "8d54a229", 8UL) == 0); | |
| v = intmap_lookup(im21, 5UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "0a", 2UL) == 0); | |
| v = intmap_lookup(im22, 17716769152692975850UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "2a", 2UL) == 0); | |
| v = intmap_lookup(im22, 5UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "0a", 2UL) == 0); | |
| v = intmap_lookup(im23, 14490036593423678000UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "22", 2UL) == 0); | |
| v = intmap_lookup(im60, 2UL); | |
| assert(!intmap_lookup(im60, 2UL).present); | |
| v = intmap_lookup(im60, 5UL); | |
| assert(!intmap_lookup(im60, 5UL).present); | |
| v = intmap_lookup(im60, 2667557012157109398UL); | |
| assert(!intmap_lookup(im60, 2667557012157109398UL).present); | |
| v = intmap_lookup(im60, 2625011179408469742UL); | |
| assert(!intmap_lookup(im60, 2625011179408469742UL).present); | |
| v = intmap_lookup(im60, 13443926201081858053UL); | |
| assert(!intmap_lookup(im60, 13443926201081858053UL).present); | |
| v = intmap_lookup(im61, 13443926201081858053UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "29", 2UL) == 0); | |
| v = intmap_lookup(im61, 2667557012157109398UL); | |
| assert(v.present); | |
| assert(v.length == 8UL); | |
| assert(memcmp(v.data, "8d54a229", 8UL) == 0); | |
| v = intmap_lookup(im61, 5UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "0a", 2UL) == 0); | |
| v = intmap_lookup(im62, 13443926201081858053UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "29", 2UL) == 0); | |
| v = intmap_lookup(im62, 5UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "0a", 2UL) == 0); | |
| v = intmap_lookup(im63, 761643042849108716UL); | |
| assert(!intmap_lookup(im63, 761643042849108716UL).present); | |
| v = intmap_lookup(im63, 13443926201081858053UL); | |
| assert(!intmap_lookup(im63, 13443926201081858053UL).present); | |
| v = intmap_lookup(im63, 2667557012157109398UL); | |
| assert(!intmap_lookup(im63, 2667557012157109398UL).present); | |
| v = intmap_lookup(im63, 5UL); | |
| assert(!intmap_lookup(im63, 5UL).present); | |
| v = intmap_lookup(im28, 2667557012157109398UL); | |
| assert(v.present); | |
| assert(v.length == 8UL); | |
| assert(memcmp(v.data, "8d54a229", 8UL) == 0); | |
| v = intmap_lookup(im29, 761643042849108716UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "59", 2UL) == 0); | |
| v = intmap_lookup(im29, 13443926201081858053UL); | |
| assert(v.present); | |
| assert(v.length == 8UL); | |
| assert(memcmp(v.data, "c085e4a6", 8UL) == 0); | |
| v = intmap_lookup(im66, 14490036593423678000UL); | |
| assert(!intmap_lookup(im66, 14490036593423678000UL).present); | |
| v = intmap_lookup(im66, 2UL); | |
| assert(!intmap_lookup(im66, 2UL).present); | |
| v = intmap_lookup(im66, 5UL); | |
| assert(!intmap_lookup(im66, 5UL).present); | |
| v = intmap_lookup(im66, 2667557012157109398UL); | |
| assert(!intmap_lookup(im66, 2667557012157109398UL).present); | |
| v = intmap_lookup(im66, 13443926201081858053UL); | |
| assert(!intmap_lookup(im66, 13443926201081858053UL).present); | |
| v = intmap_lookup(im67, 2UL); | |
| assert(!intmap_lookup(im67, 2UL).present); | |
| v = intmap_lookup(im67, 5UL); | |
| assert(!intmap_lookup(im67, 5UL).present); | |
| v = intmap_lookup(im1, 2UL); | |
| assert(v.present); | |
| assert(v.length == 10UL); | |
| assert(memcmp(v.data, "d39ea5b710", 10UL) == 0); | |
| v = intmap_lookup(im73, 14490036593423678000UL); | |
| assert(!intmap_lookup(im73, 14490036593423678000UL).present); | |
| v = intmap_lookup(im73, 17716769152692975850UL); | |
| assert(v.present); | |
| assert(v.length == 6UL); | |
| assert(memcmp(v.data, "8c310b", 6UL) == 0); | |
| v = intmap_lookup(im73, 2667557012157109398UL); | |
| assert(v.present); | |
| assert(v.length == 8UL); | |
| assert(memcmp(v.data, "8d54a229", 8UL) == 0); | |
| v = intmap_lookup(im3, 2625011179408469742UL); | |
| assert(v.present); | |
| assert(v.length == 4UL); | |
| assert(memcmp(v.data, "f7cb", 4UL) == 0); | |
| v = intmap_lookup(im2, 5UL); | |
| assert(v.present); | |
| assert(v.length == 10UL); | |
| assert(memcmp(v.data, "89eaa69a8f", 10UL) == 0); | |
| v = intmap_lookup(im5, 17716769152692975850UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "2a", 2UL) == 0); | |
| v = intmap_lookup(im4, 13443926201081858053UL); | |
| assert(v.present); | |
| assert(v.length == 4UL); | |
| assert(memcmp(v.data, "c1a2", 4UL) == 0); | |
| v = intmap_lookup(im7, 13443926201081858053UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "29", 2UL) == 0); | |
| v = intmap_lookup(im6, 5UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "0a", 2UL) == 0); | |
| v = intmap_lookup(im9, 5UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "37", 2UL) == 0); | |
| v = intmap_lookup(im8, 13443926201081858053UL); | |
| assert(v.present); | |
| assert(v.length == 8UL); | |
| assert(memcmp(v.data, "c085e4a6", 8UL) == 0); | |
| v = intmap_lookup(im71, 2UL); | |
| assert(!intmap_lookup(im71, 2UL).present); | |
| v = intmap_lookup(im71, 5UL); | |
| assert(!intmap_lookup(im71, 5UL).present); | |
| v = intmap_lookup(im54, 14490036593423678000UL); | |
| assert(!intmap_lookup(im54, 14490036593423678000UL).present); | |
| v = intmap_lookup(im54, 17716769152692975850UL); | |
| assert(!intmap_lookup(im54, 17716769152692975850UL).present); | |
| // check equality; | |
| assert(intmap_are_equal(im54, im63)); | |
| assert(!intmap_are_equal(im30, NULL)); | |
| assert(!intmap_are_equal(NULL, im75)); | |
| assert(!intmap_are_equal(im48, NULL)); | |
| assert(!intmap_are_equal(im19, NULL)); | |
| assert(!intmap_are_equal(im24, im54)); | |
| assert(!intmap_are_equal(im4, NULL)); | |
| assert(intmap_are_equal(im51, im53)); | |
| assert(!intmap_are_equal(im16, im19)); | |
| assert(!intmap_are_equal(im73, NULL)); | |
| assert(intmap_are_equal(im22, im22)); | |
| assert(intmap_are_equal(NULL, im66)); | |
| assert(!intmap_are_equal(im18, im64)); | |
| assert(!intmap_are_equal(im2, im23)); | |
| assert(!intmap_are_equal(im45, NULL)); | |
| assert(!intmap_are_equal(im42, im19)); | |
| assert(!intmap_are_equal(im6, im23)); | |
| assert(!intmap_are_equal(im30, im3)); | |
| assert(!intmap_are_equal(im14, im39)); | |
| assert(!intmap_are_equal(im44, im58)); | |
| assert(intmap_are_equal(NULL, im60)); | |
| assert(!intmap_are_equal(im62, im52)); | |
| assert(!intmap_are_equal(im36, im33)); | |
| assert(!intmap_are_equal(im61, im69)); | |
| assert(!intmap_are_equal(NULL, im15)); | |
| assert(!intmap_are_equal(im27, NULL)); | |
| assert(intmap_are_equal(im63, im49)); | |
| assert(!intmap_are_equal(im11, im65)); | |
| assert(!intmap_are_equal(im46, im17)); | |
| assert(!intmap_are_equal(im37, im24)); | |
| assert(!intmap_are_equal(im4, im24)); | |
| assert(!intmap_are_equal(im34, im65)); | |
| assert(!intmap_are_equal(im33, im43)); | |
| assert(!intmap_are_equal(im37, im2)); | |
| assert(!intmap_are_equal(im25, im38)); | |
| assert(intmap_are_equal(im72, im63)); | |
| assert(!intmap_are_equal(im11, im75)); | |
| assert(!intmap_are_equal(im23, im16)); | |
| assert(!intmap_are_equal(im31, im6)); | |
| assert(!intmap_are_equal(im2, NULL)); | |
| assert(!intmap_are_equal(im27, im32)); | |
| assert(!intmap_are_equal(im3, NULL)); | |
| assert(!intmap_are_equal(im75, im38)); | |
| assert(intmap_are_equal(im52, NULL)); | |
| assert(!intmap_are_equal(NULL, im9)); | |
| assert(intmap_are_equal(im71, NULL)); | |
| assert(!intmap_are_equal(im47, im5)); | |
| assert(intmap_are_equal(NULL, im54)); | |
| assert(!intmap_are_equal(im64, im18)); | |
| assert(intmap_are_equal(NULL, NULL)); | |
| assert(!intmap_are_equal(im18, im48)); | |
| assert(intmap_are_equal(im57, NULL)); | |
| assert(!intmap_are_equal(im69, im20)); | |
| assert(intmap_are_equal(NULL, NULL)); | |
| assert(!intmap_are_equal(im9, NULL)); | |
| assert(!intmap_are_equal(im27, im23)); | |
| assert(!intmap_are_equal(im65, im9)); | |
| assert(!intmap_are_equal(im21, im27)); | |
| assert(!intmap_are_equal(NULL, im9)); | |
| assert(intmap_are_equal(im44, im18)); | |
| assert(!intmap_are_equal(im75, im44)); | |
| assert(!intmap_are_equal(im59, im69)); | |
| assert(!intmap_are_equal(im73, NULL)); | |
| assert(!intmap_are_equal(NULL, im33)); | |
| assert(!intmap_are_equal(NULL, im61)); | |
| assert(!intmap_are_equal(im28, im44)); | |
| assert(!intmap_are_equal(im18, im50)); | |
| assert(!intmap_are_equal(im27, im72)); | |
| assert(!intmap_are_equal(NULL, im24)); | |
| assert(!intmap_are_equal(im43, im57)); | |
| assert(!intmap_are_equal(im69, im61)); | |
| assert(intmap_are_equal(NULL, im67)); | |
| assert(!intmap_are_equal(NULL, im50)); | |
| assert(intmap_are_equal(NULL, NULL)); | |
| assert(!intmap_are_equal(im26, im37)); | |
| assert(!intmap_are_equal(im14, im3)); | |
| assert(intmap_are_equal(im58, im64)); | |
| assert(!intmap_are_equal(NULL, im24)); | |
| assert(!intmap_are_equal(NULL, im62)); | |
| assert(!intmap_are_equal(im41, im72)); | |
| assert(!intmap_are_equal(im47, im27)); | |
| assert(intmap_are_equal(im57, NULL)); | |
| assert(!intmap_are_equal(im16, im37)); | |
| assert(!intmap_are_equal(NULL, im27)); | |
| assert(intmap_are_equal(im31, im31)); | |
| assert(intmap_are_equal(im51, im56)); | |
| assert(!intmap_are_equal(im28, im46)); | |
| assert(intmap_are_equal(im72, im64)); | |
| assert(intmap_are_equal(im47, NULL)); | |
| assert(!intmap_are_equal(im4, im57)); | |
| assert(!intmap_are_equal(im19, NULL)); | |
| assert(!intmap_are_equal(NULL, im21)); | |
| assert(!intmap_are_equal(im1, im58)); | |
| assert(!intmap_are_equal(im45, im20)); | |
| assert(!intmap_are_equal(im25, im8)); | |
| assert(!intmap_are_equal(im67, im69)); | |
| assert(!intmap_are_equal(im24, im8)); | |
| assert(!intmap_are_equal(im26, NULL)); | |
| assert(!intmap_are_equal(NULL, im65)); | |
| assert(!intmap_are_equal(im33, NULL)); | |
| assert(!intmap_are_equal(im28, im66)); | |
| assert(!intmap_are_equal(im59, im42)); | |
| assert(intmap_are_equal(im52, NULL)); | |
| assert(!intmap_are_equal(im41, im11)); | |
| assert(!intmap_are_equal(NULL, im8)); | |
| assert(!intmap_are_equal(im9, im12)); | |
| assert(intmap_are_equal(NULL, im67)); | |
| assert(!intmap_are_equal(im22, im19)); | |
| assert(!intmap_are_equal(im63, im27)); | |
| assert(!intmap_are_equal(im1, NULL)); | |
| assert(!intmap_are_equal(NULL, im19)); | |
| assert(!intmap_are_equal(im8, im31)); | |
| assert(!intmap_are_equal(im8, im5)); | |
| assert(!intmap_are_equal(im73, NULL)); | |
| assert(!intmap_are_equal(NULL, im37)); | |
| assert(!intmap_are_equal(im57, im32)); | |
| assert(!intmap_are_equal(im50, im45)); | |
| assert(!intmap_are_equal(im10, im40)); | |
| assert(!intmap_are_equal(im13, im15)); | |
| assert(!intmap_are_equal(im67, im2)); | |
| assert(intmap_are_equal(im58, NULL)); | |
| assert(!intmap_are_equal(im20, im68)); | |
| assert(!intmap_are_equal(im19, im73)); | |
| assert(intmap_are_equal(NULL, NULL)); | |
| assert(!intmap_are_equal(im2, im31)); | |
| assert(intmap_are_equal(im52, im63)); | |
| assert(intmap_are_equal(NULL, im53)); | |
| assert(!intmap_are_equal(im50, im43)); | |
| assert(!intmap_are_equal(im3, im47)); | |
| assert(!intmap_are_equal(im10, im20)); | |
| assert(!intmap_are_equal(im15, im53)); | |
| assert(!intmap_are_equal(NULL, im12)); | |
| assert(!intmap_are_equal(im30, im50)); | |
| assert(!intmap_are_equal(im24, im4)); | |
| assert(!intmap_are_equal(im62, im53)); | |
| assert(!intmap_are_equal(im65, im30)); | |
| assert(!intmap_are_equal(im36, im7)); | |
| assert(intmap_are_equal(NULL, NULL)); | |
| assert(!intmap_are_equal(im37, im55)); | |
| assert(!intmap_are_equal(im4, im56)); | |
| assert(!intmap_are_equal(im66, im17)); | |
| assert(!intmap_are_equal(im38, im45)); | |
| assert(!intmap_are_equal(im17, im37)); | |
| assert(!intmap_are_equal(im66, im41)); | |
| assert(intmap_are_equal(im6, im6)); | |
| assert(!intmap_are_equal(im44, NULL)); | |
| assert(!intmap_are_equal(im11, im66)); | |
| assert(!intmap_are_equal(im33, im17)); | |
| assert(!intmap_are_equal(im31, NULL)); | |
| assert(!intmap_are_equal(im16, im26)); | |
| assert(!intmap_are_equal(im40, NULL)); | |
| assert(!intmap_are_equal(im12, im37)); | |
| assert(!intmap_are_equal(im70, im4)); | |
| assert(intmap_are_equal(im36, im36)); | |
| assert(!intmap_are_equal(im9, im10)); | |
| assert(intmap_are_equal(im67, im74)); | |
| assert(!intmap_are_equal(im51, im34)); | |
| assert(!intmap_are_equal(im25, im2)); | |
| assert(!intmap_are_equal(im46, im25)); | |
| assert(!intmap_are_equal(im32, NULL)); | |
| assert(intmap_are_equal(im66, im64)); | |
| assert(!intmap_are_equal(im1, NULL)); | |
| assert(intmap_are_equal(NULL, NULL)); | |
| assert(!intmap_are_equal(im5, im39)); | |
| assert(!intmap_are_equal(im35, im20)); | |
| assert(!intmap_are_equal(im31, im73)); | |
| assert(!intmap_are_equal(im32, im73)); | |
| assert(!intmap_are_equal(im74, im3)); | |
| assert(!intmap_are_equal(im55, im13)); | |
| assert(!intmap_are_equal(im48, im67)); | |
| assert(!intmap_are_equal(im38, NULL)); | |
| assert(!intmap_are_equal(im26, im75)); | |
| assert(intmap_are_equal(NULL, im57)); | |
| assert(intmap_are_equal(im47, im54)); | |
| assert(!intmap_are_equal(im68, NULL)); | |
| assert(intmap_are_equal(im26, im5)); | |
| assert(!intmap_are_equal(im27, NULL)); | |
| assert(!intmap_are_equal(im48, im54)); | |
| assert(intmap_are_equal(im52, im74)); | |
| assert(!intmap_are_equal(im7, im73)); | |
| assert(!intmap_are_equal(im49, im14)); | |
| assert(!intmap_are_equal(im52, im45)); | |
| assert(!intmap_are_equal(im11, im16)); | |
| assert(!intmap_are_equal(im45, im57)); | |
| assert(!intmap_are_equal(im47, im26)); | |
| assert(!intmap_are_equal(im53, im11)); | |
| assert(!intmap_are_equal(im26, im27)); | |
| assert(!intmap_are_equal(im50, im66)); | |
| assert(!intmap_are_equal(im69, im24)); | |
| assert(!intmap_are_equal(im56, im75)); | |
| assert(intmap_are_equal(im64, im57)); | |
| assert(intmap_are_equal(NULL, NULL)); | |
| assert(!intmap_are_equal(NULL, im11)); | |
| assert(!intmap_are_equal(im72, im9)); | |
| assert(!intmap_are_equal(im17, im61)); | |
| assert(intmap_are_equal(NULL, NULL)); | |
| assert(!intmap_are_equal(im53, im30)); | |
| assert(!intmap_are_equal(im42, im46)); | |
| assert(!intmap_are_equal(im10, NULL)); | |
| assert(!intmap_are_equal(im52, im62)); | |
| assert(!intmap_are_equal(im46, im35)); | |
| assert(intmap_are_equal(NULL, NULL)); | |
| assert(!intmap_are_equal(im11, NULL)); | |
| assert(intmap_are_equal(NULL, im59)); | |
| assert(!intmap_are_equal(im60, im5)); | |
| assert(!intmap_are_equal(im27, im39)); | |
| assert(!intmap_are_equal(im35, im27)); | |
| assert(!intmap_are_equal(im12, im15)); | |
| assert(!intmap_are_equal(im26, NULL)); | |
| assert(intmap_are_equal(im46, NULL)); | |
| assert(!intmap_are_equal(im72, im50)); | |
| assert(!intmap_are_equal(im31, im66)); | |
| assert(!intmap_are_equal(im62, im58)); | |
| assert(intmap_are_equal(im51, im71)); | |
| assert(intmap_are_equal(NULL, im46)); | |
| assert(intmap_are_equal(im58, im46)); | |
| assert(intmap_are_equal(im53, NULL)); | |
| assert(!intmap_are_equal(NULL, im12)); | |
| assert(!intmap_are_equal(im74, im62)); | |
| assert(!intmap_are_equal(im14, im47)); | |
| assert(intmap_are_equal(im52, NULL)); | |
| assert(!intmap_are_equal(im20, NULL)); | |
| assert(!intmap_are_equal(im40, im25)); | |
| assert(!intmap_are_equal(im25, im45)); | |
| assert(intmap_are_equal(im57, im59)); | |
| assert(!intmap_are_equal(NULL, im73)); | |
| assert(intmap_are_equal(im70, NULL)); | |
| assert(!intmap_are_equal(im10, im61)); | |
| assert(!intmap_are_equal(im37, im39)); | |
| assert(!intmap_are_equal(im13, im15)); | |
| assert(!intmap_are_equal(im8, im14)); | |
| assert(!intmap_are_equal(im22, im35)); | |
| assert(!intmap_are_equal(im6, NULL)); | |
| assert(!intmap_are_equal(im43, im18)); | |
| assert(!intmap_are_equal(im32, im71)); | |
| assert(!intmap_are_equal(im46, im37)); | |
| assert(!intmap_are_equal(im33, im44)); | |
| assert(!intmap_are_equal(im68, im51)); | |
| assert(!intmap_are_equal(im33, im73)); | |
| assert(!intmap_are_equal(im31, im48)); | |
| assert(!intmap_are_equal(im16, im44)); | |
| assert(!intmap_are_equal(im24, NULL)); | |
| assert(intmap_are_equal(NULL, im49)); | |
| assert(!intmap_are_equal(im53, im9)); | |
| assert(!intmap_are_equal(im17, NULL)); | |
| assert(!intmap_are_equal(im28, im48)); | |
| assert(!intmap_are_equal(im56, im33)); | |
| assert(!intmap_are_equal(im41, im55)); | |
| assert(!intmap_are_equal(im42, im67)); | |
| assert(!intmap_are_equal(im23, im54)); | |
| assert(!intmap_are_equal(im66, im11)); | |
| assert(!intmap_are_equal(im74, im35)); | |
| assert(intmap_are_equal(im74, NULL)); | |
| assert(!intmap_are_equal(im66, im37)); | |
| assert(!intmap_are_equal(im53, im17)); | |
| assert(!intmap_are_equal(im26, im17)); | |
| assert(!intmap_are_equal(NULL, im11)); | |
| assert(!intmap_are_equal(im37, im24)); | |
| assert(!intmap_are_equal(im69, im5)); | |
| assert(!intmap_are_equal(im23, im71)); | |
| assert(!intmap_are_equal(im37, im52)); | |
| assert(intmap_are_equal(im59, NULL)); | |
| assert(!intmap_are_equal(im50, im56)); | |
| assert(!intmap_are_equal(im48, im38)); | |
| assert(!intmap_are_equal(im14, im47)); | |
| assert(!intmap_are_equal(im52, im75)); | |
| assert(!intmap_are_equal(im8, im75)); | |
| assert(intmap_are_equal(NULL, im52)); | |
| assert(!intmap_are_equal(im46, im23)); | |
| assert(!intmap_are_equal(im53, im25)); | |
| assert(!intmap_are_equal(im8, im51)); | |
| assert(!intmap_are_equal(NULL, im10)); | |
| assert(!intmap_are_equal(NULL, im65)); | |
| assert(!intmap_are_equal(im39, im15)); | |
| assert(!intmap_are_equal(NULL, im50)); | |
| assert(!intmap_are_equal(im58, im15)); | |
| assert(!intmap_are_equal(im71, im19)); | |
| assert(!intmap_are_equal(im40, im35)); | |
| assert(!intmap_are_equal(im27, im35)); | |
| assert(intmap_are_equal(im74, im70)); | |
| assert(intmap_are_equal(im74, NULL)); | |
| assert(!intmap_are_equal(im68, im15)); | |
| assert(!intmap_are_equal(im26, im8)); | |
| assert(!intmap_are_equal(im35, im31)); | |
| assert(!intmap_are_equal(im62, im39)); | |
| assert(!intmap_are_equal(NULL, im22)); | |
| assert(!intmap_are_equal(im59, im43)); | |
| assert(!intmap_are_equal(im3, im42)); | |
| assert(!intmap_are_equal(NULL, im16)); | |
| assert(!intmap_are_equal(im19, im69)); | |
| assert(!intmap_are_equal(im42, im18)); | |
| assert(!intmap_are_equal(im69, im59)); | |
| assert(!intmap_are_equal(im67, im33)); | |
| assert(!intmap_are_equal(im67, im42)); | |
| assert(intmap_are_equal(im53, im71)); | |
| assert(!intmap_are_equal(im48, NULL)); | |
| assert(!intmap_are_equal(im6, NULL)); | |
| assert(!intmap_are_equal(im21, im69)); | |
| assert(!intmap_are_equal(im48, NULL)); | |
| assert(!intmap_are_equal(im6, im39)); | |
| assert(!intmap_are_equal(im43, im66)); | |
| assert(!intmap_are_equal(im6, im52)); | |
| assert(!intmap_are_equal(im54, im39)); | |
| assert(!intmap_are_equal(im14, im65)); | |
| assert(!intmap_are_equal(im48, NULL)); | |
| assert(!intmap_are_equal(im16, NULL)); | |
| assert(intmap_are_equal(im66, NULL)); | |
| assert(!intmap_are_equal(im72, im41)); | |
| assert(!intmap_are_equal(im9, NULL)); | |
| assert(!intmap_are_equal(im75, im8)); | |
| assert(!intmap_are_equal(NULL, im62)); | |
| assert(!intmap_are_equal(im31, im20)); | |
| assert(!intmap_are_equal(im42, im72)); | |
| assert(!intmap_are_equal(im49, im30)); | |
| assert(!intmap_are_equal(im41, NULL)); | |
| assert(!intmap_are_equal(im17, im1)); | |
| assert(!intmap_are_equal(im45, im33)); | |
| assert(intmap_are_equal(im54, im52)); | |
| assert(intmap_are_equal(NULL, NULL)); | |
| assert(!intmap_are_equal(im54, im3)); | |
| assert(!intmap_are_equal(im51, im25)); | |
| assert(!intmap_are_equal(NULL, im31)); | |
| assert(!intmap_are_equal(im9, NULL)); | |
| assert(!intmap_are_equal(im63, im44)); | |
| assert(!intmap_are_equal(im61, NULL)); | |
| assert(!intmap_are_equal(im11, NULL)); | |
| assert(intmap_are_equal(im48, im48)); | |
| assert(!intmap_are_equal(im61, im75)); | |
| assert(!intmap_are_equal(NULL, im12)); | |
| assert(!intmap_are_equal(im22, NULL)); | |
| assert(!intmap_are_equal(im36, NULL)); | |
| assert(intmap_are_equal(NULL, im63)); | |
| assert(intmap_are_equal(NULL, NULL)); | |
| assert(intmap_are_equal(im49, im56)); | |
| assert(!intmap_are_equal(im25, im6)); | |
| assert(!intmap_are_equal(im31, im53)); | |
| assert(!intmap_are_equal(im58, im43)); | |
| assert(!intmap_are_equal(im48, NULL)); | |
| assert(!intmap_are_equal(im74, im26)); | |
| assert(!intmap_are_equal(im19, im22)); | |
| assert(!intmap_are_equal(NULL, im31)); | |
| assert(intmap_are_equal(im47, NULL)); | |
| assert(!intmap_are_equal(im51, im35)); | |
| assert(!intmap_are_equal(im62, im43)); | |
| assert(!intmap_are_equal(im52, im37)); | |
| assert(!intmap_are_equal(im66, im12)); | |
| assert(!intmap_are_equal(im56, im68)); | |
| assert(!intmap_are_equal(im31, NULL)); | |
| assert(!intmap_are_equal(NULL, im29)); | |
| assert(!intmap_are_equal(NULL, im37)); | |
| assert(!intmap_are_equal(NULL, im27)); | |
| assert(!intmap_are_equal(im34, NULL)); | |
| assert(!intmap_are_equal(im48, im25)); | |
| assert(!intmap_are_equal(im43, im69)); | |
| assert(!intmap_are_equal(im17, im50)); | |
| assert(!intmap_are_equal(im58, im26)); | |
| assert(!intmap_are_equal(im38, NULL)); | |
| assert(intmap_are_equal(im54, im56)); | |
| assert(intmap_are_equal(im70, im56)); | |
| assert(!intmap_are_equal(im4, NULL)); | |
| assert(!intmap_are_equal(im74, im12)); | |
| assert(intmap_are_equal(NULL, NULL)); | |
| assert(!intmap_are_equal(im11, NULL)); | |
| assert(!intmap_are_equal(im36, NULL)); | |
| assert(!intmap_are_equal(im36, im15)); | |
| assert(!intmap_are_equal(NULL, im73)); | |
| assert(!intmap_are_equal(NULL, im62)); | |
| assert(!intmap_are_equal(im12, im32)); | |
| assert(!intmap_are_equal(im31, im50)); | |
| assert(!intmap_are_equal(im25, im66)); | |
| assert(!intmap_are_equal(im69, im49)); | |
| assert(!intmap_are_equal(NULL, im45)); | |
| assert(!intmap_are_equal(im49, im2)); | |
| assert(intmap_are_equal(im60, NULL)); | |
| assert(intmap_are_equal(NULL, NULL)); | |
| assert(!intmap_are_equal(im36, im23)); | |
| assert(!intmap_are_equal(im35, NULL)); | |
| assert(!intmap_are_equal(im48, NULL)); | |
| assert(!intmap_are_equal(im73, NULL)); | |
| assert(!intmap_are_equal(im23, im8)); | |
| assert(!intmap_are_equal(im56, im43)); | |
| assert(!intmap_are_equal(NULL, im36)); | |
| assert(!intmap_are_equal(im61, im25)); | |
| assert(!intmap_are_equal(im34, NULL)); | |
| assert(!intmap_are_equal(im68, im74)); | |
| assert(!intmap_are_equal(im50, im5)); | |
| assert(intmap_are_equal(im64, NULL)); | |
| assert(!intmap_are_equal(im11, im74)); | |
| assert(!intmap_are_equal(im43, NULL)); | |
| assert(!intmap_are_equal(im75, im72)); | |
| assert(!intmap_are_equal(im48, im2)); | |
| assert(!intmap_are_equal(im6, im44)); | |
| assert(!intmap_are_equal(im33, im50)); | |
| assert(intmap_are_equal(NULL, im64)); | |
| assert(!intmap_are_equal(im55, im3)); | |
| assert(!intmap_are_equal(im60, im35)); | |
| assert(!intmap_are_equal(im22, im63)); | |
| assert(!intmap_are_equal(NULL, im65)); | |
| assert(!intmap_are_equal(im36, im72)); | |
| assert(!intmap_are_equal(im66, im9)); | |
| assert(intmap_are_equal(im57, NULL)); | |
| assert(!intmap_are_equal(im2, im30)); | |
| assert(intmap_are_equal(NULL, NULL)); | |
| assert(!intmap_are_equal(im2, im8)); | |
| assert(!intmap_are_equal(im3, im61)); | |
| assert(!intmap_are_equal(im53, im19)); | |
| assert(!intmap_are_equal(im15, im49)); | |
| assert(!intmap_are_equal(im20, im37)); | |
| assert(!intmap_are_equal(im13, im60)); | |
| assert(!intmap_are_equal(NULL, im4)); | |
| assert(!intmap_are_equal(im23, im38)); | |
| assert(!intmap_are_equal(im38, im15)); | |
| assert(!intmap_are_equal(im63, im19)); | |
| assert(intmap_are_equal(im67, im72)); | |
| assert(!intmap_are_equal(im63, im32)); | |
| assert(!intmap_are_equal(im53, im23)); | |
| assert(!intmap_are_equal(im19, im12)); | |
| assert(!intmap_are_equal(im60, im19)); | |
| assert(!intmap_are_equal(im49, im41)); | |
| assert(!intmap_are_equal(im75, NULL)); | |
| assert(!intmap_are_equal(im42, im35)); | |
| assert(!intmap_are_equal(im42, im1)); | |
| assert(!intmap_are_equal(im42, im74)); | |
| assert(!intmap_are_equal(im19, im67)); | |
| assert(!intmap_are_equal(im37, NULL)); | |
| assert(!intmap_are_equal(im32, im70)); | |
| assert(!intmap_are_equal(im11, NULL)); | |
| assert(intmap_are_equal(im47, NULL)); | |
| assert(!intmap_are_equal(im42, im10)); | |
| assert(!intmap_are_equal(NULL, im30)); | |
| assert(!intmap_are_equal(im32, im55)); | |
| assert(!intmap_are_equal(im30, im51)); | |
| assert(!intmap_are_equal(im10, im66)); | |
| assert(!intmap_are_equal(NULL, im12)); | |
| assert(!intmap_are_equal(im24, im15)); | |
| assert(!intmap_are_equal(im52, im1)); | |
| assert(!intmap_are_equal(im60, im20)); | |
| assert(!intmap_are_equal(im13, im40)); | |
| assert(!intmap_are_equal(im8, im37)); | |
| assert(!intmap_are_equal(im31, im23)); | |
| assert(!intmap_are_equal(im52, im36)); | |
| assert(!intmap_are_equal(im17, NULL)); | |
| assert(!intmap_are_equal(im60, im35)); | |
| assert(!intmap_are_equal(NULL, im50)); | |
| assert(!intmap_are_equal(im51, im10)); | |
| assert(!intmap_are_equal(im39, im56)); | |
| assert(!intmap_are_equal(im14, im40)); | |
| assert(!intmap_are_equal(im50, im51)); | |
| assert(!intmap_are_equal(im21, im3)); | |
| assert(!intmap_are_equal(im57, im11)); | |
| assert(!intmap_are_equal(NULL, im45)); | |
| assert(!intmap_are_equal(im40, im34)); | |
| assert(!intmap_are_equal(im10, im71)); | |
| assert(intmap_are_equal(NULL, NULL)); | |
| assert(intmap_are_equal(NULL, NULL)); | |
| assert(!intmap_are_equal(im34, NULL)); | |
| assert(!intmap_are_equal(im8, im57)); | |
| assert(!intmap_are_equal(im5, NULL)); | |
| assert(!intmap_are_equal(im70, im11)); | |
| assert(!intmap_are_equal(im24, NULL)); | |
| assert(!intmap_are_equal(im58, im13)); | |
| assert(!intmap_are_equal(im73, im70)); | |
| assert(!intmap_are_equal(im72, im27)); | |
| assert(intmap_are_equal(NULL, NULL)); | |
| assert(!intmap_are_equal(im50, im44)); | |
| assert(!intmap_are_equal(NULL, im18)); | |
| assert(!intmap_are_equal(im13, im16)); | |
| assert(!intmap_are_equal(im32, NULL)); | |
| assert(!intmap_are_equal(im75, NULL)); | |
| assert(!intmap_are_equal(im27, im63)); | |
| assert(!intmap_are_equal(im46, im45)); | |
| assert(!intmap_are_equal(im3, im29)); | |
| assert(!intmap_are_equal(im2, NULL)); | |
| assert(!intmap_are_equal(im73, im17)); | |
| assert(!intmap_are_equal(NULL, im9)); | |
| assert(intmap_are_equal(im66, NULL)); | |
| assert(!intmap_are_equal(im37, im2)); | |
| assert(!intmap_are_equal(im3, im18)); | |
| assert(intmap_are_equal(im71, im70)); | |
| assert(intmap_are_equal(im66, im63)); | |
| assert(!intmap_are_equal(NULL, im24)); | |
| assert(!intmap_are_equal(im62, im31)); | |
| assert(!intmap_are_equal(im1, im59)); | |
| assert(intmap_are_equal(im51, im74)); | |
| assert(!intmap_are_equal(im24, NULL)); | |
| assert(intmap_are_equal(im54, NULL)); | |
| assert(!intmap_are_equal(im39, im8)); | |
| assert(intmap_are_equal(im60, im66)); | |
| assert(!intmap_are_equal(im37, im47)); | |
| assert(!intmap_are_equal(im27, NULL)); | |
| assert(!intmap_are_equal(im25, im30)); | |
| assert(!intmap_are_equal(im64, im48)); | |
| assert(!intmap_are_equal(im2, im3)); | |
| assert(!intmap_are_equal(im32, im56)); | |
| assert(!intmap_are_equal(im63, im17)); | |
| assert(!intmap_are_equal(im1, im10)); | |
| assert(!intmap_are_equal(NULL, im25)); | |
| assert(!intmap_are_equal(im20, im66)); | |
| assert(!intmap_are_equal(im43, im35)); | |
| assert(!intmap_are_equal(im50, im19)); | |
| // check random memberships and free; | |
| v = intmap_lookup(im36, 2667557012157109398UL); | |
| assert(!intmap_lookup(im36, 2667557012157109398UL).present); | |
| v = intmap_lookup(im14, 14490036593423678000UL); | |
| assert(!intmap_lookup(im14, 14490036593423678000UL).present); | |
| v = intmap_lookup(im38, 5UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "37", 2UL) == 0); | |
| v = intmap_lookup(im45, 3UL); | |
| assert(!intmap_lookup(im45, 3UL).present); | |
| v = intmap_lookup(im18, 2625011179408469742UL); | |
| assert(!intmap_lookup(im18, 2625011179408469742UL).present); | |
| v = intmap_lookup(im53, 17716769152692975850UL); | |
| assert(!intmap_lookup(im53, 17716769152692975850UL).present); | |
| v = intmap_lookup(im39, 14490036593423678000UL); | |
| assert(!intmap_lookup(im39, 14490036593423678000UL).present); | |
| v = intmap_lookup(NULL, 6UL); | |
| assert(!intmap_lookup(NULL, 6UL).present); | |
| v = intmap_lookup(im51, 9475316500171939218UL); | |
| assert(!intmap_lookup(im51, 9475316500171939218UL).present); | |
| v = intmap_lookup(im36, 0UL); | |
| assert(!intmap_lookup(im36, 0UL).present); | |
| v = intmap_lookup(im5, 5UL); | |
| assert(!intmap_lookup(im5, 5UL).present); | |
| v = intmap_lookup(im17, 17716769152692975850UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "2a", 2UL) == 0); | |
| v = intmap_lookup(im8, 2625011179408469742UL); | |
| assert(!intmap_lookup(im8, 2625011179408469742UL).present); | |
| v = intmap_lookup(im30, 16873582492441264833UL); | |
| assert(!intmap_lookup(im30, 16873582492441264833UL).present); | |
| v = intmap_lookup(im70, 10471506749266861704UL); | |
| assert(!intmap_lookup(im70, 10471506749266861704UL).present); | |
| v = intmap_lookup(NULL, 13443926201081858053UL); | |
| assert(!intmap_lookup(NULL, 13443926201081858053UL).present); | |
| v = intmap_lookup(im63, 8UL); | |
| assert(!intmap_lookup(im63, 8UL).present); | |
| v = intmap_lookup(im48, 2UL); | |
| assert(!intmap_lookup(im48, 2UL).present); | |
| intmap_release(a, im38); | |
| v = intmap_lookup(im17, 17716769152692975850UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "2a", 2UL) == 0); | |
| v = intmap_lookup(im39, 761643042849108716UL); | |
| assert(!intmap_lookup(im39, 761643042849108716UL).present); | |
| v = intmap_lookup(im63, 12UL); | |
| assert(!intmap_lookup(im63, 12UL).present); | |
| v = intmap_lookup(im32, 9UL); | |
| assert(!intmap_lookup(im32, 9UL).present); | |
| v = intmap_lookup(im32, 6687872038456266494UL); | |
| assert(!intmap_lookup(im32, 6687872038456266494UL).present); | |
| v = intmap_lookup(im44, 2625011179408469742UL); | |
| assert(!intmap_lookup(im44, 2625011179408469742UL).present); | |
| intmap_release(a, im42); | |
| v = intmap_lookup(im28, 17716769152692975850UL); | |
| assert(!intmap_lookup(im28, 17716769152692975850UL).present); | |
| v = intmap_lookup(im67, 2625011179408469742UL); | |
| assert(!intmap_lookup(im67, 2625011179408469742UL).present); | |
| v = intmap_lookup(NULL, 2625011179408469742UL); | |
| assert(!intmap_lookup(NULL, 2625011179408469742UL).present); | |
| v = intmap_lookup(im48, 2UL); | |
| assert(!intmap_lookup(im48, 2UL).present); | |
| intmap_release(a, im8); | |
| v = intmap_lookup(im10, 2UL); | |
| assert(!intmap_lookup(im10, 2UL).present); | |
| v = intmap_lookup(im3, 12177582039016398197UL); | |
| assert(!intmap_lookup(im3, 12177582039016398197UL).present); | |
| v = intmap_lookup(NULL, 19UL); | |
| assert(!intmap_lookup(NULL, 19UL).present); | |
| v = intmap_lookup(NULL, 17716769152692975850UL); | |
| assert(!intmap_lookup(NULL, 17716769152692975850UL).present); | |
| v = intmap_lookup(im60, 4UL); | |
| assert(!intmap_lookup(im60, 4UL).present); | |
| v = intmap_lookup(im58, 761643042849108716UL); | |
| assert(!intmap_lookup(im58, 761643042849108716UL).present); | |
| v = intmap_lookup(im14, 2667557012157109398UL); | |
| assert(v.present); | |
| assert(v.length == 8UL); | |
| assert(memcmp(v.data, "8d54a229", 8UL) == 0); | |
| v = intmap_lookup(im61, 5264564837108559896UL); | |
| assert(!intmap_lookup(im61, 5264564837108559896UL).present); | |
| v = intmap_lookup(NULL, 2028013609556924232UL); | |
| assert(!intmap_lookup(NULL, 2028013609556924232UL).present); | |
| v = intmap_lookup(NULL, 14490036593423678000UL); | |
| assert(!intmap_lookup(NULL, 14490036593423678000UL).present); | |
| v = intmap_lookup(im51, 12UL); | |
| assert(!intmap_lookup(im51, 12UL).present); | |
| v = intmap_lookup(im15, 5UL); | |
| assert(!intmap_lookup(im15, 5UL).present); | |
| v = intmap_lookup(im6, 2667557012157109398UL); | |
| assert(!intmap_lookup(im6, 2667557012157109398UL).present); | |
| v = intmap_lookup(NULL, 761643042849108716UL); | |
| assert(!intmap_lookup(NULL, 761643042849108716UL).present); | |
| v = intmap_lookup(im13, 10887994888480023694UL); | |
| assert(!intmap_lookup(im13, 10887994888480023694UL).present); | |
| v = intmap_lookup(im33, 5UL); | |
| assert(v.present); | |
| assert(v.length == 10UL); | |
| assert(memcmp(v.data, "e41d981864", 10UL) == 0); | |
| intmap_release(a, im7); | |
| v = intmap_lookup(NULL, 2667557012157109398UL); | |
| assert(!intmap_lookup(NULL, 2667557012157109398UL).present); | |
| v = intmap_lookup(NULL, 11994094489140796726UL); | |
| assert(!intmap_lookup(NULL, 11994094489140796726UL).present); | |
| v = intmap_lookup(im40, 2UL); | |
| assert(!intmap_lookup(im40, 2UL).present); | |
| v = intmap_lookup(im10, 13443926201081858053UL); | |
| assert(!intmap_lookup(im10, 13443926201081858053UL).present); | |
| v = intmap_lookup(im45, 5UL); | |
| assert(v.present); | |
| assert(v.length == 10UL); | |
| assert(memcmp(v.data, "e41d981864", 10UL) == 0); | |
| v = intmap_lookup(im44, 10122179591171658085UL); | |
| assert(!intmap_lookup(im44, 10122179591171658085UL).present); | |
| v = intmap_lookup(im37, 14490036593423678000UL); | |
| assert(!intmap_lookup(im37, 14490036593423678000UL).present); | |
| v = intmap_lookup(im15, 5UL); | |
| assert(!intmap_lookup(im15, 5UL).present); | |
| v = intmap_lookup(im43, 2667557012157109398UL); | |
| assert(v.present); | |
| assert(v.length == 8UL); | |
| assert(memcmp(v.data, "8d54a229", 8UL) == 0); | |
| v = intmap_lookup(NULL, 2UL); | |
| assert(!intmap_lookup(NULL, 2UL).present); | |
| v = intmap_lookup(im54, 7UL); | |
| assert(!intmap_lookup(im54, 7UL).present); | |
| v = intmap_lookup(im40, 2UL); | |
| assert(!intmap_lookup(im40, 2UL).present); | |
| v = intmap_lookup(im14, 13443926201081858053UL); | |
| assert(!intmap_lookup(im14, 13443926201081858053UL).present); | |
| v = intmap_lookup(NULL, 24UL); | |
| assert(!intmap_lookup(NULL, 24UL).present); | |
| v = intmap_lookup(im37, 2625011179408469742UL); | |
| assert(!intmap_lookup(im37, 2625011179408469742UL).present); | |
| v = intmap_lookup(im13, 5UL); | |
| assert(!intmap_lookup(im13, 5UL).present); | |
| v = intmap_lookup(im12, 2UL); | |
| assert(!intmap_lookup(im12, 2UL).present); | |
| intmap_release(a, im56); | |
| v = intmap_lookup(im57, 4UL); | |
| assert(!intmap_lookup(im57, 4UL).present); | |
| v = intmap_lookup(im22, 5UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "0a", 2UL) == 0); | |
| v = intmap_lookup(im29, 761643042849108716UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "59", 2UL) == 0); | |
| v = intmap_lookup(im6, 2UL); | |
| assert(!intmap_lookup(im6, 2UL).present); | |
| v = intmap_lookup(NULL, 1201439129495439632UL); | |
| assert(!intmap_lookup(NULL, 1201439129495439632UL).present); | |
| v = intmap_lookup(im4, 2667557012157109398UL); | |
| assert(!intmap_lookup(im4, 2667557012157109398UL).present); | |
| v = intmap_lookup(im64, 13443926201081858053UL); | |
| assert(!intmap_lookup(im64, 13443926201081858053UL).present); | |
| v = intmap_lookup(im18, 5961378758959004667UL); | |
| assert(!intmap_lookup(im18, 5961378758959004667UL).present); | |
| v = intmap_lookup(im69, 2667557012157109398UL); | |
| assert(!intmap_lookup(im69, 2667557012157109398UL).present); | |
| v = intmap_lookup(im15, 2187304219963443642UL); | |
| assert(!intmap_lookup(im15, 2187304219963443642UL).present); | |
| v = intmap_lookup(im13, 2625011179408469742UL); | |
| assert(!intmap_lookup(im13, 2625011179408469742UL).present); | |
| v = intmap_lookup(im73, 2UL); | |
| assert(!intmap_lookup(im73, 2UL).present); | |
| v = intmap_lookup(im39, 35UL); | |
| assert(!intmap_lookup(im39, 35UL).present); | |
| v = intmap_lookup(im29, 761643042849108716UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "59", 2UL) == 0); | |
| v = intmap_lookup(NULL, 5UL); | |
| assert(!intmap_lookup(NULL, 5UL).present); | |
| v = intmap_lookup(im1, 761643042849108716UL); | |
| assert(!intmap_lookup(im1, 761643042849108716UL).present); | |
| intmap_release(a, im41); | |
| v = intmap_lookup(im51, 2UL); | |
| assert(!intmap_lookup(im51, 2UL).present); | |
| v = intmap_lookup(im70, 5UL); | |
| assert(!intmap_lookup(im70, 5UL).present); | |
| v = intmap_lookup(NULL, 6899454156098675072UL); | |
| assert(!intmap_lookup(NULL, 6899454156098675072UL).present); | |
| intmap_release(a, im35); | |
| v = intmap_lookup(im4, 14878246852761994905UL); | |
| assert(!intmap_lookup(im4, 14878246852761994905UL).present); | |
| v = intmap_lookup(im21, 8UL); | |
| assert(!intmap_lookup(im21, 8UL).present); | |
| v = intmap_lookup(im60, 2667557012157109398UL); | |
| assert(!intmap_lookup(im60, 2667557012157109398UL).present); | |
| v = intmap_lookup(im3, 2UL); | |
| assert(!intmap_lookup(im3, 2UL).present); | |
| v = intmap_lookup(im40, 5UL); | |
| assert(!intmap_lookup(im40, 5UL).present); | |
| v = intmap_lookup(NULL, 5UL); | |
| assert(!intmap_lookup(NULL, 5UL).present); | |
| v = intmap_lookup(im74, 2625011179408469742UL); | |
| assert(!intmap_lookup(im74, 2625011179408469742UL).present); | |
| v = intmap_lookup(im43, 2UL); | |
| assert(!intmap_lookup(im43, 2UL).present); | |
| intmap_release(a, im12); | |
| v = intmap_lookup(NULL, 761643042849108716UL); | |
| assert(!intmap_lookup(NULL, 761643042849108716UL).present); | |
| v = intmap_lookup(im22, 2UL); | |
| assert(!intmap_lookup(im22, 2UL).present); | |
| v = intmap_lookup(NULL, 13443926201081858053UL); | |
| assert(!intmap_lookup(NULL, 13443926201081858053UL).present); | |
| v = intmap_lookup(im26, 902480071682136869UL); | |
| assert(!intmap_lookup(im26, 902480071682136869UL).present); | |
| v = intmap_lookup(im55, 16277048997805965585UL); | |
| assert(!intmap_lookup(im55, 16277048997805965585UL).present); | |
| v = intmap_lookup(im73, 4UL); | |
| assert(!intmap_lookup(im73, 4UL).present); | |
| v = intmap_lookup(im3, 14544648360362657943UL); | |
| assert(!intmap_lookup(im3, 14544648360362657943UL).present); | |
| v = intmap_lookup(im10, 761643042849108716UL); | |
| assert(!intmap_lookup(im10, 761643042849108716UL).present); | |
| v = intmap_lookup(im30, 14490036593423678000UL); | |
| assert(!intmap_lookup(im30, 14490036593423678000UL).present); | |
| v = intmap_lookup(im31, 14150961214526290644UL); | |
| assert(!intmap_lookup(im31, 14150961214526290644UL).present); | |
| intmap_release(a, im46); | |
| v = intmap_lookup(im24, 12653639342185718187UL); | |
| assert(!intmap_lookup(im24, 12653639342185718187UL).present); | |
| v = intmap_lookup(im49, 761643042849108716UL); | |
| assert(!intmap_lookup(im49, 761643042849108716UL).present); | |
| v = intmap_lookup(im51, 14490036593423678000UL); | |
| assert(!intmap_lookup(im51, 14490036593423678000UL).present); | |
| v = intmap_lookup(im61, 17615252976351227271UL); | |
| assert(!intmap_lookup(im61, 17615252976351227271UL).present); | |
| intmap_release(a, im13); | |
| v = intmap_lookup(im71, 2UL); | |
| assert(!intmap_lookup(im71, 2UL).present); | |
| v = intmap_lookup(im23, 6UL); | |
| assert(!intmap_lookup(im23, 6UL).present); | |
| v = intmap_lookup(im1, 5932907698239413276UL); | |
| assert(!intmap_lookup(im1, 5932907698239413276UL).present); | |
| v = intmap_lookup(im9, 2625011179408469742UL); | |
| assert(!intmap_lookup(im9, 2625011179408469742UL).present); | |
| v = intmap_lookup(im59, 17716769152692975850UL); | |
| assert(!intmap_lookup(im59, 17716769152692975850UL).present); | |
| v = intmap_lookup(im69, 17716769152692975850UL); | |
| assert(!intmap_lookup(im69, 17716769152692975850UL).present); | |
| v = intmap_lookup(im19, 5UL); | |
| assert(!intmap_lookup(im19, 5UL).present); | |
| intmap_release(a, im28); | |
| v = intmap_lookup(im64, 17253608502564305969UL); | |
| assert(!intmap_lookup(im64, 17253608502564305969UL).present); | |
| v = intmap_lookup(im34, 761643042849108716UL); | |
| assert(!intmap_lookup(im34, 761643042849108716UL).present); | |
| v = intmap_lookup(im6, 3UL); | |
| assert(!intmap_lookup(im6, 3UL).present); | |
| v = intmap_lookup(im37, 2667557012157109398UL); | |
| assert(v.present); | |
| assert(v.length == 8UL); | |
| assert(memcmp(v.data, "8d54a229", 8UL) == 0); | |
| v = intmap_lookup(im72, 0UL); | |
| assert(!intmap_lookup(im72, 0UL).present); | |
| v = intmap_lookup(im54, 9848070263861908076UL); | |
| assert(!intmap_lookup(im54, 9848070263861908076UL).present); | |
| v = intmap_lookup(NULL, 761643042849108716UL); | |
| assert(!intmap_lookup(NULL, 761643042849108716UL).present); | |
| v = intmap_lookup(im31, 13443926201081858053UL); | |
| assert(!intmap_lookup(im31, 13443926201081858053UL).present); | |
| v = intmap_lookup(NULL, 761643042849108716UL); | |
| assert(!intmap_lookup(NULL, 761643042849108716UL).present); | |
| v = intmap_lookup(im25, 15684262163931841030UL); | |
| assert(!intmap_lookup(im25, 15684262163931841030UL).present); | |
| v = intmap_lookup(im58, 12400886317364653342UL); | |
| assert(!intmap_lookup(im58, 12400886317364653342UL).present); | |
| v = intmap_lookup(NULL, 4UL); | |
| assert(!intmap_lookup(NULL, 4UL).present); | |
| v = intmap_lookup(im66, 761643042849108716UL); | |
| assert(!intmap_lookup(im66, 761643042849108716UL).present); | |
| v = intmap_lookup(im18, 5UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "0a", 2UL) == 0); | |
| v = intmap_lookup(im39, 15180129734401429911UL); | |
| assert(!intmap_lookup(im39, 15180129734401429911UL).present); | |
| v = intmap_lookup(im73, 2625011179408469742UL); | |
| assert(!intmap_lookup(im73, 2625011179408469742UL).present); | |
| intmap_release(a, im47); | |
| intmap_release(a, im6); | |
| v = intmap_lookup(im14, 761643042849108716UL); | |
| assert(!intmap_lookup(im14, 761643042849108716UL).present); | |
| v = intmap_lookup(im48, 2UL); | |
| assert(!intmap_lookup(im48, 2UL).present); | |
| v = intmap_lookup(im64, 2UL); | |
| assert(!intmap_lookup(im64, 2UL).present); | |
| v = intmap_lookup(im58, 14490036593423678000UL); | |
| assert(!intmap_lookup(im58, 14490036593423678000UL).present); | |
| v = intmap_lookup(im53, 10453667501261964511UL); | |
| assert(!intmap_lookup(im53, 10453667501261964511UL).present); | |
| v = intmap_lookup(im40, 5UL); | |
| assert(!intmap_lookup(im40, 5UL).present); | |
| v = intmap_lookup(im22, 2UL); | |
| assert(!intmap_lookup(im22, 2UL).present); | |
| v = intmap_lookup(im14, 17716769152692975850UL); | |
| assert(!intmap_lookup(im14, 17716769152692975850UL).present); | |
| v = intmap_lookup(NULL, 761643042849108716UL); | |
| assert(!intmap_lookup(NULL, 761643042849108716UL).present); | |
| v = intmap_lookup(im32, 17337619426021077560UL); | |
| assert(!intmap_lookup(im32, 17337619426021077560UL).present); | |
| v = intmap_lookup(im73, 5UL); | |
| assert(!intmap_lookup(im73, 5UL).present); | |
| intmap_release(a, im55); | |
| v = intmap_lookup(NULL, 13443926201081858053UL); | |
| assert(!intmap_lookup(NULL, 13443926201081858053UL).present); | |
| v = intmap_lookup(NULL, 2UL); | |
| assert(!intmap_lookup(NULL, 2UL).present); | |
| v = intmap_lookup(im74, 7823164141722135710UL); | |
| assert(!intmap_lookup(im74, 7823164141722135710UL).present); | |
| v = intmap_lookup(NULL, 14486770614035862477UL); | |
| assert(!intmap_lookup(NULL, 14486770614035862477UL).present); | |
| v = intmap_lookup(im33, 2UL); | |
| assert(!intmap_lookup(im33, 2UL).present); | |
| v = intmap_lookup(im75, 2114758274888756910UL); | |
| assert(!intmap_lookup(im75, 2114758274888756910UL).present); | |
| v = intmap_lookup(im21, 13443926201081858053UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "29", 2UL) == 0); | |
| v = intmap_lookup(im74, 17716769152692975850UL); | |
| assert(!intmap_lookup(im74, 17716769152692975850UL).present); | |
| v = intmap_lookup(im48, 761643042849108716UL); | |
| assert(!intmap_lookup(im48, 761643042849108716UL).present); | |
| v = intmap_lookup(im43, 8UL); | |
| assert(!intmap_lookup(im43, 8UL).present); | |
| v = intmap_lookup(im25, 761643042849108716UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "59", 2UL) == 0); | |
| intmap_release(a, im3); | |
| v = intmap_lookup(im51, 2625011179408469742UL); | |
| assert(!intmap_lookup(im51, 2625011179408469742UL).present); | |
| v = intmap_lookup(im44, 5UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "0a", 2UL) == 0); | |
| v = intmap_lookup(NULL, 4318411884142068257UL); | |
| assert(!intmap_lookup(NULL, 4318411884142068257UL).present); | |
| v = intmap_lookup(im17, 2625011179408469742UL); | |
| assert(!intmap_lookup(im17, 2625011179408469742UL).present); | |
| v = intmap_lookup(NULL, 13443926201081858053UL); | |
| assert(!intmap_lookup(NULL, 13443926201081858053UL).present); | |
| v = intmap_lookup(im65, 2667557012157109398UL); | |
| assert(!intmap_lookup(im65, 2667557012157109398UL).present); | |
| v = intmap_lookup(im69, 5414539054254578426UL); | |
| assert(!intmap_lookup(im69, 5414539054254578426UL).present); | |
| v = intmap_lookup(im72, 2625011179408469742UL); | |
| assert(!intmap_lookup(im72, 2625011179408469742UL).present); | |
| v = intmap_lookup(im29, 13443926201081858053UL); | |
| assert(v.present); | |
| assert(v.length == 8UL); | |
| assert(memcmp(v.data, "c085e4a6", 8UL) == 0); | |
| v = intmap_lookup(im27, 5UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "37", 2UL) == 0); | |
| v = intmap_lookup(NULL, 906168846387887067UL); | |
| assert(!intmap_lookup(NULL, 906168846387887067UL).present); | |
| v = intmap_lookup(im53, 761643042849108716UL); | |
| assert(!intmap_lookup(im53, 761643042849108716UL).present); | |
| v = intmap_lookup(im14, 16273968806458734522UL); | |
| assert(!intmap_lookup(im14, 16273968806458734522UL).present); | |
| v = intmap_lookup(im51, 5UL); | |
| assert(!intmap_lookup(im51, 5UL).present); | |
| v = intmap_lookup(im71, 5UL); | |
| assert(!intmap_lookup(im71, 5UL).present); | |
| v = intmap_lookup(im22, 5UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "0a", 2UL) == 0); | |
| v = intmap_lookup(im20, 2625011179408469742UL); | |
| assert(!intmap_lookup(im20, 2625011179408469742UL).present); | |
| v = intmap_lookup(im43, 0UL); | |
| assert(!intmap_lookup(im43, 0UL).present); | |
| v = intmap_lookup(im73, 2667557012157109398UL); | |
| assert(v.present); | |
| assert(v.length == 8UL); | |
| assert(memcmp(v.data, "8d54a229", 8UL) == 0); | |
| v = intmap_lookup(im51, 5UL); | |
| assert(!intmap_lookup(im51, 5UL).present); | |
| v = intmap_lookup(im67, 2625011179408469742UL); | |
| assert(!intmap_lookup(im67, 2625011179408469742UL).present); | |
| v = intmap_lookup(im34, 4UL); | |
| assert(!intmap_lookup(im34, 4UL).present); | |
| v = intmap_lookup(im65, 761643042849108716UL); | |
| assert(!intmap_lookup(im65, 761643042849108716UL).present); | |
| v = intmap_lookup(NULL, 300620146033957640UL); | |
| assert(!intmap_lookup(NULL, 300620146033957640UL).present); | |
| v = intmap_lookup(im26, 2625011179408469742UL); | |
| assert(!intmap_lookup(im26, 2625011179408469742UL).present); | |
| v = intmap_lookup(im2, 17716769152692975850UL); | |
| assert(!intmap_lookup(im2, 17716769152692975850UL).present); | |
| intmap_release(a, im51); | |
| v = intmap_lookup(im4, 1UL); | |
| assert(!intmap_lookup(im4, 1UL).present); | |
| intmap_release(a, im74); | |
| v = intmap_lookup(im44, 9340332974856987867UL); | |
| assert(!intmap_lookup(im44, 9340332974856987867UL).present); | |
| intmap_release(a, im50); | |
| v = intmap_lookup(im10, 7UL); | |
| assert(!intmap_lookup(im10, 7UL).present); | |
| v = intmap_lookup(im53, 14490036593423678000UL); | |
| assert(!intmap_lookup(im53, 14490036593423678000UL).present); | |
| v = intmap_lookup(im20, 2UL); | |
| assert(!intmap_lookup(im20, 2UL).present); | |
| v = intmap_lookup(im15, 9UL); | |
| assert(!intmap_lookup(im15, 9UL).present); | |
| v = intmap_lookup(im31, 2667557012157109398UL); | |
| assert(!intmap_lookup(im31, 2667557012157109398UL).present); | |
| v = intmap_lookup(im24, 3539803080675683032UL); | |
| assert(!intmap_lookup(im24, 3539803080675683032UL).present); | |
| v = intmap_lookup(im45, 5UL); | |
| assert(v.present); | |
| assert(v.length == 10UL); | |
| assert(memcmp(v.data, "e41d981864", 10UL) == 0); | |
| v = intmap_lookup(im2, 2625011179408469742UL); | |
| assert(!intmap_lookup(im2, 2625011179408469742UL).present); | |
| v = intmap_lookup(im52, 1UL); | |
| assert(!intmap_lookup(im52, 1UL).present); | |
| v = intmap_lookup(im60, 2UL); | |
| assert(!intmap_lookup(im60, 2UL).present); | |
| v = intmap_lookup(im45, 5582676968255673461UL); | |
| assert(!intmap_lookup(im45, 5582676968255673461UL).present); | |
| v = intmap_lookup(im36, 13443926201081858053UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "29", 2UL) == 0); | |
| intmap_release(a, im1); | |
| v = intmap_lookup(im58, 14490036593423678000UL); | |
| assert(!intmap_lookup(im58, 14490036593423678000UL).present); | |
| v = intmap_lookup(im20, 2625011179408469742UL); | |
| assert(!intmap_lookup(im20, 2625011179408469742UL).present); | |
| v = intmap_lookup(im4, 14490036593423678000UL); | |
| assert(!intmap_lookup(im4, 14490036593423678000UL).present); | |
| v = intmap_lookup(im15, 761643042849108716UL); | |
| assert(!intmap_lookup(im15, 761643042849108716UL).present); | |
| v = intmap_lookup(NULL, 2UL); | |
| assert(!intmap_lookup(NULL, 2UL).present); | |
| v = intmap_lookup(im17, 14056152219443060652UL); | |
| assert(!intmap_lookup(im17, 14056152219443060652UL).present); | |
| intmap_release(a, im17); | |
| v = intmap_lookup(im31, 13443926201081858053UL); | |
| assert(!intmap_lookup(im31, 13443926201081858053UL).present); | |
| v = intmap_lookup(im5, 7UL); | |
| assert(!intmap_lookup(im5, 7UL).present); | |
| v = intmap_lookup(NULL, 13443926201081858053UL); | |
| assert(!intmap_lookup(NULL, 13443926201081858053UL).present); | |
| v = intmap_lookup(NULL, 13443926201081858053UL); | |
| assert(!intmap_lookup(NULL, 13443926201081858053UL).present); | |
| v = intmap_lookup(im24, 0UL); | |
| assert(!intmap_lookup(im24, 0UL).present); | |
| v = intmap_lookup(im26, 2UL); | |
| assert(!intmap_lookup(im26, 2UL).present); | |
| v = intmap_lookup(im14, 12UL); | |
| assert(!intmap_lookup(im14, 12UL).present); | |
| v = intmap_lookup(NULL, 5UL); | |
| assert(!intmap_lookup(NULL, 5UL).present); | |
| v = intmap_lookup(im27, 2UL); | |
| assert(!intmap_lookup(im27, 2UL).present); | |
| v = intmap_lookup(im72, 13443926201081858053UL); | |
| assert(!intmap_lookup(im72, 13443926201081858053UL).present); | |
| intmap_release(a, im34); | |
| v = intmap_lookup(im32, 1UL); | |
| assert(!intmap_lookup(im32, 1UL).present); | |
| v = intmap_lookup(im14, 761643042849108716UL); | |
| assert(!intmap_lookup(im14, 761643042849108716UL).present); | |
| v = intmap_lookup(im29, 14490036593423678000UL); | |
| assert(!intmap_lookup(im29, 14490036593423678000UL).present); | |
| v = intmap_lookup(im32, 5UL); | |
| assert(!intmap_lookup(im32, 5UL).present); | |
| v = intmap_lookup(im31, 17743437528680141472UL); | |
| assert(!intmap_lookup(im31, 17743437528680141472UL).present); | |
| v = intmap_lookup(im43, 2667557012157109398UL); | |
| assert(v.present); | |
| assert(v.length == 8UL); | |
| assert(memcmp(v.data, "8d54a229", 8UL) == 0); | |
| v = intmap_lookup(im68, 2UL); | |
| assert(v.present); | |
| assert(v.length == 10UL); | |
| assert(memcmp(v.data, "d39ea5b710", 10UL) == 0); | |
| v = intmap_lookup(im71, 3973737261736073657UL); | |
| assert(!intmap_lookup(im71, 3973737261736073657UL).present); | |
| v = intmap_lookup(im16, 14490036593423678000UL); | |
| assert(!intmap_lookup(im16, 14490036593423678000UL).present); | |
| v = intmap_lookup(im65, 3UL); | |
| assert(!intmap_lookup(im65, 3UL).present); | |
| v = intmap_lookup(im62, 2667557012157109398UL); | |
| assert(!intmap_lookup(im62, 2667557012157109398UL).present); | |
| v = intmap_lookup(im64, 2667557012157109398UL); | |
| assert(!intmap_lookup(im64, 2667557012157109398UL).present); | |
| v = intmap_lookup(im64, 14490036593423678000UL); | |
| assert(!intmap_lookup(im64, 14490036593423678000UL).present); | |
| v = intmap_lookup(im53, 14490036593423678000UL); | |
| assert(!intmap_lookup(im53, 14490036593423678000UL).present); | |
| v = intmap_lookup(NULL, 761643042849108716UL); | |
| assert(!intmap_lookup(NULL, 761643042849108716UL).present); | |
| v = intmap_lookup(im23, 0UL); | |
| assert(!intmap_lookup(im23, 0UL).present); | |
| v = intmap_lookup(im30, 1719961386867278059UL); | |
| assert(!intmap_lookup(im30, 1719961386867278059UL).present); | |
| v = intmap_lookup(im10, 761643042849108716UL); | |
| assert(!intmap_lookup(im10, 761643042849108716UL).present); | |
| v = intmap_lookup(im48, 14490036593423678000UL); | |
| assert(!intmap_lookup(im48, 14490036593423678000UL).present); | |
| v = intmap_lookup(im54, 14490036593423678000UL); | |
| assert(!intmap_lookup(im54, 14490036593423678000UL).present); | |
| v = intmap_lookup(im5, 1UL); | |
| assert(!intmap_lookup(im5, 1UL).present); | |
| v = intmap_lookup(im75, 8491119848656777675UL); | |
| assert(!intmap_lookup(im75, 8491119848656777675UL).present); | |
| v = intmap_lookup(im60, 17716769152692975850UL); | |
| assert(!intmap_lookup(im60, 17716769152692975850UL).present); | |
| v = intmap_lookup(im15, 13585389843606685573UL); | |
| assert(!intmap_lookup(im15, 13585389843606685573UL).present); | |
| v = intmap_lookup(im25, 8UL); | |
| assert(!intmap_lookup(im25, 8UL).present); | |
| v = intmap_lookup(im18, 2625011179408469742UL); | |
| assert(!intmap_lookup(im18, 2625011179408469742UL).present); | |
| v = intmap_lookup(im22, 0UL); | |
| assert(!intmap_lookup(im22, 0UL).present); | |
| v = intmap_lookup(im49, 5UL); | |
| assert(!intmap_lookup(im49, 5UL).present); | |
| v = intmap_lookup(NULL, 14490036593423678000UL); | |
| assert(!intmap_lookup(NULL, 14490036593423678000UL).present); | |
| v = intmap_lookup(im2, 4095538859707777541UL); | |
| assert(!intmap_lookup(im2, 4095538859707777541UL).present); | |
| v = intmap_lookup(im25, 6908423511154868808UL); | |
| assert(!intmap_lookup(im25, 6908423511154868808UL).present); | |
| v = intmap_lookup(im9, 14490036593423678000UL); | |
| assert(!intmap_lookup(im9, 14490036593423678000UL).present); | |
| v = intmap_lookup(im59, 761643042849108716UL); | |
| assert(!intmap_lookup(im59, 761643042849108716UL).present); | |
| v = intmap_lookup(NULL, 13443926201081858053UL); | |
| assert(!intmap_lookup(NULL, 13443926201081858053UL).present); | |
| v = intmap_lookup(NULL, 14490036593423678000UL); | |
| assert(!intmap_lookup(NULL, 14490036593423678000UL).present); | |
| v = intmap_lookup(im2, 5UL); | |
| assert(v.present); | |
| assert(v.length == 10UL); | |
| assert(memcmp(v.data, "89eaa69a8f", 10UL) == 0); | |
| v = intmap_lookup(im15, 2667557012157109398UL); | |
| assert(!intmap_lookup(im15, 2667557012157109398UL).present); | |
| v = intmap_lookup(im43, 2667557012157109398UL); | |
| assert(v.present); | |
| assert(v.length == 8UL); | |
| assert(memcmp(v.data, "8d54a229", 8UL) == 0); | |
| v = intmap_lookup(im69, 5UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "0a", 2UL) == 0); | |
| v = intmap_lookup(im43, 3016833216084111225UL); | |
| assert(!intmap_lookup(im43, 3016833216084111225UL).present); | |
| v = intmap_lookup(im48, 2UL); | |
| assert(!intmap_lookup(im48, 2UL).present); | |
| v = intmap_lookup(NULL, 2625011179408469742UL); | |
| assert(!intmap_lookup(NULL, 2625011179408469742UL).present); | |
| v = intmap_lookup(im32, 5UL); | |
| assert(!intmap_lookup(im32, 5UL).present); | |
| v = intmap_lookup(NULL, 5UL); | |
| assert(!intmap_lookup(NULL, 5UL).present); | |
| v = intmap_lookup(NULL, 761643042849108716UL); | |
| assert(!intmap_lookup(NULL, 761643042849108716UL).present); | |
| v = intmap_lookup(im68, 5UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "0a", 2UL) == 0); | |
| v = intmap_lookup(im44, 2625011179408469742UL); | |
| assert(!intmap_lookup(im44, 2625011179408469742UL).present); | |
| v = intmap_lookup(im48, 5UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "0a", 2UL) == 0); | |
| v = intmap_lookup(im69, 4UL); | |
| assert(!intmap_lookup(im69, 4UL).present); | |
| v = intmap_lookup(NULL, 11UL); | |
| assert(!intmap_lookup(NULL, 11UL).present); | |
| v = intmap_lookup(im11, 2UL); | |
| assert(!intmap_lookup(im11, 2UL).present); | |
| v = intmap_lookup(im63, 11UL); | |
| assert(!intmap_lookup(im63, 11UL).present); | |
| v = intmap_lookup(im45, 2UL); | |
| assert(v.present); | |
| assert(v.length == 10UL); | |
| assert(memcmp(v.data, "d39ea5b710", 10UL) == 0); | |
| v = intmap_lookup(im60, 21UL); | |
| assert(!intmap_lookup(im60, 21UL).present); | |
| v = intmap_lookup(NULL, 13443926201081858053UL); | |
| assert(!intmap_lookup(NULL, 13443926201081858053UL).present); | |
| v = intmap_lookup(im26, 2UL); | |
| assert(!intmap_lookup(im26, 2UL).present); | |
| v = intmap_lookup(im58, 8783497840351016784UL); | |
| assert(!intmap_lookup(im58, 8783497840351016784UL).present); | |
| v = intmap_lookup(im63, 2UL); | |
| assert(!intmap_lookup(im63, 2UL).present); | |
| v = intmap_lookup(im62, 761643042849108716UL); | |
| assert(!intmap_lookup(im62, 761643042849108716UL).present); | |
| v = intmap_lookup(im19, 2625011179408469742UL); | |
| assert(!intmap_lookup(im19, 2625011179408469742UL).present); | |
| v = intmap_lookup(im18, 2UL); | |
| assert(!intmap_lookup(im18, 2UL).present); | |
| v = intmap_lookup(NULL, 11582970618516751662UL); | |
| assert(!intmap_lookup(NULL, 11582970618516751662UL).present); | |
| v = intmap_lookup(NULL, 5UL); | |
| assert(!intmap_lookup(NULL, 5UL).present); | |
| v = intmap_lookup(im48, 761643042849108716UL); | |
| assert(!intmap_lookup(im48, 761643042849108716UL).present); | |
| v = intmap_lookup(im9, 761643042849108716UL); | |
| assert(!intmap_lookup(im9, 761643042849108716UL).present); | |
| v = intmap_lookup(im2, 11UL); | |
| assert(!intmap_lookup(im2, 11UL).present); | |
| v = intmap_lookup(im72, 3UL); | |
| assert(!intmap_lookup(im72, 3UL).present); | |
| v = intmap_lookup(im60, 2667557012157109398UL); | |
| assert(!intmap_lookup(im60, 2667557012157109398UL).present); | |
| v = intmap_lookup(im27, 13443926201081858053UL); | |
| assert(!intmap_lookup(im27, 13443926201081858053UL).present); | |
| v = intmap_lookup(NULL, 2UL); | |
| assert(!intmap_lookup(NULL, 2UL).present); | |
| v = intmap_lookup(NULL, 761643042849108716UL); | |
| assert(!intmap_lookup(NULL, 761643042849108716UL).present); | |
| v = intmap_lookup(im21, 13443926201081858053UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "29", 2UL) == 0); | |
| intmap_release(a, im36); | |
| v = intmap_lookup(im24, 2UL); | |
| assert(v.present); | |
| assert(v.length == 10UL); | |
| assert(memcmp(v.data, "d39ea5b710", 10UL) == 0); | |
| v = intmap_lookup(im70, 2UL); | |
| assert(!intmap_lookup(im70, 2UL).present); | |
| v = intmap_lookup(im23, 0UL); | |
| assert(!intmap_lookup(im23, 0UL).present); | |
| v = intmap_lookup(im43, 13443926201081858053UL); | |
| assert(!intmap_lookup(im43, 13443926201081858053UL).present); | |
| v = intmap_lookup(im69, 7UL); | |
| assert(!intmap_lookup(im69, 7UL).present); | |
| v = intmap_lookup(im24, 2625011179408469742UL); | |
| assert(!intmap_lookup(im24, 2625011179408469742UL).present); | |
| v = intmap_lookup(im25, 6UL); | |
| assert(!intmap_lookup(im25, 6UL).present); | |
| v = intmap_lookup(im52, 2625011179408469742UL); | |
| assert(!intmap_lookup(im52, 2625011179408469742UL).present); | |
| v = intmap_lookup(im4, 17UL); | |
| assert(!intmap_lookup(im4, 17UL).present); | |
| v = intmap_lookup(im24, 14341061672941475318UL); | |
| assert(!intmap_lookup(im24, 14341061672941475318UL).present); | |
| v = intmap_lookup(im16, 14490036593423678000UL); | |
| assert(!intmap_lookup(im16, 14490036593423678000UL).present); | |
| v = intmap_lookup(im61, 2UL); | |
| assert(!intmap_lookup(im61, 2UL).present); | |
| v = intmap_lookup(im9, 2UL); | |
| assert(!intmap_lookup(im9, 2UL).present); | |
| v = intmap_lookup(im24, 1UL); | |
| assert(!intmap_lookup(im24, 1UL).present); | |
| v = intmap_lookup(im20, 22UL); | |
| assert(!intmap_lookup(im20, 22UL).present); | |
| v = intmap_lookup(im57, 2625011179408469742UL); | |
| assert(!intmap_lookup(im57, 2625011179408469742UL).present); | |
| v = intmap_lookup(im53, 2625011179408469742UL); | |
| assert(!intmap_lookup(im53, 2625011179408469742UL).present); | |
| intmap_release(a, im20); | |
| intmap_release(a, im58); | |
| v = intmap_lookup(im10, 10UL); | |
| assert(!intmap_lookup(im10, 10UL).present); | |
| v = intmap_lookup(im60, 2667557012157109398UL); | |
| assert(!intmap_lookup(im60, 2667557012157109398UL).present); | |
| v = intmap_lookup(im24, 8UL); | |
| assert(!intmap_lookup(im24, 8UL).present); | |
| v = intmap_lookup(im25, 1UL); | |
| assert(!intmap_lookup(im25, 1UL).present); | |
| v = intmap_lookup(im32, 13443926201081858053UL); | |
| assert(!intmap_lookup(im32, 13443926201081858053UL).present); | |
| intmap_release(a, im33); | |
| v = intmap_lookup(im18, 2625011179408469742UL); | |
| assert(!intmap_lookup(im18, 2625011179408469742UL).present); | |
| intmap_release(a, im59); | |
| v = intmap_lookup(im44, 17716769152692975850UL); | |
| assert(!intmap_lookup(im44, 17716769152692975850UL).present); | |
| v = intmap_lookup(im29, 761643042849108716UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "59", 2UL) == 0); | |
| v = intmap_lookup(im27, 14490036593423678000UL); | |
| assert(!intmap_lookup(im27, 14490036593423678000UL).present); | |
| v = intmap_lookup(im66, 761643042849108716UL); | |
| assert(!intmap_lookup(im66, 761643042849108716UL).present); | |
| v = intmap_lookup(im44, 2667557012157109398UL); | |
| assert(!intmap_lookup(im44, 2667557012157109398UL).present); | |
| v = intmap_lookup(NULL, 2UL); | |
| assert(!intmap_lookup(NULL, 2UL).present); | |
| v = intmap_lookup(NULL, 2UL); | |
| assert(!intmap_lookup(NULL, 2UL).present); | |
| v = intmap_lookup(im29, 5UL); | |
| assert(!intmap_lookup(im29, 5UL).present); | |
| v = intmap_lookup(im72, 17716769152692975850UL); | |
| assert(!intmap_lookup(im72, 17716769152692975850UL).present); | |
| v = intmap_lookup(im69, 0UL); | |
| assert(!intmap_lookup(im69, 0UL).present); | |
| v = intmap_lookup(im68, 6UL); | |
| assert(!intmap_lookup(im68, 6UL).present); | |
| v = intmap_lookup(NULL, 2UL); | |
| assert(!intmap_lookup(NULL, 2UL).present); | |
| v = intmap_lookup(im18, 10095117624957976436UL); | |
| assert(!intmap_lookup(im18, 10095117624957976436UL).present); | |
| v = intmap_lookup(im27, 761643042849108716UL); | |
| assert(!intmap_lookup(im27, 761643042849108716UL).present); | |
| v = intmap_lookup(im23, 14490036593423678000UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "22", 2UL) == 0); | |
| v = intmap_lookup(im24, 2625011179408469742UL); | |
| assert(!intmap_lookup(im24, 2625011179408469742UL).present); | |
| v = intmap_lookup(im4, 5UL); | |
| assert(!intmap_lookup(im4, 5UL).present); | |
| v = intmap_lookup(im45, 7UL); | |
| assert(!intmap_lookup(im45, 7UL).present); | |
| v = intmap_lookup(im26, 17716769152692975850UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "2a", 2UL) == 0); | |
| v = intmap_lookup(NULL, 6408817792940759397UL); | |
| assert(!intmap_lookup(NULL, 6408817792940759397UL).present); | |
| v = intmap_lookup(im21, 1623805451390962753UL); | |
| assert(!intmap_lookup(im21, 1623805451390962753UL).present); | |
| intmap_release(a, im18); | |
| v = intmap_lookup(im26, 761643042849108716UL); | |
| assert(!intmap_lookup(im26, 761643042849108716UL).present); | |
| v = intmap_lookup(im60, 1UL); | |
| assert(!intmap_lookup(im60, 1UL).present); | |
| v = intmap_lookup(im4, 761643042849108716UL); | |
| assert(!intmap_lookup(im4, 761643042849108716UL).present); | |
| v = intmap_lookup(im75, 5UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "0a", 2UL) == 0); | |
| v = intmap_lookup(im44, 12107006626835524755UL); | |
| assert(!intmap_lookup(im44, 12107006626835524755UL).present); | |
| v = intmap_lookup(im68, 2UL); | |
| assert(v.present); | |
| assert(v.length == 10UL); | |
| assert(memcmp(v.data, "d39ea5b710", 10UL) == 0); | |
| v = intmap_lookup(im39, 17716769152692975850UL); | |
| assert(!intmap_lookup(im39, 17716769152692975850UL).present); | |
| v = intmap_lookup(im69, 934657362791149169UL); | |
| assert(!intmap_lookup(im69, 934657362791149169UL).present); | |
| v = intmap_lookup(im22, 14490036593423678000UL); | |
| assert(!intmap_lookup(im22, 14490036593423678000UL).present); | |
| v = intmap_lookup(NULL, 17716769152692975850UL); | |
| assert(!intmap_lookup(NULL, 17716769152692975850UL).present); | |
| v = intmap_lookup(NULL, 5UL); | |
| assert(!intmap_lookup(NULL, 5UL).present); | |
| v = intmap_lookup(NULL, 16239844001957072469UL); | |
| assert(!intmap_lookup(NULL, 16239844001957072469UL).present); | |
| v = intmap_lookup(im15, 2625011179408469742UL); | |
| assert(!intmap_lookup(im15, 2625011179408469742UL).present); | |
| v = intmap_lookup(NULL, 2UL); | |
| assert(!intmap_lookup(NULL, 2UL).present); | |
| v = intmap_lookup(im48, 0UL); | |
| assert(!intmap_lookup(im48, 0UL).present); | |
| v = intmap_lookup(im57, 7749207423641136407UL); | |
| assert(!intmap_lookup(im57, 7749207423641136407UL).present); | |
| v = intmap_lookup(im48, 14490036593423678000UL); | |
| assert(!intmap_lookup(im48, 14490036593423678000UL).present); | |
| v = intmap_lookup(im43, 761643042849108716UL); | |
| assert(!intmap_lookup(im43, 761643042849108716UL).present); | |
| v = intmap_lookup(im65, 13458199732572215188UL); | |
| assert(!intmap_lookup(im65, 13458199732572215188UL).present); | |
| v = intmap_lookup(im10, 2625011179408469742UL); | |
| assert(!intmap_lookup(im10, 2625011179408469742UL).present); | |
| v = intmap_lookup(im27, 10301085342062431973UL); | |
| assert(!intmap_lookup(im27, 10301085342062431973UL).present); | |
| v = intmap_lookup(im60, 15UL); | |
| assert(!intmap_lookup(im60, 15UL).present); | |
| intmap_release(a, im5); | |
| v = intmap_lookup(im73, 17716769152692975850UL); | |
| assert(v.present); | |
| assert(v.length == 6UL); | |
| assert(memcmp(v.data, "8c310b", 6UL) == 0); | |
| v = intmap_lookup(im9, 14490036593423678000UL); | |
| assert(!intmap_lookup(im9, 14490036593423678000UL).present); | |
| v = intmap_lookup(NULL, 761643042849108716UL); | |
| assert(!intmap_lookup(NULL, 761643042849108716UL).present); | |
| v = intmap_lookup(im70, 2667557012157109398UL); | |
| assert(!intmap_lookup(im70, 2667557012157109398UL).present); | |
| v = intmap_lookup(im64, 8369721382407396639UL); | |
| assert(!intmap_lookup(im64, 8369721382407396639UL).present); | |
| v = intmap_lookup(NULL, 23UL); | |
| assert(!intmap_lookup(NULL, 23UL).present); | |
| v = intmap_lookup(im64, 17716769152692975850UL); | |
| assert(!intmap_lookup(im64, 17716769152692975850UL).present); | |
| v = intmap_lookup(im22, 14490036593423678000UL); | |
| assert(!intmap_lookup(im22, 14490036593423678000UL).present); | |
| v = intmap_lookup(im21, 14490036593423678000UL); | |
| assert(!intmap_lookup(im21, 14490036593423678000UL).present); | |
| v = intmap_lookup(im73, 2UL); | |
| assert(!intmap_lookup(im73, 2UL).present); | |
| v = intmap_lookup(im25, 2625011179408469742UL); | |
| assert(!intmap_lookup(im25, 2625011179408469742UL).present); | |
| v = intmap_lookup(NULL, 13757798915154124380UL); | |
| assert(!intmap_lookup(NULL, 13757798915154124380UL).present); | |
| v = intmap_lookup(im49, 761643042849108716UL); | |
| assert(!intmap_lookup(im49, 761643042849108716UL).present); | |
| v = intmap_lookup(im63, 17716769152692975850UL); | |
| assert(!intmap_lookup(im63, 17716769152692975850UL).present); | |
| v = intmap_lookup(NULL, 14490036593423678000UL); | |
| assert(!intmap_lookup(NULL, 14490036593423678000UL).present); | |
| v = intmap_lookup(im30, 2625011179408469742UL); | |
| assert(!intmap_lookup(im30, 2625011179408469742UL).present); | |
| v = intmap_lookup(im73, 13789602635394125333UL); | |
| assert(!intmap_lookup(im73, 13789602635394125333UL).present); | |
| v = intmap_lookup(im54, 2UL); | |
| assert(!intmap_lookup(im54, 2UL).present); | |
| v = intmap_lookup(im62, 761643042849108716UL); | |
| assert(!intmap_lookup(im62, 761643042849108716UL).present); | |
| v = intmap_lookup(im71, 10UL); | |
| assert(!intmap_lookup(im71, 10UL).present); | |
| v = intmap_lookup(im9, 6UL); | |
| assert(!intmap_lookup(im9, 6UL).present); | |
| v = intmap_lookup(im53, 14490036593423678000UL); | |
| assert(!intmap_lookup(im53, 14490036593423678000UL).present); | |
| v = intmap_lookup(NULL, 14490036593423678000UL); | |
| assert(!intmap_lookup(NULL, 14490036593423678000UL).present); | |
| v = intmap_lookup(im75, 13443926201081858053UL); | |
| assert(!intmap_lookup(im75, 13443926201081858053UL).present); | |
| v = intmap_lookup(im44, 2625011179408469742UL); | |
| assert(!intmap_lookup(im44, 2625011179408469742UL).present); | |
| v = intmap_lookup(NULL, 17716769152692975850UL); | |
| assert(!intmap_lookup(NULL, 17716769152692975850UL).present); | |
| v = intmap_lookup(NULL, 14490036593423678000UL); | |
| assert(!intmap_lookup(NULL, 14490036593423678000UL).present); | |
| intmap_release(a, im63); | |
| intmap_release(a, im64); | |
| v = intmap_lookup(im40, 14167217241423239858UL); | |
| assert(!intmap_lookup(im40, 14167217241423239858UL).present); | |
| v = intmap_lookup(NULL, 17716769152692975850UL); | |
| assert(!intmap_lookup(NULL, 17716769152692975850UL).present); | |
| v = intmap_lookup(im69, 12231282134180097266UL); | |
| assert(!intmap_lookup(im69, 12231282134180097266UL).present); | |
| v = intmap_lookup(im15, 13443926201081858053UL); | |
| assert(!intmap_lookup(im15, 13443926201081858053UL).present); | |
| v = intmap_lookup(NULL, 7483250776666118123UL); | |
| assert(!intmap_lookup(NULL, 7483250776666118123UL).present); | |
| intmap_release(a, im9); | |
| v = intmap_lookup(im15, 761643042849108716UL); | |
| assert(!intmap_lookup(im15, 761643042849108716UL).present); | |
| v = intmap_lookup(NULL, 17UL); | |
| assert(!intmap_lookup(NULL, 17UL).present); | |
| v = intmap_lookup(im49, 9UL); | |
| assert(!intmap_lookup(im49, 9UL).present); | |
| v = intmap_lookup(NULL, 13443926201081858053UL); | |
| assert(!intmap_lookup(NULL, 13443926201081858053UL).present); | |
| v = intmap_lookup(im61, 10UL); | |
| assert(!intmap_lookup(im61, 10UL).present); | |
| v = intmap_lookup(im29, 2625011179408469742UL); | |
| assert(!intmap_lookup(im29, 2625011179408469742UL).present); | |
| v = intmap_lookup(im68, 17716769152692975850UL); | |
| assert(!intmap_lookup(im68, 17716769152692975850UL).present); | |
| v = intmap_lookup(im44, 3UL); | |
| assert(!intmap_lookup(im44, 3UL).present); | |
| v = intmap_lookup(im10, 2667557012157109398UL); | |
| assert(!intmap_lookup(im10, 2667557012157109398UL).present); | |
| intmap_release(a, im25); | |
| v = intmap_lookup(im53, 1UL); | |
| assert(!intmap_lookup(im53, 1UL).present); | |
| v = intmap_lookup(NULL, 11054579238276653116UL); | |
| assert(!intmap_lookup(NULL, 11054579238276653116UL).present); | |
| v = intmap_lookup(NULL, 13443926201081858053UL); | |
| assert(!intmap_lookup(NULL, 13443926201081858053UL).present); | |
| v = intmap_lookup(im27, 17UL); | |
| assert(!intmap_lookup(im27, 17UL).present); | |
| v = intmap_lookup(im71, 5UL); | |
| assert(!intmap_lookup(im71, 5UL).present); | |
| v = intmap_lookup(im61, 13443926201081858053UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "29", 2UL) == 0); | |
| v = intmap_lookup(im72, 12988533909527467655UL); | |
| assert(!intmap_lookup(im72, 12988533909527467655UL).present); | |
| v = intmap_lookup(im72, 3644486824577494466UL); | |
| assert(!intmap_lookup(im72, 3644486824577494466UL).present); | |
| v = intmap_lookup(im30, 2625011179408469742UL); | |
| assert(!intmap_lookup(im30, 2625011179408469742UL).present); | |
| v = intmap_lookup(NULL, 11599761622167304902UL); | |
| assert(!intmap_lookup(NULL, 11599761622167304902UL).present); | |
| v = intmap_lookup(NULL, 16040425760594115102UL); | |
| assert(!intmap_lookup(NULL, 16040425760594115102UL).present); | |
| v = intmap_lookup(im70, 2UL); | |
| assert(!intmap_lookup(im70, 2UL).present); | |
| v = intmap_lookup(NULL, 2UL); | |
| assert(!intmap_lookup(NULL, 2UL).present); | |
| v = intmap_lookup(im72, 5UL); | |
| assert(!intmap_lookup(im72, 5UL).present); | |
| v = intmap_lookup(NULL, 3258993975640234929UL); | |
| assert(!intmap_lookup(NULL, 3258993975640234929UL).present); | |
| v = intmap_lookup(NULL, 2625011179408469742UL); | |
| assert(!intmap_lookup(NULL, 2625011179408469742UL).present); | |
| v = intmap_lookup(im37, 14490036593423678000UL); | |
| assert(!intmap_lookup(im37, 14490036593423678000UL).present); | |
| intmap_release(a, im14); | |
| v = intmap_lookup(im57, 7415840125736805681UL); | |
| assert(!intmap_lookup(im57, 7415840125736805681UL).present); | |
| v = intmap_lookup(im65, 520062007339009264UL); | |
| assert(!intmap_lookup(im65, 520062007339009264UL).present); | |
| v = intmap_lookup(im39, 761643042849108716UL); | |
| assert(!intmap_lookup(im39, 761643042849108716UL).present); | |
| v = intmap_lookup(NULL, 5UL); | |
| assert(!intmap_lookup(NULL, 5UL).present); | |
| v = intmap_lookup(im2, 17716769152692975850UL); | |
| assert(!intmap_lookup(im2, 17716769152692975850UL).present); | |
| v = intmap_lookup(im48, 14490036593423678000UL); | |
| assert(!intmap_lookup(im48, 14490036593423678000UL).present); | |
| v = intmap_lookup(im29, 761643042849108716UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "59", 2UL) == 0); | |
| v = intmap_lookup(im27, 14UL); | |
| assert(!intmap_lookup(im27, 14UL).present); | |
| v = intmap_lookup(NULL, 11675876539686806938UL); | |
| assert(!intmap_lookup(NULL, 11675876539686806938UL).present); | |
| v = intmap_lookup(im71, 2625011179408469742UL); | |
| assert(!intmap_lookup(im71, 2625011179408469742UL).present); | |
| v = intmap_lookup(im71, 15719525208129419506UL); | |
| assert(!intmap_lookup(im71, 15719525208129419506UL).present); | |
| v = intmap_lookup(im53, 761643042849108716UL); | |
| assert(!intmap_lookup(im53, 761643042849108716UL).present); | |
| v = intmap_lookup(im16, 5UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "0a", 2UL) == 0); | |
| v = intmap_lookup(im19, 3UL); | |
| assert(!intmap_lookup(im19, 3UL).present); | |
| v = intmap_lookup(im71, 2625011179408469742UL); | |
| assert(!intmap_lookup(im71, 2625011179408469742UL).present); | |
| v = intmap_lookup(im44, 5204186662257378397UL); | |
| assert(!intmap_lookup(im44, 5204186662257378397UL).present); | |
| v = intmap_lookup(im22, 2625011179408469742UL); | |
| assert(!intmap_lookup(im22, 2625011179408469742UL).present); | |
| v = intmap_lookup(im23, 6946558097083699489UL); | |
| assert(!intmap_lookup(im23, 6946558097083699489UL).present); | |
| v = intmap_lookup(im71, 5UL); | |
| assert(!intmap_lookup(im71, 5UL).present); | |
| v = intmap_lookup(im72, 29UL); | |
| assert(!intmap_lookup(im72, 29UL).present); | |
| v = intmap_lookup(im43, 13443926201081858053UL); | |
| assert(!intmap_lookup(im43, 13443926201081858053UL).present); | |
| intmap_release(a, im37); | |
| v = intmap_lookup(NULL, 3UL); | |
| assert(!intmap_lookup(NULL, 3UL).present); | |
| v = intmap_lookup(im70, 15635532690743660581UL); | |
| assert(!intmap_lookup(im70, 15635532690743660581UL).present); | |
| v = intmap_lookup(im22, 17716769152692975850UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "2a", 2UL) == 0); | |
| v = intmap_lookup(im23, 13UL); | |
| assert(!intmap_lookup(im23, 13UL).present); | |
| intmap_release(a, im26); | |
| v = intmap_lookup(im21, 2625011179408469742UL); | |
| assert(!intmap_lookup(im21, 2625011179408469742UL).present); | |
| v = intmap_lookup(im15, 761643042849108716UL); | |
| assert(!intmap_lookup(im15, 761643042849108716UL).present); | |
| v = intmap_lookup(im75, 2625011179408469742UL); | |
| assert(!intmap_lookup(im75, 2625011179408469742UL).present); | |
| v = intmap_lookup(NULL, 2625011179408469742UL); | |
| assert(!intmap_lookup(NULL, 2625011179408469742UL).present); | |
| v = intmap_lookup(im11, 13154798555298865936UL); | |
| assert(!intmap_lookup(im11, 13154798555298865936UL).present); | |
| v = intmap_lookup(im66, 5UL); | |
| assert(!intmap_lookup(im66, 5UL).present); | |
| v = intmap_lookup(im52, 2UL); | |
| assert(!intmap_lookup(im52, 2UL).present); | |
| v = intmap_lookup(im15, 10543781109006715687UL); | |
| assert(!intmap_lookup(im15, 10543781109006715687UL).present); | |
| v = intmap_lookup(im15, 18UL); | |
| assert(!intmap_lookup(im15, 18UL).present); | |
| v = intmap_lookup(im40, 2UL); | |
| assert(!intmap_lookup(im40, 2UL).present); | |
| v = intmap_lookup(im11, 5UL); | |
| assert(v.present); | |
| assert(v.length == 10UL); | |
| assert(memcmp(v.data, "e41d981864", 10UL) == 0); | |
| v = intmap_lookup(im27, 10622012607957130697UL); | |
| assert(!intmap_lookup(im27, 10622012607957130697UL).present); | |
| v = intmap_lookup(im21, 14513241929793164754UL); | |
| assert(!intmap_lookup(im21, 14513241929793164754UL).present); | |
| v = intmap_lookup(im72, 5UL); | |
| assert(!intmap_lookup(im72, 5UL).present); | |
| intmap_release(a, im70); | |
| v = intmap_lookup(NULL, 2625011179408469742UL); | |
| assert(!intmap_lookup(NULL, 2625011179408469742UL).present); | |
| v = intmap_lookup(NULL, 13443926201081858053UL); | |
| assert(!intmap_lookup(NULL, 13443926201081858053UL).present); | |
| v = intmap_lookup(im65, 14490036593423678000UL); | |
| assert(!intmap_lookup(im65, 14490036593423678000UL).present); | |
| v = intmap_lookup(im69, 2625011179408469742UL); | |
| assert(!intmap_lookup(im69, 2625011179408469742UL).present); | |
| v = intmap_lookup(im68, 8388963018843828026UL); | |
| assert(!intmap_lookup(im68, 8388963018843828026UL).present); | |
| intmap_release(a, im60); | |
| v = intmap_lookup(im39, 2667557012157109398UL); | |
| assert(v.present); | |
| assert(v.length == 8UL); | |
| assert(memcmp(v.data, "8d54a229", 8UL) == 0); | |
| v = intmap_lookup(im19, 2UL); | |
| assert(!intmap_lookup(im19, 2UL).present); | |
| v = intmap_lookup(im30, 14UL); | |
| assert(!intmap_lookup(im30, 14UL).present); | |
| v = intmap_lookup(NULL, 761643042849108716UL); | |
| assert(!intmap_lookup(NULL, 761643042849108716UL).present); | |
| v = intmap_lookup(im66, 13443926201081858053UL); | |
| assert(!intmap_lookup(im66, 13443926201081858053UL).present); | |
| v = intmap_lookup(im49, 6387021974525083051UL); | |
| assert(!intmap_lookup(im49, 6387021974525083051UL).present); | |
| v = intmap_lookup(im66, 2625011179408469742UL); | |
| assert(!intmap_lookup(im66, 2625011179408469742UL).present); | |
| v = intmap_lookup(im73, 5UL); | |
| assert(!intmap_lookup(im73, 5UL).present); | |
| v = intmap_lookup(im24, 8089170702621970011UL); | |
| assert(!intmap_lookup(im24, 8089170702621970011UL).present); | |
| v = intmap_lookup(NULL, 8769116552062386471UL); | |
| assert(!intmap_lookup(NULL, 8769116552062386471UL).present); | |
| v = intmap_lookup(NULL, 17716769152692975850UL); | |
| assert(!intmap_lookup(NULL, 17716769152692975850UL).present); | |
| v = intmap_lookup(NULL, 13443926201081858053UL); | |
| assert(!intmap_lookup(NULL, 13443926201081858053UL).present); | |
| v = intmap_lookup(im73, 11188273795231295893UL); | |
| assert(!intmap_lookup(im73, 11188273795231295893UL).present); | |
| v = intmap_lookup(im10, 2667557012157109398UL); | |
| assert(!intmap_lookup(im10, 2667557012157109398UL).present); | |
| v = intmap_lookup(im32, 13UL); | |
| assert(!intmap_lookup(im32, 13UL).present); | |
| v = intmap_lookup(im67, 2667557012157109398UL); | |
| assert(!intmap_lookup(im67, 2667557012157109398UL).present); | |
| v = intmap_lookup(NULL, 14490036593423678000UL); | |
| assert(!intmap_lookup(NULL, 14490036593423678000UL).present); | |
| v = intmap_lookup(im30, 4UL); | |
| assert(!intmap_lookup(im30, 4UL).present); | |
| v = intmap_lookup(im57, 17716769152692975850UL); | |
| assert(!intmap_lookup(im57, 17716769152692975850UL).present); | |
| v = intmap_lookup(NULL, 2UL); | |
| assert(!intmap_lookup(NULL, 2UL).present); | |
| v = intmap_lookup(im44, 14UL); | |
| assert(!intmap_lookup(im44, 14UL).present); | |
| v = intmap_lookup(im65, 14490036593423678000UL); | |
| assert(!intmap_lookup(im65, 14490036593423678000UL).present); | |
| intmap_release(a, im68); | |
| v = intmap_lookup(im23, 7784515780867128136UL); | |
| assert(!intmap_lookup(im23, 7784515780867128136UL).present); | |
| intmap_release(a, im30); | |
| intmap_release(a, im40); | |
| v = intmap_lookup(im72, 12808632006873538503UL); | |
| assert(!intmap_lookup(im72, 12808632006873538503UL).present); | |
| v = intmap_lookup(im73, 2667557012157109398UL); | |
| assert(v.present); | |
| assert(v.length == 8UL); | |
| assert(memcmp(v.data, "8d54a229", 8UL) == 0); | |
| v = intmap_lookup(im53, 17868893401682372101UL); | |
| assert(!intmap_lookup(im53, 17868893401682372101UL).present); | |
| v = intmap_lookup(im62, 2UL); | |
| assert(!intmap_lookup(im62, 2UL).present); | |
| v = intmap_lookup(im49, 10242229160369563586UL); | |
| assert(!intmap_lookup(im49, 10242229160369563586UL).present); | |
| v = intmap_lookup(im16, 2625011179408469742UL); | |
| assert(!intmap_lookup(im16, 2625011179408469742UL).present); | |
| v = intmap_lookup(im21, 14490036593423678000UL); | |
| assert(!intmap_lookup(im21, 14490036593423678000UL).present); | |
| v = intmap_lookup(im31, 761643042849108716UL); | |
| assert(!intmap_lookup(im31, 761643042849108716UL).present); | |
| v = intmap_lookup(NULL, 14490036593423678000UL); | |
| assert(!intmap_lookup(NULL, 14490036593423678000UL).present); | |
| v = intmap_lookup(im52, 2UL); | |
| assert(!intmap_lookup(im52, 2UL).present); | |
| v = intmap_lookup(im71, 7UL); | |
| assert(!intmap_lookup(im71, 7UL).present); | |
| v = intmap_lookup(im11, 17716769152692975850UL); | |
| assert(!intmap_lookup(im11, 17716769152692975850UL).present); | |
| v = intmap_lookup(im54, 14490036593423678000UL); | |
| assert(!intmap_lookup(im54, 14490036593423678000UL).present); | |
| v = intmap_lookup(NULL, 2UL); | |
| assert(!intmap_lookup(NULL, 2UL).present); | |
| v = intmap_lookup(im27, 14490036593423678000UL); | |
| assert(!intmap_lookup(im27, 14490036593423678000UL).present); | |
| v = intmap_lookup(im32, 14490036593423678000UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "22", 2UL) == 0); | |
| v = intmap_lookup(im75, 1UL); | |
| assert(!intmap_lookup(im75, 1UL).present); | |
| v = intmap_lookup(im16, 13443926201081858053UL); | |
| assert(!intmap_lookup(im16, 13443926201081858053UL).present); | |
| v = intmap_lookup(im45, 2UL); | |
| assert(v.present); | |
| assert(v.length == 10UL); | |
| assert(memcmp(v.data, "d39ea5b710", 10UL) == 0); | |
| v = intmap_lookup(im21, 17716769152692975850UL); | |
| assert(!intmap_lookup(im21, 17716769152692975850UL).present); | |
| v = intmap_lookup(im4, 3660437966495793491UL); | |
| assert(!intmap_lookup(im4, 3660437966495793491UL).present); | |
| v = intmap_lookup(im49, 7796951242401865102UL); | |
| assert(!intmap_lookup(im49, 7796951242401865102UL).present); | |
| v = intmap_lookup(im21, 2667557012157109398UL); | |
| assert(v.present); | |
| assert(v.length == 8UL); | |
| assert(memcmp(v.data, "8d54a229", 8UL) == 0); | |
| intmap_release(a, im53); | |
| v = intmap_lookup(im54, 9UL); | |
| assert(!intmap_lookup(im54, 9UL).present); | |
| v = intmap_lookup(im23, 20UL); | |
| assert(!intmap_lookup(im23, 20UL).present); | |
| v = intmap_lookup(NULL, 17329718120929121347UL); | |
| assert(!intmap_lookup(NULL, 17329718120929121347UL).present); | |
| v = intmap_lookup(im27, 13443926201081858053UL); | |
| assert(!intmap_lookup(im27, 13443926201081858053UL).present); | |
| v = intmap_lookup(im48, 0UL); | |
| assert(!intmap_lookup(im48, 0UL).present); | |
| v = intmap_lookup(NULL, 12727255238965682115UL); | |
| assert(!intmap_lookup(NULL, 12727255238965682115UL).present); | |
| v = intmap_lookup(im31, 392129687603842016UL); | |
| assert(!intmap_lookup(im31, 392129687603842016UL).present); | |
| v = intmap_lookup(im21, 13443926201081858053UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "29", 2UL) == 0); | |
| v = intmap_lookup(im11, 2UL); | |
| assert(!intmap_lookup(im11, 2UL).present); | |
| v = intmap_lookup(im39, 761643042849108716UL); | |
| assert(!intmap_lookup(im39, 761643042849108716UL).present); | |
| v = intmap_lookup(im10, 17397020305937619867UL); | |
| assert(!intmap_lookup(im10, 17397020305937619867UL).present); | |
| v = intmap_lookup(NULL, 0UL); | |
| assert(!intmap_lookup(NULL, 0UL).present); | |
| v = intmap_lookup(im24, 12688785804385754824UL); | |
| assert(!intmap_lookup(im24, 12688785804385754824UL).present); | |
| v = intmap_lookup(im62, 2625011179408469742UL); | |
| assert(!intmap_lookup(im62, 2625011179408469742UL).present); | |
| v = intmap_lookup(im65, 2667557012157109398UL); | |
| assert(!intmap_lookup(im65, 2667557012157109398UL).present); | |
| v = intmap_lookup(NULL, 13443926201081858053UL); | |
| assert(!intmap_lookup(NULL, 13443926201081858053UL).present); | |
| v = intmap_lookup(NULL, 7UL); | |
| assert(!intmap_lookup(NULL, 7UL).present); | |
| v = intmap_lookup(im65, 10138578171703371849UL); | |
| assert(!intmap_lookup(im65, 10138578171703371849UL).present); | |
| v = intmap_lookup(im52, 13443926201081858053UL); | |
| assert(!intmap_lookup(im52, 13443926201081858053UL).present); | |
| v = intmap_lookup(im4, 761643042849108716UL); | |
| assert(!intmap_lookup(im4, 761643042849108716UL).present); | |
| v = intmap_lookup(im66, 13UL); | |
| assert(!intmap_lookup(im66, 13UL).present); | |
| v = intmap_lookup(im11, 902698894453053800UL); | |
| assert(!intmap_lookup(im11, 902698894453053800UL).present); | |
| v = intmap_lookup(im61, 5080712115902580302UL); | |
| assert(!intmap_lookup(im61, 5080712115902580302UL).present); | |
| v = intmap_lookup(im23, 13443926201081858053UL); | |
| assert(!intmap_lookup(im23, 13443926201081858053UL).present); | |
| v = intmap_lookup(im39, 4UL); | |
| assert(!intmap_lookup(im39, 4UL).present); | |
| v = intmap_lookup(NULL, 13443926201081858053UL); | |
| assert(!intmap_lookup(NULL, 13443926201081858053UL).present); | |
| v = intmap_lookup(im29, 17597770373141627482UL); | |
| assert(!intmap_lookup(im29, 17597770373141627482UL).present); | |
| v = intmap_lookup(im44, 14490036593423678000UL); | |
| assert(!intmap_lookup(im44, 14490036593423678000UL).present); | |
| v = intmap_lookup(im45, 761643042849108716UL); | |
| assert(!intmap_lookup(im45, 761643042849108716UL).present); | |
| v = intmap_lookup(NULL, 14UL); | |
| assert(!intmap_lookup(NULL, 14UL).present); | |
| v = intmap_lookup(im62, 9552621019227773879UL); | |
| assert(!intmap_lookup(im62, 9552621019227773879UL).present); | |
| v = intmap_lookup(im62, 5UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "0a", 2UL) == 0); | |
| v = intmap_lookup(im10, 5UL); | |
| assert(v.present); | |
| assert(v.length == 4UL); | |
| assert(memcmp(v.data, "6b95", 4UL) == 0); | |
| v = intmap_lookup(im44, 1UL); | |
| assert(!intmap_lookup(im44, 1UL).present); | |
| v = intmap_lookup(im39, 13943945251130993349UL); | |
| assert(!intmap_lookup(im39, 13943945251130993349UL).present); | |
| v = intmap_lookup(im73, 5UL); | |
| assert(!intmap_lookup(im73, 5UL).present); | |
| v = intmap_lookup(im69, 2UL); | |
| assert(!intmap_lookup(im69, 2UL).present); | |
| v = intmap_lookup(im65, 761643042849108716UL); | |
| assert(!intmap_lookup(im65, 761643042849108716UL).present); | |
| v = intmap_lookup(im39, 12UL); | |
| assert(!intmap_lookup(im39, 12UL).present); | |
| v = intmap_lookup(im23, 3778820777491128237UL); | |
| assert(!intmap_lookup(im23, 3778820777491128237UL).present); | |
| v = intmap_lookup(im61, 5UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "0a", 2UL) == 0); | |
| v = intmap_lookup(im48, 17716769152692975850UL); | |
| assert(!intmap_lookup(im48, 17716769152692975850UL).present); | |
| v = intmap_lookup(im71, 761643042849108716UL); | |
| assert(!intmap_lookup(im71, 761643042849108716UL).present); | |
| v = intmap_lookup(im21, 2667557012157109398UL); | |
| assert(v.present); | |
| assert(v.length == 8UL); | |
| assert(memcmp(v.data, "8d54a229", 8UL) == 0); | |
| v = intmap_lookup(NULL, 5UL); | |
| assert(!intmap_lookup(NULL, 5UL).present); | |
| v = intmap_lookup(im75, 14490036593423678000UL); | |
| assert(!intmap_lookup(im75, 14490036593423678000UL).present); | |
| v = intmap_lookup(im49, 17716769152692975850UL); | |
| assert(!intmap_lookup(im49, 17716769152692975850UL).present); | |
| v = intmap_lookup(im72, 2667557012157109398UL); | |
| assert(!intmap_lookup(im72, 2667557012157109398UL).present); | |
| v = intmap_lookup(im72, 14490036593423678000UL); | |
| assert(!intmap_lookup(im72, 14490036593423678000UL).present); | |
| v = intmap_lookup(im48, 761643042849108716UL); | |
| assert(!intmap_lookup(im48, 761643042849108716UL).present); | |
| v = intmap_lookup(im43, 2667557012157109398UL); | |
| assert(v.present); | |
| assert(v.length == 8UL); | |
| assert(memcmp(v.data, "8d54a229", 8UL) == 0); | |
| v = intmap_lookup(im4, 6945907203634178209UL); | |
| assert(!intmap_lookup(im4, 6945907203634178209UL).present); | |
| v = intmap_lookup(im39, 761643042849108716UL); | |
| assert(!intmap_lookup(im39, 761643042849108716UL).present); | |
| v = intmap_lookup(im15, 2760296209578451457UL); | |
| assert(!intmap_lookup(im15, 2760296209578451457UL).present); | |
| v = intmap_lookup(im72, 14490036593423678000UL); | |
| assert(!intmap_lookup(im72, 14490036593423678000UL).present); | |
| v = intmap_lookup(im52, 5UL); | |
| assert(!intmap_lookup(im52, 5UL).present); | |
| v = intmap_lookup(im10, 13UL); | |
| assert(!intmap_lookup(im10, 13UL).present); | |
| v = intmap_lookup(im52, 3648442918744230529UL); | |
| assert(!intmap_lookup(im52, 3648442918744230529UL).present); | |
| v = intmap_lookup(im43, 761643042849108716UL); | |
| assert(!intmap_lookup(im43, 761643042849108716UL).present); | |
| v = intmap_lookup(im62, 3UL); | |
| assert(!intmap_lookup(im62, 3UL).present); | |
| v = intmap_lookup(NULL, 5860060533761321943UL); | |
| assert(!intmap_lookup(NULL, 5860060533761321943UL).present); | |
| v = intmap_lookup(im2, 4UL); | |
| assert(!intmap_lookup(im2, 4UL).present); | |
| v = intmap_lookup(im54, 2667557012157109398UL); | |
| assert(!intmap_lookup(im54, 2667557012157109398UL).present); | |
| v = intmap_lookup(im43, 2UL); | |
| assert(!intmap_lookup(im43, 2UL).present); | |
| intmap_release(a, im4); | |
| v = intmap_lookup(im10, 8UL); | |
| assert(!intmap_lookup(im10, 8UL).present); | |
| v = intmap_lookup(NULL, 12439087818260318625UL); | |
| assert(!intmap_lookup(NULL, 12439087818260318625UL).present); | |
| v = intmap_lookup(im67, 5UL); | |
| assert(!intmap_lookup(im67, 5UL).present); | |
| v = intmap_lookup(im69, 5UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "0a", 2UL) == 0); | |
| v = intmap_lookup(NULL, 13881750221271397893UL); | |
| assert(!intmap_lookup(NULL, 13881750221271397893UL).present); | |
| v = intmap_lookup(NULL, 14245461955155326131UL); | |
| assert(!intmap_lookup(NULL, 14245461955155326131UL).present); | |
| v = intmap_lookup(im67, 10475203017351618868UL); | |
| assert(!intmap_lookup(im67, 10475203017351618868UL).present); | |
| v = intmap_lookup(im49, 17716769152692975850UL); | |
| assert(!intmap_lookup(im49, 17716769152692975850UL).present); | |
| v = intmap_lookup(im44, 5UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "0a", 2UL) == 0); | |
| v = intmap_lookup(im44, 14490036593423678000UL); | |
| assert(!intmap_lookup(im44, 14490036593423678000UL).present); | |
| intmap_release(a, im2); | |
| v = intmap_lookup(im44, 8UL); | |
| assert(!intmap_lookup(im44, 8UL).present); | |
| v = intmap_lookup(im31, 2667557012157109398UL); | |
| assert(!intmap_lookup(im31, 2667557012157109398UL).present); | |
| v = intmap_lookup(im62, 505394196922335377UL); | |
| assert(!intmap_lookup(im62, 505394196922335377UL).present); | |
| v = intmap_lookup(im44, 761643042849108716UL); | |
| assert(!intmap_lookup(im44, 761643042849108716UL).present); | |
| v = intmap_lookup(im54, 14283647475954473668UL); | |
| assert(!intmap_lookup(im54, 14283647475954473668UL).present); | |
| v = intmap_lookup(im52, 5UL); | |
| assert(!intmap_lookup(im52, 5UL).present); | |
| v = intmap_lookup(im44, 13281102649572508263UL); | |
| assert(!intmap_lookup(im44, 13281102649572508263UL).present); | |
| v = intmap_lookup(im22, 2UL); | |
| assert(!intmap_lookup(im22, 2UL).present); | |
| intmap_release(a, im24); | |
| v = intmap_lookup(im75, 2625011179408469742UL); | |
| assert(!intmap_lookup(im75, 2625011179408469742UL).present); | |
| v = intmap_lookup(im48, 2870442575971189528UL); | |
| assert(!intmap_lookup(im48, 2870442575971189528UL).present); | |
| v = intmap_lookup(im61, 11630553185342387831UL); | |
| assert(!intmap_lookup(im61, 11630553185342387831UL).present); | |
| v = intmap_lookup(NULL, 761643042849108716UL); | |
| assert(!intmap_lookup(NULL, 761643042849108716UL).present); | |
| v = intmap_lookup(im32, 17716769152692975850UL); | |
| assert(!intmap_lookup(im32, 17716769152692975850UL).present); | |
| v = intmap_lookup(NULL, 2667557012157109398UL); | |
| assert(!intmap_lookup(NULL, 2667557012157109398UL).present); | |
| v = intmap_lookup(im61, 761643042849108716UL); | |
| assert(!intmap_lookup(im61, 761643042849108716UL).present); | |
| v = intmap_lookup(NULL, 14490036593423678000UL); | |
| assert(!intmap_lookup(NULL, 14490036593423678000UL).present); | |
| v = intmap_lookup(im21, 13443926201081858053UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "29", 2UL) == 0); | |
| intmap_release(a, im19); | |
| v = intmap_lookup(NULL, 10987730819205200470UL); | |
| assert(!intmap_lookup(NULL, 10987730819205200470UL).present); | |
| v = intmap_lookup(im54, 2667557012157109398UL); | |
| assert(!intmap_lookup(im54, 2667557012157109398UL).present); | |
| v = intmap_lookup(im29, 4UL); | |
| assert(!intmap_lookup(im29, 4UL).present); | |
| v = intmap_lookup(NULL, 9301517264394858208UL); | |
| assert(!intmap_lookup(NULL, 9301517264394858208UL).present); | |
| v = intmap_lookup(im16, 5UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "0a", 2UL) == 0); | |
| v = intmap_lookup(im31, 14490036593423678000UL); | |
| assert(!intmap_lookup(im31, 14490036593423678000UL).present); | |
| v = intmap_lookup(im10, 9UL); | |
| assert(!intmap_lookup(im10, 9UL).present); | |
| v = intmap_lookup(im75, 14490036593423678000UL); | |
| assert(!intmap_lookup(im75, 14490036593423678000UL).present); | |
| v = intmap_lookup(im45, 5UL); | |
| assert(v.present); | |
| assert(v.length == 10UL); | |
| assert(memcmp(v.data, "e41d981864", 10UL) == 0); | |
| v = intmap_lookup(im32, 5UL); | |
| assert(!intmap_lookup(im32, 5UL).present); | |
| v = intmap_lookup(NULL, 761643042849108716UL); | |
| assert(!intmap_lookup(NULL, 761643042849108716UL).present); | |
| v = intmap_lookup(im10, 16UL); | |
| assert(!intmap_lookup(im10, 16UL).present); | |
| v = intmap_lookup(im43, 4398391570340913855UL); | |
| assert(!intmap_lookup(im43, 4398391570340913855UL).present); | |
| v = intmap_lookup(im11, 4965008293307857804UL); | |
| assert(!intmap_lookup(im11, 4965008293307857804UL).present); | |
| v = intmap_lookup(im15, 2625011179408469742UL); | |
| assert(!intmap_lookup(im15, 2625011179408469742UL).present); | |
| v = intmap_lookup(im49, 2UL); | |
| assert(!intmap_lookup(im49, 2UL).present); | |
| v = intmap_lookup(NULL, 2UL); | |
| assert(!intmap_lookup(NULL, 2UL).present); | |
| v = intmap_lookup(im52, 17716769152692975850UL); | |
| assert(!intmap_lookup(im52, 17716769152692975850UL).present); | |
| v = intmap_lookup(im31, 14490036593423678000UL); | |
| assert(!intmap_lookup(im31, 14490036593423678000UL).present); | |
| v = intmap_lookup(im66, 2625011179408469742UL); | |
| assert(!intmap_lookup(im66, 2625011179408469742UL).present); | |
| v = intmap_lookup(NULL, 761643042849108716UL); | |
| assert(!intmap_lookup(NULL, 761643042849108716UL).present); | |
| v = intmap_lookup(im39, 17716769152692975850UL); | |
| assert(!intmap_lookup(im39, 17716769152692975850UL).present); | |
| v = intmap_lookup(im22, 2667557012157109398UL); | |
| assert(!intmap_lookup(im22, 2667557012157109398UL).present); | |
| v = intmap_lookup(im67, 17716769152692975850UL); | |
| assert(!intmap_lookup(im67, 17716769152692975850UL).present); | |
| v = intmap_lookup(im73, 2667557012157109398UL); | |
| assert(v.present); | |
| assert(v.length == 8UL); | |
| assert(memcmp(v.data, "8d54a229", 8UL) == 0); | |
| intmap_release(a, im27); | |
| v = intmap_lookup(im61, 38UL); | |
| assert(!intmap_lookup(im61, 38UL).present); | |
| v = intmap_lookup(im29, 14490036593423678000UL); | |
| assert(!intmap_lookup(im29, 14490036593423678000UL).present); | |
| v = intmap_lookup(im44, 13443926201081858053UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "29", 2UL) == 0); | |
| intmap_release(a, im49); | |
| v = intmap_lookup(im15, 2667557012157109398UL); | |
| assert(!intmap_lookup(im15, 2667557012157109398UL).present); | |
| v = intmap_lookup(im69, 761643042849108716UL); | |
| assert(!intmap_lookup(im69, 761643042849108716UL).present); | |
| v = intmap_lookup(im43, 2UL); | |
| assert(!intmap_lookup(im43, 2UL).present); | |
| v = intmap_lookup(im72, 8445503033989216879UL); | |
| assert(!intmap_lookup(im72, 8445503033989216879UL).present); | |
| v = intmap_lookup(im61, 8719641855465249783UL); | |
| assert(!intmap_lookup(im61, 8719641855465249783UL).present); | |
| v = intmap_lookup(im45, 13443926201081858053UL); | |
| assert(!intmap_lookup(im45, 13443926201081858053UL).present); | |
| v = intmap_lookup(NULL, 2667557012157109398UL); | |
| assert(!intmap_lookup(NULL, 2667557012157109398UL).present); | |
| intmap_release(a, im71); | |
| v = intmap_lookup(im44, 13443926201081858053UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "29", 2UL) == 0); | |
| v = intmap_lookup(im52, 2625011179408469742UL); | |
| assert(!intmap_lookup(im52, 2625011179408469742UL).present); | |
| v = intmap_lookup(NULL, 13UL); | |
| assert(!intmap_lookup(NULL, 13UL).present); | |
| v = intmap_lookup(NULL, 2667557012157109398UL); | |
| assert(!intmap_lookup(NULL, 2667557012157109398UL).present); | |
| v = intmap_lookup(NULL, 13679421577630897854UL); | |
| assert(!intmap_lookup(NULL, 13679421577630897854UL).present); | |
| v = intmap_lookup(im39, 6113585594820672157UL); | |
| assert(!intmap_lookup(im39, 6113585594820672157UL).present); | |
| v = intmap_lookup(im16, 2625011179408469742UL); | |
| assert(!intmap_lookup(im16, 2625011179408469742UL).present); | |
| v = intmap_lookup(im43, 1838008357909449363UL); | |
| assert(!intmap_lookup(im43, 1838008357909449363UL).present); | |
| v = intmap_lookup(im52, 17716769152692975850UL); | |
| assert(!intmap_lookup(im52, 17716769152692975850UL).present); | |
| v = intmap_lookup(NULL, 2667557012157109398UL); | |
| assert(!intmap_lookup(NULL, 2667557012157109398UL).present); | |
| v = intmap_lookup(NULL, 2625011179408469742UL); | |
| assert(!intmap_lookup(NULL, 2625011179408469742UL).present); | |
| v = intmap_lookup(im65, 14490036593423678000UL); | |
| assert(!intmap_lookup(im65, 14490036593423678000UL).present); | |
| v = intmap_lookup(im61, 761643042849108716UL); | |
| assert(!intmap_lookup(im61, 761643042849108716UL).present); | |
| v = intmap_lookup(NULL, 17716769152692975850UL); | |
| assert(!intmap_lookup(NULL, 17716769152692975850UL).present); | |
| v = intmap_lookup(im57, 1324508320432147553UL); | |
| assert(!intmap_lookup(im57, 1324508320432147553UL).present); | |
| v = intmap_lookup(NULL, 2625011179408469742UL); | |
| assert(!intmap_lookup(NULL, 2625011179408469742UL).present); | |
| v = intmap_lookup(im45, 2667557012157109398UL); | |
| assert(!intmap_lookup(im45, 2667557012157109398UL).present); | |
| v = intmap_lookup(im69, 3UL); | |
| assert(!intmap_lookup(im69, 3UL).present); | |
| v = intmap_lookup(im62, 14490036593423678000UL); | |
| assert(!intmap_lookup(im62, 14490036593423678000UL).present); | |
| v = intmap_lookup(im61, 5UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "0a", 2UL) == 0); | |
| v = intmap_lookup(im10, 3723379816916324443UL); | |
| assert(!intmap_lookup(im10, 3723379816916324443UL).present); | |
| v = intmap_lookup(im52, 15UL); | |
| assert(!intmap_lookup(im52, 15UL).present); | |
| v = intmap_lookup(im54, 14490036593423678000UL); | |
| assert(!intmap_lookup(im54, 14490036593423678000UL).present); | |
| v = intmap_lookup(im31, 17307368098945148504UL); | |
| assert(!intmap_lookup(im31, 17307368098945148504UL).present); | |
| v = intmap_lookup(im15, 28UL); | |
| assert(!intmap_lookup(im15, 28UL).present); | |
| intmap_release(a, im52); | |
| v = intmap_lookup(im11, 17716769152692975850UL); | |
| assert(!intmap_lookup(im11, 17716769152692975850UL).present); | |
| v = intmap_lookup(NULL, 2625011179408469742UL); | |
| assert(!intmap_lookup(NULL, 2625011179408469742UL).present); | |
| v = intmap_lookup(NULL, 4UL); | |
| assert(!intmap_lookup(NULL, 4UL).present); | |
| v = intmap_lookup(im21, 17716769152692975850UL); | |
| assert(!intmap_lookup(im21, 17716769152692975850UL).present); | |
| v = intmap_lookup(im29, 17716769152692975850UL); | |
| assert(!intmap_lookup(im29, 17716769152692975850UL).present); | |
| intmap_release(a, im16); | |
| v = intmap_lookup(im23, 2UL); | |
| assert(!intmap_lookup(im23, 2UL).present); | |
| v = intmap_lookup(im43, 13443926201081858053UL); | |
| assert(!intmap_lookup(im43, 13443926201081858053UL).present); | |
| v = intmap_lookup(im62, 5UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "0a", 2UL) == 0); | |
| v = intmap_lookup(im11, 13443926201081858053UL); | |
| assert(!intmap_lookup(im11, 13443926201081858053UL).present); | |
| v = intmap_lookup(im67, 761643042849108716UL); | |
| assert(!intmap_lookup(im67, 761643042849108716UL).present); | |
| v = intmap_lookup(im66, 13443926201081858053UL); | |
| assert(!intmap_lookup(im66, 13443926201081858053UL).present); | |
| v = intmap_lookup(im43, 11534520532222839593UL); | |
| assert(!intmap_lookup(im43, 11534520532222839593UL).present); | |
| v = intmap_lookup(im48, 761643042849108716UL); | |
| assert(!intmap_lookup(im48, 761643042849108716UL).present); | |
| v = intmap_lookup(im72, 2667557012157109398UL); | |
| assert(!intmap_lookup(im72, 2667557012157109398UL).present); | |
| intmap_release(a, im10); | |
| v = intmap_lookup(im39, 2625011179408469742UL); | |
| assert(!intmap_lookup(im39, 2625011179408469742UL).present); | |
| v = intmap_lookup(im75, 6UL); | |
| assert(!intmap_lookup(im75, 6UL).present); | |
| v = intmap_lookup(im62, 0UL); | |
| assert(!intmap_lookup(im62, 0UL).present); | |
| v = intmap_lookup(im75, 5UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "0a", 2UL) == 0); | |
| v = intmap_lookup(im66, 2625011179408469742UL); | |
| assert(!intmap_lookup(im66, 2625011179408469742UL).present); | |
| v = intmap_lookup(NULL, 2667557012157109398UL); | |
| assert(!intmap_lookup(NULL, 2667557012157109398UL).present); | |
| v = intmap_lookup(im66, 3UL); | |
| assert(!intmap_lookup(im66, 3UL).present); | |
| v = intmap_lookup(im21, 2UL); | |
| assert(!intmap_lookup(im21, 2UL).present); | |
| v = intmap_lookup(im21, 5UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "0a", 2UL) == 0); | |
| v = intmap_lookup(im54, 11UL); | |
| assert(!intmap_lookup(im54, 11UL).present); | |
| v = intmap_lookup(im32, 761643042849108716UL); | |
| assert(!intmap_lookup(im32, 761643042849108716UL).present); | |
| v = intmap_lookup(NULL, 2667557012157109398UL); | |
| assert(!intmap_lookup(NULL, 2667557012157109398UL).present); | |
| v = intmap_lookup(im57, 5UL); | |
| assert(!intmap_lookup(im57, 5UL).present); | |
| v = intmap_lookup(im32, 2UL); | |
| assert(!intmap_lookup(im32, 2UL).present); | |
| v = intmap_lookup(im11, 2667557012157109398UL); | |
| assert(!intmap_lookup(im11, 2667557012157109398UL).present); | |
| v = intmap_lookup(im32, 14490036593423678000UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "22", 2UL) == 0); | |
| intmap_release(a, im57); | |
| v = intmap_lookup(im43, 2UL); | |
| assert(!intmap_lookup(im43, 2UL).present); | |
| v = intmap_lookup(im62, 14UL); | |
| assert(!intmap_lookup(im62, 14UL).present); | |
| v = intmap_lookup(im65, 0UL); | |
| assert(!intmap_lookup(im65, 0UL).present); | |
| v = intmap_lookup(im22, 5UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "0a", 2UL) == 0); | |
| v = intmap_lookup(im65, 15472099966457721970UL); | |
| assert(!intmap_lookup(im65, 15472099966457721970UL).present); | |
| v = intmap_lookup(im54, 7749684778572138557UL); | |
| assert(!intmap_lookup(im54, 7749684778572138557UL).present); | |
| v = intmap_lookup(im67, 2625011179408469742UL); | |
| assert(!intmap_lookup(im67, 2625011179408469742UL).present); | |
| v = intmap_lookup(NULL, 17573884252492164290UL); | |
| assert(!intmap_lookup(NULL, 17573884252492164290UL).present); | |
| v = intmap_lookup(im65, 5UL); | |
| assert(v.present); | |
| assert(v.length == 10UL); | |
| assert(memcmp(v.data, "89eaa69a8f", 10UL) == 0); | |
| v = intmap_lookup(im43, 14490036593423678000UL); | |
| assert(!intmap_lookup(im43, 14490036593423678000UL).present); | |
| v = intmap_lookup(im66, 6340587588393565292UL); | |
| assert(!intmap_lookup(im66, 6340587588393565292UL).present); | |
| v = intmap_lookup(NULL, 761643042849108716UL); | |
| assert(!intmap_lookup(NULL, 761643042849108716UL).present); | |
| v = intmap_lookup(im67, 7UL); | |
| assert(!intmap_lookup(im67, 7UL).present); | |
| intmap_release(a, im15); | |
| intmap_release(a, im29); | |
| intmap_release(a, im32); | |
| v = intmap_lookup(im21, 17716769152692975850UL); | |
| assert(!intmap_lookup(im21, 17716769152692975850UL).present); | |
| v = intmap_lookup(NULL, 1UL); | |
| assert(!intmap_lookup(NULL, 1UL).present); | |
| v = intmap_lookup(im69, 5UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "0a", 2UL) == 0); | |
| v = intmap_lookup(im66, 5UL); | |
| assert(!intmap_lookup(im66, 5UL).present); | |
| v = intmap_lookup(im66, 761643042849108716UL); | |
| assert(!intmap_lookup(im66, 761643042849108716UL).present); | |
| intmap_release(a, im31); | |
| v = intmap_lookup(im72, 6UL); | |
| assert(!intmap_lookup(im72, 6UL).present); | |
| v = intmap_lookup(im11, 5UL); | |
| assert(v.present); | |
| assert(v.length == 10UL); | |
| assert(memcmp(v.data, "e41d981864", 10UL) == 0); | |
| v = intmap_lookup(im11, 0UL); | |
| assert(!intmap_lookup(im11, 0UL).present); | |
| intmap_release(a, im65); | |
| v = intmap_lookup(im45, 4520154812848368502UL); | |
| assert(!intmap_lookup(im45, 4520154812848368502UL).present); | |
| v = intmap_lookup(im48, 5UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "0a", 2UL) == 0); | |
| intmap_release(a, im72); | |
| v = intmap_lookup(im43, 13443926201081858053UL); | |
| assert(!intmap_lookup(im43, 13443926201081858053UL).present); | |
| v = intmap_lookup(im39, 17716769152692975850UL); | |
| assert(!intmap_lookup(im39, 17716769152692975850UL).present); | |
| v = intmap_lookup(im62, 1UL); | |
| assert(!intmap_lookup(im62, 1UL).present); | |
| v = intmap_lookup(im61, 12840335656338590366UL); | |
| assert(!intmap_lookup(im61, 12840335656338590366UL).present); | |
| v = intmap_lookup(NULL, 5UL); | |
| assert(!intmap_lookup(NULL, 5UL).present); | |
| v = intmap_lookup(im11, 2667557012157109398UL); | |
| assert(!intmap_lookup(im11, 2667557012157109398UL).present); | |
| v = intmap_lookup(im48, 761643042849108716UL); | |
| assert(!intmap_lookup(im48, 761643042849108716UL).present); | |
| v = intmap_lookup(im45, 2589917350437800974UL); | |
| assert(!intmap_lookup(im45, 2589917350437800974UL).present); | |
| intmap_release(a, im48); | |
| v = intmap_lookup(im75, 1386140140985334040UL); | |
| assert(!intmap_lookup(im75, 1386140140985334040UL).present); | |
| v = intmap_lookup(im22, 17716769152692975850UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "2a", 2UL) == 0); | |
| v = intmap_lookup(im66, 2625011179408469742UL); | |
| assert(!intmap_lookup(im66, 2625011179408469742UL).present); | |
| v = intmap_lookup(im21, 761643042849108716UL); | |
| assert(!intmap_lookup(im21, 761643042849108716UL).present); | |
| v = intmap_lookup(NULL, 0UL); | |
| assert(!intmap_lookup(NULL, 0UL).present); | |
| v = intmap_lookup(NULL, 17716769152692975850UL); | |
| assert(!intmap_lookup(NULL, 17716769152692975850UL).present); | |
| v = intmap_lookup(im73, 9448496432051398656UL); | |
| assert(!intmap_lookup(im73, 9448496432051398656UL).present); | |
| v = intmap_lookup(im62, 17716769152692975850UL); | |
| assert(!intmap_lookup(im62, 17716769152692975850UL).present); | |
| v = intmap_lookup(im22, 17UL); | |
| assert(!intmap_lookup(im22, 17UL).present); | |
| v = intmap_lookup(NULL, 0UL); | |
| assert(!intmap_lookup(NULL, 0UL).present); | |
| v = intmap_lookup(im11, 2625011179408469742UL); | |
| assert(!intmap_lookup(im11, 2625011179408469742UL).present); | |
| v = intmap_lookup(im22, 17716769152692975850UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "2a", 2UL) == 0); | |
| v = intmap_lookup(im73, 14490036593423678000UL); | |
| assert(!intmap_lookup(im73, 14490036593423678000UL).present); | |
| intmap_release(a, im73); | |
| v = intmap_lookup(im22, 761643042849108716UL); | |
| assert(!intmap_lookup(im22, 761643042849108716UL).present); | |
| v = intmap_lookup(im45, 5UL); | |
| assert(v.present); | |
| assert(v.length == 10UL); | |
| assert(memcmp(v.data, "e41d981864", 10UL) == 0); | |
| v = intmap_lookup(im39, 17716769152692975850UL); | |
| assert(!intmap_lookup(im39, 17716769152692975850UL).present); | |
| v = intmap_lookup(im62, 2UL); | |
| assert(!intmap_lookup(im62, 2UL).present); | |
| v = intmap_lookup(im45, 14490036593423678000UL); | |
| assert(!intmap_lookup(im45, 14490036593423678000UL).present); | |
| v = intmap_lookup(im21, 14UL); | |
| assert(!intmap_lookup(im21, 14UL).present); | |
| v = intmap_lookup(im44, 761643042849108716UL); | |
| assert(!intmap_lookup(im44, 761643042849108716UL).present); | |
| v = intmap_lookup(im45, 38UL); | |
| assert(!intmap_lookup(im45, 38UL).present); | |
| v = intmap_lookup(im43, 5UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "0a", 2UL) == 0); | |
| v = intmap_lookup(im23, 11236861977848850401UL); | |
| assert(!intmap_lookup(im23, 11236861977848850401UL).present); | |
| v = intmap_lookup(im66, 14490036593423678000UL); | |
| assert(!intmap_lookup(im66, 14490036593423678000UL).present); | |
| v = intmap_lookup(im44, 2UL); | |
| assert(!intmap_lookup(im44, 2UL).present); | |
| v = intmap_lookup(NULL, 4214698747553950221UL); | |
| assert(!intmap_lookup(NULL, 4214698747553950221UL).present); | |
| v = intmap_lookup(im61, 14990991837208100936UL); | |
| assert(!intmap_lookup(im61, 14990991837208100936UL).present); | |
| v = intmap_lookup(im75, 2667557012157109398UL); | |
| assert(!intmap_lookup(im75, 2667557012157109398UL).present); | |
| v = intmap_lookup(im22, 2UL); | |
| assert(!intmap_lookup(im22, 2UL).present); | |
| v = intmap_lookup(im66, 5UL); | |
| assert(!intmap_lookup(im66, 5UL).present); | |
| v = intmap_lookup(im54, 14490036593423678000UL); | |
| assert(!intmap_lookup(im54, 14490036593423678000UL).present); | |
| v = intmap_lookup(im62, 2UL); | |
| assert(!intmap_lookup(im62, 2UL).present); | |
| v = intmap_lookup(NULL, 2667557012157109398UL); | |
| assert(!intmap_lookup(NULL, 2667557012157109398UL).present); | |
| v = intmap_lookup(NULL, 17716769152692975850UL); | |
| assert(!intmap_lookup(NULL, 17716769152692975850UL).present); | |
| v = intmap_lookup(im44, 20UL); | |
| assert(!intmap_lookup(im44, 20UL).present); | |
| v = intmap_lookup(im21, 3653116411757380477UL); | |
| assert(!intmap_lookup(im21, 3653116411757380477UL).present); | |
| v = intmap_lookup(NULL, 17716769152692975850UL); | |
| assert(!intmap_lookup(NULL, 17716769152692975850UL).present); | |
| v = intmap_lookup(im54, 761643042849108716UL); | |
| assert(!intmap_lookup(im54, 761643042849108716UL).present); | |
| v = intmap_lookup(im54, 2625011179408469742UL); | |
| assert(!intmap_lookup(im54, 2625011179408469742UL).present); | |
| v = intmap_lookup(NULL, 2667557012157109398UL); | |
| assert(!intmap_lookup(NULL, 2667557012157109398UL).present); | |
| v = intmap_lookup(im61, 2625011179408469742UL); | |
| assert(!intmap_lookup(im61, 2625011179408469742UL).present); | |
| v = intmap_lookup(im23, 7UL); | |
| assert(!intmap_lookup(im23, 7UL).present); | |
| v = intmap_lookup(NULL, 2667557012157109398UL); | |
| assert(!intmap_lookup(NULL, 2667557012157109398UL).present); | |
| v = intmap_lookup(im11, 13443926201081858053UL); | |
| assert(!intmap_lookup(im11, 13443926201081858053UL).present); | |
| v = intmap_lookup(im75, 2667557012157109398UL); | |
| assert(!intmap_lookup(im75, 2667557012157109398UL).present); | |
| v = intmap_lookup(im69, 5UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "0a", 2UL) == 0); | |
| v = intmap_lookup(im39, 8UL); | |
| assert(!intmap_lookup(im39, 8UL).present); | |
| v = intmap_lookup(im67, 17716769152692975850UL); | |
| assert(!intmap_lookup(im67, 17716769152692975850UL).present); | |
| v = intmap_lookup(im75, 18042243530100691183UL); | |
| assert(!intmap_lookup(im75, 18042243530100691183UL).present); | |
| v = intmap_lookup(im62, 13443926201081858053UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "29", 2UL) == 0); | |
| v = intmap_lookup(im21, 14490036593423678000UL); | |
| assert(!intmap_lookup(im21, 14490036593423678000UL).present); | |
| v = intmap_lookup(im62, 17874678308347622793UL); | |
| assert(!intmap_lookup(im62, 17874678308347622793UL).present); | |
| v = intmap_lookup(im62, 761643042849108716UL); | |
| assert(!intmap_lookup(im62, 761643042849108716UL).present); | |
| v = intmap_lookup(NULL, 3UL); | |
| assert(!intmap_lookup(NULL, 3UL).present); | |
| v = intmap_lookup(im67, 5UL); | |
| assert(!intmap_lookup(im67, 5UL).present); | |
| v = intmap_lookup(im45, 13UL); | |
| assert(!intmap_lookup(im45, 13UL).present); | |
| v = intmap_lookup(im67, 2667557012157109398UL); | |
| assert(!intmap_lookup(im67, 2667557012157109398UL).present); | |
| v = intmap_lookup(NULL, 6291626137528567815UL); | |
| assert(!intmap_lookup(NULL, 6291626137528567815UL).present); | |
| v = intmap_lookup(NULL, 1UL); | |
| assert(!intmap_lookup(NULL, 1UL).present); | |
| v = intmap_lookup(NULL, 1678009346518718189UL); | |
| assert(!intmap_lookup(NULL, 1678009346518718189UL).present); | |
| v = intmap_lookup(im66, 1001020936624122783UL); | |
| assert(!intmap_lookup(im66, 1001020936624122783UL).present); | |
| v = intmap_lookup(NULL, 2667557012157109398UL); | |
| assert(!intmap_lookup(NULL, 2667557012157109398UL).present); | |
| v = intmap_lookup(im11, 2667557012157109398UL); | |
| assert(!intmap_lookup(im11, 2667557012157109398UL).present); | |
| intmap_release(a, im62); | |
| v = intmap_lookup(im39, 17716769152692975850UL); | |
| assert(!intmap_lookup(im39, 17716769152692975850UL).present); | |
| v = intmap_lookup(im22, 8UL); | |
| assert(!intmap_lookup(im22, 8UL).present); | |
| v = intmap_lookup(im23, 761643042849108716UL); | |
| assert(!intmap_lookup(im23, 761643042849108716UL).present); | |
| v = intmap_lookup(NULL, 2625011179408469742UL); | |
| assert(!intmap_lookup(NULL, 2625011179408469742UL).present); | |
| v = intmap_lookup(im75, 2667557012157109398UL); | |
| assert(!intmap_lookup(im75, 2667557012157109398UL).present); | |
| v = intmap_lookup(im23, 2667557012157109398UL); | |
| assert(!intmap_lookup(im23, 2667557012157109398UL).present); | |
| v = intmap_lookup(NULL, 5UL); | |
| assert(!intmap_lookup(NULL, 5UL).present); | |
| v = intmap_lookup(im69, 761643042849108716UL); | |
| assert(!intmap_lookup(im69, 761643042849108716UL).present); | |
| v = intmap_lookup(im21, 2667557012157109398UL); | |
| assert(v.present); | |
| assert(v.length == 8UL); | |
| assert(memcmp(v.data, "8d54a229", 8UL) == 0); | |
| v = intmap_lookup(im69, 5UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "0a", 2UL) == 0); | |
| v = intmap_lookup(im21, 2UL); | |
| assert(!intmap_lookup(im21, 2UL).present); | |
| v = intmap_lookup(NULL, 2625011179408469742UL); | |
| assert(!intmap_lookup(NULL, 2625011179408469742UL).present); | |
| v = intmap_lookup(NULL, 12580623259611283723UL); | |
| assert(!intmap_lookup(NULL, 12580623259611283723UL).present); | |
| v = intmap_lookup(im45, 761643042849108716UL); | |
| assert(!intmap_lookup(im45, 761643042849108716UL).present); | |
| v = intmap_lookup(im75, 14490036593423678000UL); | |
| assert(!intmap_lookup(im75, 14490036593423678000UL).present); | |
| v = intmap_lookup(im21, 2625011179408469742UL); | |
| assert(!intmap_lookup(im21, 2625011179408469742UL).present); | |
| v = intmap_lookup(im23, 2625011179408469742UL); | |
| assert(!intmap_lookup(im23, 2625011179408469742UL).present); | |
| v = intmap_lookup(im75, 4UL); | |
| assert(!intmap_lookup(im75, 4UL).present); | |
| v = intmap_lookup(im44, 1UL); | |
| assert(!intmap_lookup(im44, 1UL).present); | |
| v = intmap_lookup(im22, 761643042849108716UL); | |
| assert(!intmap_lookup(im22, 761643042849108716UL).present); | |
| v = intmap_lookup(im23, 0UL); | |
| assert(!intmap_lookup(im23, 0UL).present); | |
| v = intmap_lookup(im44, 14490036593423678000UL); | |
| assert(!intmap_lookup(im44, 14490036593423678000UL).present); | |
| v = intmap_lookup(im43, 14490036593423678000UL); | |
| assert(!intmap_lookup(im43, 14490036593423678000UL).present); | |
| v = intmap_lookup(im11, 5UL); | |
| assert(v.present); | |
| assert(v.length == 10UL); | |
| assert(memcmp(v.data, "e41d981864", 10UL) == 0); | |
| v = intmap_lookup(im43, 3UL); | |
| assert(!intmap_lookup(im43, 3UL).present); | |
| v = intmap_lookup(NULL, 14490036593423678000UL); | |
| assert(!intmap_lookup(NULL, 14490036593423678000UL).present); | |
| v = intmap_lookup(im44, 1595130340342235252UL); | |
| assert(!intmap_lookup(im44, 1595130340342235252UL).present); | |
| v = intmap_lookup(im11, 8UL); | |
| assert(!intmap_lookup(im11, 8UL).present); | |
| v = intmap_lookup(NULL, 6UL); | |
| assert(!intmap_lookup(NULL, 6UL).present); | |
| v = intmap_lookup(im66, 2667557012157109398UL); | |
| assert(!intmap_lookup(im66, 2667557012157109398UL).present); | |
| v = intmap_lookup(im61, 17716769152692975850UL); | |
| assert(!intmap_lookup(im61, 17716769152692975850UL).present); | |
| v = intmap_lookup(im39, 2UL); | |
| assert(!intmap_lookup(im39, 2UL).present); | |
| v = intmap_lookup(im69, 2667557012157109398UL); | |
| assert(!intmap_lookup(im69, 2667557012157109398UL).present); | |
| v = intmap_lookup(im21, 16UL); | |
| assert(!intmap_lookup(im21, 16UL).present); | |
| v = intmap_lookup(im69, 10UL); | |
| assert(!intmap_lookup(im69, 10UL).present); | |
| v = intmap_lookup(NULL, 2UL); | |
| assert(!intmap_lookup(NULL, 2UL).present); | |
| intmap_release(a, im21); | |
| v = intmap_lookup(im23, 13443926201081858053UL); | |
| assert(!intmap_lookup(im23, 13443926201081858053UL).present); | |
| v = intmap_lookup(im22, 2625011179408469742UL); | |
| assert(!intmap_lookup(im22, 2625011179408469742UL).present); | |
| v = intmap_lookup(im75, 13443926201081858053UL); | |
| assert(!intmap_lookup(im75, 13443926201081858053UL).present); | |
| v = intmap_lookup(im39, 5084388727220791355UL); | |
| assert(!intmap_lookup(im39, 5084388727220791355UL).present); | |
| v = intmap_lookup(NULL, 5UL); | |
| assert(!intmap_lookup(NULL, 5UL).present); | |
| v = intmap_lookup(im45, 13443926201081858053UL); | |
| assert(!intmap_lookup(im45, 13443926201081858053UL).present); | |
| v = intmap_lookup(im23, 14490036593423678000UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "22", 2UL) == 0); | |
| v = intmap_lookup(im67, 5UL); | |
| assert(!intmap_lookup(im67, 5UL).present); | |
| v = intmap_lookup(im69, 11297900749432941582UL); | |
| assert(!intmap_lookup(im69, 11297900749432941582UL).present); | |
| v = intmap_lookup(im39, 0UL); | |
| assert(!intmap_lookup(im39, 0UL).present); | |
| v = intmap_lookup(im43, 13443926201081858053UL); | |
| assert(!intmap_lookup(im43, 13443926201081858053UL).present); | |
| intmap_release(a, im66); | |
| v = intmap_lookup(NULL, 3UL); | |
| assert(!intmap_lookup(NULL, 3UL).present); | |
| v = intmap_lookup(im61, 2UL); | |
| assert(!intmap_lookup(im61, 2UL).present); | |
| v = intmap_lookup(im67, 0UL); | |
| assert(!intmap_lookup(im67, 0UL).present); | |
| v = intmap_lookup(im69, 14490036593423678000UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "22", 2UL) == 0); | |
| v = intmap_lookup(NULL, 5UL); | |
| assert(!intmap_lookup(NULL, 5UL).present); | |
| v = intmap_lookup(im39, 14490036593423678000UL); | |
| assert(!intmap_lookup(im39, 14490036593423678000UL).present); | |
| v = intmap_lookup(NULL, 13443926201081858053UL); | |
| assert(!intmap_lookup(NULL, 13443926201081858053UL).present); | |
| intmap_release(a, im39); | |
| v = intmap_lookup(im23, 5UL); | |
| assert(!intmap_lookup(im23, 5UL).present); | |
| v = intmap_lookup(im61, 761643042849108716UL); | |
| assert(!intmap_lookup(im61, 761643042849108716UL).present); | |
| v = intmap_lookup(im69, 18013153797024591071UL); | |
| assert(!intmap_lookup(im69, 18013153797024591071UL).present); | |
| v = intmap_lookup(im69, 10486099285761683701UL); | |
| assert(!intmap_lookup(im69, 10486099285761683701UL).present); | |
| v = intmap_lookup(NULL, 2UL); | |
| assert(!intmap_lookup(NULL, 2UL).present); | |
| intmap_release(a, im11); | |
| v = intmap_lookup(im43, 0UL); | |
| assert(!intmap_lookup(im43, 0UL).present); | |
| v = intmap_lookup(im22, 5UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "0a", 2UL) == 0); | |
| v = intmap_lookup(im61, 8165940255031621536UL); | |
| assert(!intmap_lookup(im61, 8165940255031621536UL).present); | |
| v = intmap_lookup(im54, 2625011179408469742UL); | |
| assert(!intmap_lookup(im54, 2625011179408469742UL).present); | |
| v = intmap_lookup(im69, 761643042849108716UL); | |
| assert(!intmap_lookup(im69, 761643042849108716UL).present); | |
| v = intmap_lookup(im45, 2667557012157109398UL); | |
| assert(!intmap_lookup(im45, 2667557012157109398UL).present); | |
| v = intmap_lookup(im45, 17716769152692975850UL); | |
| assert(!intmap_lookup(im45, 17716769152692975850UL).present); | |
| v = intmap_lookup(NULL, 9478877215271349193UL); | |
| assert(!intmap_lookup(NULL, 9478877215271349193UL).present); | |
| v = intmap_lookup(im61, 17764883865656808836UL); | |
| assert(!intmap_lookup(im61, 17764883865656808836UL).present); | |
| v = intmap_lookup(im61, 761643042849108716UL); | |
| assert(!intmap_lookup(im61, 761643042849108716UL).present); | |
| intmap_release(a, im54); | |
| intmap_release(a, im75); | |
| v = intmap_lookup(im45, 14490036593423678000UL); | |
| assert(!intmap_lookup(im45, 14490036593423678000UL).present); | |
| v = intmap_lookup(im69, 3UL); | |
| assert(!intmap_lookup(im69, 3UL).present); | |
| v = intmap_lookup(im44, 5UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "0a", 2UL) == 0); | |
| v = intmap_lookup(im45, 11UL); | |
| assert(!intmap_lookup(im45, 11UL).present); | |
| v = intmap_lookup(NULL, 17716769152692975850UL); | |
| assert(!intmap_lookup(NULL, 17716769152692975850UL).present); | |
| v = intmap_lookup(im61, 13443926201081858053UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "29", 2UL) == 0); | |
| v = intmap_lookup(im69, 14589750308601882447UL); | |
| assert(!intmap_lookup(im69, 14589750308601882447UL).present); | |
| v = intmap_lookup(im22, 2UL); | |
| assert(!intmap_lookup(im22, 2UL).present); | |
| v = intmap_lookup(NULL, 13303576698560179379UL); | |
| assert(!intmap_lookup(NULL, 13303576698560179379UL).present); | |
| v = intmap_lookup(im23, 2625011179408469742UL); | |
| assert(!intmap_lookup(im23, 2625011179408469742UL).present); | |
| v = intmap_lookup(NULL, 14490036593423678000UL); | |
| assert(!intmap_lookup(NULL, 14490036593423678000UL).present); | |
| v = intmap_lookup(im67, 2UL); | |
| assert(!intmap_lookup(im67, 2UL).present); | |
| v = intmap_lookup(im23, 2UL); | |
| assert(!intmap_lookup(im23, 2UL).present); | |
| v = intmap_lookup(im61, 2667557012157109398UL); | |
| assert(v.present); | |
| assert(v.length == 8UL); | |
| assert(memcmp(v.data, "8d54a229", 8UL) == 0); | |
| v = intmap_lookup(im23, 13285663891732774936UL); | |
| assert(!intmap_lookup(im23, 13285663891732774936UL).present); | |
| v = intmap_lookup(NULL, 2667557012157109398UL); | |
| assert(!intmap_lookup(NULL, 2667557012157109398UL).present); | |
| intmap_release(a, im43); | |
| intmap_release(a, im61); | |
| v = intmap_lookup(NULL, 18280109952876143376UL); | |
| assert(!intmap_lookup(NULL, 18280109952876143376UL).present); | |
| v = intmap_lookup(NULL, 13443926201081858053UL); | |
| assert(!intmap_lookup(NULL, 13443926201081858053UL).present); | |
| v = intmap_lookup(im45, 8834964070939507070UL); | |
| assert(!intmap_lookup(im45, 8834964070939507070UL).present); | |
| v = intmap_lookup(im44, 14490036593423678000UL); | |
| assert(!intmap_lookup(im44, 14490036593423678000UL).present); | |
| v = intmap_lookup(im69, 2UL); | |
| assert(!intmap_lookup(im69, 2UL).present); | |
| v = intmap_lookup(im67, 5UL); | |
| assert(!intmap_lookup(im67, 5UL).present); | |
| v = intmap_lookup(im23, 761643042849108716UL); | |
| assert(!intmap_lookup(im23, 761643042849108716UL).present); | |
| v = intmap_lookup(im44, 1UL); | |
| assert(!intmap_lookup(im44, 1UL).present); | |
| v = intmap_lookup(im44, 2625011179408469742UL); | |
| assert(!intmap_lookup(im44, 2625011179408469742UL).present); | |
| v = intmap_lookup(NULL, 2667557012157109398UL); | |
| assert(!intmap_lookup(NULL, 2667557012157109398UL).present); | |
| v = intmap_lookup(im45, 2625011179408469742UL); | |
| assert(v.present); | |
| assert(v.length == 4UL); | |
| assert(memcmp(v.data, "f7cb", 4UL) == 0); | |
| v = intmap_lookup(NULL, 14490036593423678000UL); | |
| assert(!intmap_lookup(NULL, 14490036593423678000UL).present); | |
| intmap_release(a, im69); | |
| v = intmap_lookup(NULL, 10UL); | |
| assert(!intmap_lookup(NULL, 10UL).present); | |
| v = intmap_lookup(NULL, 7453761468090873846UL); | |
| assert(!intmap_lookup(NULL, 7453761468090873846UL).present); | |
| v = intmap_lookup(im22, 17143682826773209710UL); | |
| assert(!intmap_lookup(im22, 17143682826773209710UL).present); | |
| v = intmap_lookup(im22, 2667557012157109398UL); | |
| assert(!intmap_lookup(im22, 2667557012157109398UL).present); | |
| v = intmap_lookup(im44, 761643042849108716UL); | |
| assert(!intmap_lookup(im44, 761643042849108716UL).present); | |
| v = intmap_lookup(im44, 761643042849108716UL); | |
| assert(!intmap_lookup(im44, 761643042849108716UL).present); | |
| v = intmap_lookup(im45, 2UL); | |
| assert(v.present); | |
| assert(v.length == 10UL); | |
| assert(memcmp(v.data, "d39ea5b710", 10UL) == 0); | |
| v = intmap_lookup(NULL, 2UL); | |
| assert(!intmap_lookup(NULL, 2UL).present); | |
| v = intmap_lookup(im22, 981197782248700998UL); | |
| assert(!intmap_lookup(im22, 981197782248700998UL).present); | |
| v = intmap_lookup(im44, 14490036593423678000UL); | |
| assert(!intmap_lookup(im44, 14490036593423678000UL).present); | |
| v = intmap_lookup(NULL, 0UL); | |
| assert(!intmap_lookup(NULL, 0UL).present); | |
| v = intmap_lookup(im22, 17716769152692975850UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "2a", 2UL) == 0); | |
| v = intmap_lookup(im44, 761643042849108716UL); | |
| assert(!intmap_lookup(im44, 761643042849108716UL).present); | |
| v = intmap_lookup(im44, 15UL); | |
| assert(!intmap_lookup(im44, 15UL).present); | |
| v = intmap_lookup(im67, 17222251452152967981UL); | |
| assert(!intmap_lookup(im67, 17222251452152967981UL).present); | |
| v = intmap_lookup(im22, 17716769152692975850UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "2a", 2UL) == 0); | |
| v = intmap_lookup(im44, 13443926201081858053UL); | |
| assert(v.present); | |
| assert(v.length == 2UL); | |
| assert(memcmp(v.data, "29", 2UL) == 0); | |
| v = intmap_lookup(im44, 761643042849108716UL); | |
| assert(!intmap_lookup(im44, 761643042849108716UL).present); | |
| v = intmap_lookup(im23, 5UL); | |
| assert(!intmap_lookup(im23, 5UL).present); | |
| v = intmap_lookup(im23, 9439800039924005756UL); | |
| assert(!intmap_lookup(im23, 9439800039924005756UL).present); | |
| intmap_release(a, im44); | |
| intmap_release(a, im22); | |
| v = intmap_lookup(im67, 2625011179408469742UL); | |
| assert(!intmap_lookup(im67, 2625011179408469742UL).present); | |
| v = intmap_lookup(im67, 761643042849108716UL); | |
| assert(!intmap_lookup(im67, 761643042849108716UL).present); | |
| v = intmap_lookup(im23, 761643042849108716UL); | |
| assert(!intmap_lookup(im23, 761643042849108716UL).present); | |
| v = intmap_lookup(im45, 13577029055777623976UL); | |
| assert(!intmap_lookup(im45, 13577029055777623976UL).present); | |
| v = intmap_lookup(im23, 223629038555042042UL); | |
| assert(!intmap_lookup(im23, 223629038555042042UL).present); | |
| v = intmap_lookup(im45, 12UL); | |
| assert(!intmap_lookup(im45, 12UL).present); | |
| v = intmap_lookup(im67, 2667557012157109398UL); | |
| assert(!intmap_lookup(im67, 2667557012157109398UL).present); | |
| v = intmap_lookup(im23, 0UL); | |
| assert(!intmap_lookup(im23, 0UL).present); | |
| v = intmap_lookup(im23, 2625011179408469742UL); | |
| assert(!intmap_lookup(im23, 2625011179408469742UL).present); | |
| intmap_release(a, im23); | |
| intmap_release(a, im67); | |
| v = intmap_lookup(im45, 761643042849108716UL); | |
| assert(!intmap_lookup(im45, 761643042849108716UL).present); | |
| v = intmap_lookup(im45, 2UL); | |
| assert(v.present); | |
| assert(v.length == 10UL); | |
| assert(memcmp(v.data, "d39ea5b710", 10UL) == 0); | |
| v = intmap_lookup(im45, 15823255372254459629UL); | |
| assert(!intmap_lookup(im45, 15823255372254459629UL).present); | |
| v = intmap_lookup(NULL, 9785691493241476397UL); | |
| assert(!intmap_lookup(NULL, 9785691493241476397UL).present); | |
| v = intmap_lookup(im45, 8397509693604277623UL); | |
| assert(!intmap_lookup(im45, 8397509693604277623UL).present); | |
| intmap_release(a, im45); | |
| assert(intmap_allocator_frees_remaining(a) == 0); | |
| intmap_allocator_del(a); | |
| return 0; | |
| } |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment