comparison: src/server/test/pblock.c
src/server/test/pblock.c
- changeset 667
- 1f0f014c0121
equal
deleted
inserted
replaced
| 666:c99e0b352e36 | 667:1f0f014c0121 |
|---|---|
| 1 /* | |
| 2 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. | |
| 3 * | |
| 4 * Copyright 2026 Olaf Wintermann. All rights reserved. | |
| 5 * | |
| 6 * Redistribution and use in source and binary forms, with or without | |
| 7 * modification, are permitted provided that the following conditions are met: | |
| 8 * | |
| 9 * 1. Redistributions of source code must retain the above copyright | |
| 10 * notice, this list of conditions and the following disclaimer. | |
| 11 * | |
| 12 * 2. Redistributions in binary form must reproduce the above copyright | |
| 13 * notice, this list of conditions and the following disclaimer in the | |
| 14 * documentation and/or other materials provided with the distribution. | |
| 15 * | |
| 16 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" | |
| 17 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | |
| 18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | |
| 19 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE | |
| 20 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR | |
| 21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF | |
| 22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS | |
| 23 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN | |
| 24 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) | |
| 25 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE | |
| 26 * POSSIBILITY OF SUCH DAMAGE. | |
| 27 */ | |
| 28 | |
| 29 #include "pblock.h" | |
| 30 | |
| 31 #include "../util/pblock.h" | |
| 32 | |
| 33 #include <cx/hash_map.h> | |
| 34 | |
| 35 CX_TEST(test_pblock_iterator) { | |
| 36 pool_handle_t *pool = pool_create(); | |
| 37 | |
| 38 CX_TEST_DO { | |
| 39 pblock *pb_empty_1 = pblock_create_pool(pool, 1); | |
| 40 pblock *pb_empty_2 = pblock_create_pool(pool, 2); | |
| 41 pblock *pb_empty_4 = pblock_create_pool(pool, 4); | |
| 42 | |
| 43 pblock *pb_one_1 = pblock_create_pool(pool, 1); | |
| 44 pblock *pb_one_2 = pblock_create_pool(pool, 2); | |
| 45 pblock *pb_one_4 = pblock_create_pool(pool, 4); | |
| 46 | |
| 47 pblock *pb_many_1 = pblock_create_pool(pool, 1); | |
| 48 pblock *pb_many_4 = pblock_create_pool(pool, 4); | |
| 49 pblock *pb_many_16 = pblock_create_pool(pool, 16); | |
| 50 pblock *pb_many_64 = pblock_create_pool(pool, 64); | |
| 51 | |
| 52 pblock_nvinsert("mykey", "pb_one", pb_one_1); | |
| 53 pblock_nvinsert("mykey", "pb_one", pb_one_2); | |
| 54 pblock_nvinsert("mykey", "pb_one", pb_one_4); | |
| 55 | |
| 56 pblock *pbs[4] = { pb_many_1, pb_many_4, pb_many_16, pb_many_64 }; | |
| 57 | |
| 58 for(int n=0;n<4;n++) { | |
| 59 pblock *p = pbs[n]; | |
| 60 pblock_nvinsert("key1", "many1", p); | |
| 61 pblock_nvinsert("key2", "many2", p); | |
| 62 pblock_nvinsert("key3", "many3", p); | |
| 63 pblock_nvinsert("key4", "many4", p); | |
| 64 pblock_nvinsert("b_key5__long_key_X1", "many5", p); | |
| 65 pblock_nvinsert("c_key6__long_key_X2", "many6", p); | |
| 66 pblock_nvinsert("d_key7__long_key_X3", "many7", p); | |
| 67 pblock_nvinsert("e_key8__long_key_X4", "many8", p); | |
| 68 pblock_nvinsert("01_key9__very_long_key_test_X1", "many9", p); | |
| 69 pblock_nvinsert("12_keya__very_long_key_test_X20", "manya", p); | |
| 70 pblock_nvinsert("34_keyb__very_long_key_test_X300", "manyb", p); | |
| 71 pblock_nvinsert("56_keyc__very_long_key_test_X4000", "manyc", p); | |
| 72 pblock_nvinsert("78_keyd__very_long_key_test_X50000", "manyd", p); | |
| 73 } | |
| 74 | |
| 75 int count; | |
| 76 CxIterator i; | |
| 77 | |
| 78 // check empty pblocks | |
| 79 count = 0; | |
| 80 i = pblock_iterator(pb_empty_1); | |
| 81 cx_foreach(pb_entry*, entry, i) { | |
| 82 count++; | |
| 83 } | |
| 84 CX_TEST_ASSERT(count == 0); | |
| 85 | |
| 86 count = 0; | |
| 87 i = pblock_iterator(pb_empty_2); | |
| 88 cx_foreach(pb_entry*, entry, i) { | |
| 89 count++; | |
| 90 } | |
| 91 CX_TEST_ASSERT(count == 0); | |
| 92 | |
| 93 count = 0; | |
| 94 i = pblock_iterator(pb_empty_4); | |
| 95 cx_foreach(pb_entry*, entry, i) { | |
| 96 count++; | |
| 97 } | |
| 98 CX_TEST_ASSERT(count == 0); | |
| 99 | |
| 100 // check pblocks with one element | |
| 101 pblock *pbs_one[3] = { pb_one_1, pb_one_2, pb_one_4 }; | |
| 102 for(int n=0;n<3;n++) { | |
| 103 count = 0; | |
| 104 i = pblock_iterator(pbs_one[n]); | |
| 105 cx_foreach(pb_entry*, entry, i) { | |
| 106 count++; | |
| 107 CX_TEST_ASSERT(entry); | |
| 108 CX_TEST_ASSERT(entry->param); | |
| 109 CX_TEST_ASSERT(entry->param->name); | |
| 110 CX_TEST_ASSERT(entry->param->value); | |
| 111 CX_TEST_ASSERT(!strcmp(entry->param->name, "mykey")); | |
| 112 CX_TEST_ASSERT(!strcmp(entry->param->value, "pb_one")); | |
| 113 } | |
| 114 CX_TEST_ASSERT(count == 1); | |
| 115 } | |
| 116 | |
| 117 // check pblocks with many elements | |
| 118 for(int n=0;n<4;n++) { | |
| 119 CxMap *map = cxHashMapCreate(NULL, CX_STORE_POINTERS, 64); | |
| 120 | |
| 121 i = pblock_iterator(pbs[n]); | |
| 122 cx_foreach(pb_entry*, entry, i) { | |
| 123 CX_TEST_ASSERT(entry); | |
| 124 CX_TEST_ASSERT(entry->param); | |
| 125 CX_TEST_ASSERT(entry->param->name); | |
| 126 CX_TEST_ASSERT(entry->param->value); | |
| 127 cxMapPut(map, entry->param->name, entry->param->value); | |
| 128 } | |
| 129 CX_TEST_ASSERT(cxMapSize(map) == 13); | |
| 130 | |
| 131 CxMapIterator mi = cxMapIterator(map); | |
| 132 cx_foreach(CxMapEntry*, entry, mi) { | |
| 133 cxmutstr key = cx_strdup(cx_strn(entry->key->data, entry->key->len)); | |
| 134 char *pb_val = pblock_findval(key.ptr, pbs[n]); | |
| 135 free(key.ptr); | |
| 136 char *map_value = entry->value; | |
| 137 CX_TEST_ASSERT(!cx_strcmp(pb_val, map_value)); | |
| 138 } | |
| 139 cxMapFree(map); | |
| 140 } | |
| 141 } | |
| 142 | |
| 143 pool_destroy(pool); | |
| 144 } |
