X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=tests%2Ffunction.c;h=99ad776aecc1bc8154c4dc58cca229b885fd925c;hb=618811a49324bf07ee0d3d435bb3843d3d57fd02;hp=86a255ba326a3bd956fa6b839e7dd27399b45bcb;hpb=276c3db8d1dc8e14949df2b408960a803bea5d53;p=m6w6%2Flibmemcached diff --git a/tests/function.c b/tests/function.c index 86a255ba..99ad776a 100644 --- a/tests/function.c +++ b/tests/function.c @@ -215,6 +215,7 @@ static test_return clone_test(memcached_st *memc) assert(clone->call_free == memc->call_free); assert(clone->call_malloc == memc->call_malloc); assert(clone->call_realloc == memc->call_realloc); + assert(clone->call_calloc == memc->call_calloc); assert(clone->connect_timeout == memc->connect_timeout); assert(clone->delete_trigger == memc->delete_trigger); assert(clone->distribution == memc->distribution); @@ -262,6 +263,16 @@ static test_return clone_test(memcached_st *memc) return 0; } +static test_return userdata_test(memcached_st *memc) +{ + void* foo; + assert(memcached_set_user_data(memc, foo) == NULL); + assert(memcached_get_user_data(memc) == foo); + assert(memcached_set_user_data(memc, NULL) == foo); + + return TEST_SUCCESS; +} + static test_return connection_test(memcached_st *memc) { memcached_return rc; @@ -872,7 +883,6 @@ static test_return set_test2(memcached_st *memc) static test_return set_test3(memcached_st *memc) { memcached_return rc; - char *key= "foo"; char *value; size_t value_length= 8191; unsigned int x; @@ -883,8 +893,13 @@ static test_return set_test3(memcached_st *memc) for (x= 0; x < value_length; x++) value[x] = (char) (x % 127); - for (x= 0; x < 1; x++) + /* The dump test relies on there being at least 32 items in memcached */ + for (x= 0; x < 32; x++) { + char key[16]; + + sprintf(key, "foo%u", x); + rc= memcached_set(memc, key, strlen(key), value, value_length, (time_t)0, (uint32_t)0); @@ -2668,7 +2683,11 @@ static test_return generate_data_with_stats(memcached_st *memc) for (host_index= 0; host_index < SERVERS_TO_CREATE; host_index++) { - printf("\nserver %u|%s|%u bytes: %llu\n", host_index, (memc->hosts)[host_index].hostname, (memc->hosts)[host_index].port, (unsigned long long)(stat_p + host_index)->bytes); + /* This test was changes so that "make test" would work properlly */ +#ifdef DEBUG + printf("\nserver %u|%s|%u bytes: %llu\n", host_index, (memc->hosts)[host_index].hostname, (memc->hosts)[host_index].port, (unsigned long long)(stat_p + host_index)->bytes); +#endif + assert((unsigned long long)(stat_p + host_index)->bytes); } memcached_stat_free(NULL, stat_p); @@ -3035,7 +3054,11 @@ static void my_free(memcached_st *ptr __attribute__((unused)), void *mem) static void *my_malloc(memcached_st *ptr __attribute__((unused)), const size_t size) { - return calloc(1, size); + void *ret= malloc(size); + if (ret != NULL) + memset(ret, 0xff, size); + + return ret; } static void *my_realloc(memcached_st *ptr __attribute__((unused)), void *mem, const size_t size) @@ -3043,6 +3066,11 @@ static void *my_realloc(memcached_st *ptr __attribute__((unused)), void *mem, co return realloc(mem, size); } +static void *my_calloc(memcached_st *ptr __attribute__((unused)), size_t nelem, const size_t size) +{ + return calloc(nelem, size); +} + static memcached_return set_prefix(memcached_st *memc) { memcached_return rc; @@ -3110,7 +3138,7 @@ static memcached_return set_prefix(memcached_st *memc) return MEMCACHED_SUCCESS; } -static memcached_return set_memory_alloc(memcached_st *memc) +static memcached_return deprecated_set_memory_alloc(memcached_st *memc) { void *test_ptr= NULL; void *cb_ptr= NULL; @@ -3152,6 +3180,30 @@ static memcached_return set_memory_alloc(memcached_st *memc) assert(rc == MEMCACHED_SUCCESS); assert(test_ptr == cb_ptr); } + return MEMCACHED_SUCCESS; +} + +static memcached_return set_memory_alloc(memcached_st *memc) +{ + memcached_return rc; + rc= memcached_set_memory_allocators(memc, NULL, my_free, + my_realloc, my_calloc); + assert(rc == MEMCACHED_FAILURE); + + rc= memcached_set_memory_allocators(memc, my_malloc, my_free, + my_realloc, my_calloc); + + memcached_malloc_function mem_malloc; + memcached_free_function mem_free; + memcached_realloc_function mem_realloc; + memcached_calloc_function mem_calloc; + memcached_get_memory_allocators(memc, &mem_malloc, &mem_free, + &mem_realloc, &mem_calloc); + + assert(mem_malloc == my_malloc); + assert(mem_realloc == my_realloc); + assert(mem_calloc == my_calloc); + assert(mem_free == my_free); return MEMCACHED_SUCCESS; } @@ -3268,7 +3320,7 @@ static test_return noreply_test(memcached_st *memc) for (int x=0; x < 100; ++x) { char key[10]; - size_t len=sprintf(key, "%d", x); + size_t len= sprintf(key, "%d", x); switch (count) { case 0: @@ -3308,7 +3360,7 @@ static test_return noreply_test(memcached_st *memc) for (int x=0; x < 100; ++x) { char key[10]; - size_t len=sprintf(key, "%d", x); + size_t len= sprintf(key, "%d", x); size_t length; uint32_t flags; char* value=memcached_get(memc, key, strlen(key), @@ -3342,12 +3394,12 @@ static test_return noreply_test(memcached_st *memc) uint32_t flags; memcached_result_st results_obj; memcached_result_st *results; - ret=memcached_mget(memc, keys, lengths, 1); + ret= memcached_mget(memc, keys, lengths, 1); assert(ret == MEMCACHED_SUCCESS); - results=memcached_result_create(memc, &results_obj); + results= memcached_result_create(memc, &results_obj); assert(results); - results=memcached_fetch_result(memc, &results_obj, &ret); + results= memcached_fetch_result(memc, &results_obj, &ret); assert(results); assert(ret == MEMCACHED_SUCCESS); uint64_t cas= memcached_result_cas(results); @@ -3390,6 +3442,45 @@ static test_return analyzer_test(memcached_st *memc) return TEST_SUCCESS; } +/* Count the objects */ +static memcached_return callback_dump_counter(memcached_st *ptr __attribute__((unused)), + const char *key __attribute__((unused)), + size_t key_length __attribute__((unused)), + void *context) +{ + uint32_t *counter= (uint32_t *)context; + + *counter= *counter + 1; + + return MEMCACHED_SUCCESS; +} + +static test_return dump_test(memcached_st *memc) +{ + memcached_return rc; + uint32_t counter= 0; + memcached_dump_func callbacks[1]; + test_return main_rc; + + callbacks[0]= &callback_dump_counter; + + /* No support for Binary protocol yet */ + if (memc->flags & MEM_BINARY_PROTOCOL) + return TEST_SUCCESS; + + main_rc= set_test3(memc); + + assert (main_rc == TEST_SUCCESS); + + rc= memcached_dump(memc, callbacks, (void *)&counter, 1); + assert(rc == MEMCACHED_SUCCESS); + + /* We may have more then 32 if our previous flush has not completed */ + assert(counter >= 32); + + return TEST_SUCCESS; +} + #ifdef HAVE_LIBMEMCACHEDUTIL static void* connection_release(void *arg) { struct { @@ -3790,6 +3881,228 @@ static test_return hsieh_avaibility_test (memcached_st *memc) return TEST_SUCCESS; } +static char *list[]= +{ + "apple", + "beat", + "carrot", + "daikon", + "eggplant", + "flower", + "green", + "hide", + "ick", + "jack", + "kick", + "lime", + "mushrooms", + "nectarine", + "orange", + "peach", + "quant", + "ripen", + "strawberry", + "tang", + "up", + "volumne", + "when", + "yellow", + "zip", + NULL +}; + +static test_return md5_run (memcached_st *memc __attribute__((unused))) +{ + uint32_t x; + char **ptr; + uint32_t values[]= { 3195025439, 2556848621, 3724893440, 3332385401, 245758794, 2550894432, + 121710495, 3053817768, 1250994555, 1862072655, 2631955953, 2951528551, + 1451250070, 2820856945, 2060845566, 3646985608, 2138080750, 217675895, + 2230934345, 1234361223, 3968582726, 2455685270, 1293568479, 199067604, + 2042482093 }; + + + for (ptr= list, x= 0; *ptr; ptr++, x++) + { + uint32_t hash_val; + + hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_MD5); + assert(values[x] == hash_val); + } + + return TEST_SUCCESS; +} + +static test_return crc_run (memcached_st *memc __attribute__((unused))) +{ + uint32_t x; + char **ptr; + uint32_t values[]= { 10542, 22009, 14526, 19510, 19432, 10199, 20634, 9369, 11511, 10362, + 7893, 31289, 11313, 9354, 7621, 30628, 15218, 25967, 2695, 9380, + 17300, 28156, 9192, 20484, 16925 }; + + for (ptr= list, x= 0; *ptr; ptr++, x++) + { + uint32_t hash_val; + + hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_CRC); + assert(values[x] == hash_val); + } + + return TEST_SUCCESS; +} + +static test_return fnv1_64_run (memcached_st *memc __attribute__((unused))) +{ + uint32_t x; + char **ptr; + uint32_t values[]= { 473199127, 4148981457, 3971873300, 3257986707, 1722477987, 2991193800, + 4147007314, 3633179701, 1805162104, 3503289120, 3395702895, 3325073042, + 2345265314, 3340346032, 2722964135, 1173398992, 2815549194, 2562818319, + 224996066, 2680194749, 3035305390, 246890365, 2395624193, 4145193337, + 1801941682 }; + + for (ptr= list, x= 0; *ptr; ptr++, x++) + { + uint32_t hash_val; + + hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_FNV1_64); + assert(values[x] == hash_val); + } + + return TEST_SUCCESS; +} + +static test_return fnv1a_64_run (memcached_st *memc __attribute__((unused))) +{ + uint32_t x; + char **ptr; + uint32_t values[]= { 1488911807, 2500855813, 1510099634, 1390325195, 3647689787, 3241528582, + 1669328060, 2604311949, 734810122, 1516407546, 560948863, 1767346780, + 561034892, 4156330026, 3716417003, 3475297030, 1518272172, 227211583, + 3938128828, 126112909, 3043416448, 3131561933, 1328739897, 2455664041, + 2272238452 }; + + for (ptr= list, x= 0; *ptr; ptr++, x++) + { + uint32_t hash_val; + + hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_FNV1A_64); + assert(values[x] == hash_val); + } + + return TEST_SUCCESS; +} + +static test_return fnv1_32_run (memcached_st *memc __attribute__((unused))) +{ + uint32_t x; + char **ptr; + uint32_t values[]= { 67176023, 1190179409, 2043204404, 3221866419, 2567703427, 3787535528, 4147287986, + 3500475733, 344481048, 3865235296, 2181839183, 119581266, 510234242, 4248244304, + 1362796839, 103389328, 1449620010, 182962511, 3554262370, 3206747549, 1551306158, + 4127558461, 1889140833, 2774173721, 1180552018 }; + + + for (ptr= list, x= 0; *ptr; ptr++, x++) + { + uint32_t hash_val; + + hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_FNV1_32); + assert(values[x] == hash_val); + } + + return TEST_SUCCESS; +} + +static test_return fnv1a_32_run (memcached_st *memc __attribute__((unused))) +{ + uint32_t x; + char **ptr; + uint32_t values[]= { 280767167, 2421315013, 3072375666, 855001899, 459261019, 3521085446, 18738364, + 1625305005, 2162232970, 777243802, 3323728671, 132336572, 3654473228, 260679466, + 1169454059, 2698319462, 1062177260, 235516991, 2218399068, 405302637, 1128467232, + 3579622413, 2138539289, 96429129, 2877453236 }; + + for (ptr= list, x= 0; *ptr; ptr++, x++) + { + uint32_t hash_val; + + hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_FNV1A_32); + assert(values[x] == hash_val); + } + + return TEST_SUCCESS; +} + +static test_return hsieh_run (memcached_st *memc __attribute__((unused))) +{ + uint32_t x; + char **ptr; +#ifdef HAVE_HSIEH_HASH + uint32_t values[]= { 3738850110, 3636226060, 3821074029, 3489929160, 3485772682, 80540287, + 1805464076, 1895033657, 409795758, 979934958, 3634096985, 1284445480, + 2265380744, 707972988, 353823508, 1549198350, 1327930172, 9304163, + 4220749037, 2493964934, 2777873870, 2057831732, 1510213931, 2027828987, + 3395453351 }; +#else + uint32_t values[]= { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }; +#endif + + for (ptr= list, x= 0; *ptr; ptr++, x++) + { + uint32_t hash_val; + + hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_HSIEH); + assert(values[x] == hash_val); + } + + return TEST_SUCCESS; +} + +static test_return murmur_run (memcached_st *memc __attribute__((unused))) +{ + uint32_t x; + char **ptr; + uint32_t values[]= { 473199127, 4148981457, 3971873300, 3257986707, 1722477987, 2991193800, + 4147007314, 3633179701, 1805162104, 3503289120, 3395702895, 3325073042, + 2345265314, 3340346032, 2722964135, 1173398992, 2815549194, 2562818319, + 224996066, 2680194749, 3035305390, 246890365, 2395624193, 4145193337, + 1801941682 }; + + for (ptr= list, x= 0; *ptr; ptr++, x++) + { + uint32_t hash_val; + + hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_FNV1_64); + assert(values[x] == hash_val); + } + + return TEST_SUCCESS; +} + +static test_return jenkins_run (memcached_st *memc __attribute__((unused))) +{ + uint32_t x; + char **ptr; + uint32_t values[]= { 1442444624, 4253821186, 1885058256, 2120131735, 3261968576, 3515188778, + 4232909173, 4288625128, 1812047395, 3689182164, 2502979932, 1214050606, + 2415988847, 1494268927, 1025545760, 3920481083, 4153263658, 3824871822, + 3072759809, 798622255, 3065432577, 1453328165, 2691550971, 3408888387, + 2629893356 }; + + + for (ptr= list, x= 0; *ptr; ptr++, x++) + { + uint32_t hash_val; + + hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_JENKINS); + assert(values[x] == hash_val); + } + + return TEST_SUCCESS; +} + test_st udp_setup_server_tests[] ={ {"set_udp_behavior_test", 0, set_udp_behavior_test}, {"add_tcp_server_udp_client_test", 0, add_tcp_server_udp_client_test}, @@ -3828,10 +4141,12 @@ test_st tests[] ={ {"connection_test", 0, connection_test}, {"callback_test", 0, callback_test}, {"behavior_test", 0, behavior_test}, + {"userdata_test", 0, userdata_test}, {"error", 0, error_test }, {"set", 0, set_test }, {"set2", 0, set_test2 }, {"set3", 0, set_test3 }, + {"dump", 1, dump_test}, {"add", 1, add_test }, {"replace", 1, replace_test }, {"delete", 1, delete_test }, @@ -3977,6 +4292,19 @@ test_st ketama_auto_eject_hosts[] ={ {0, 0, 0} }; +test_st hash_tests[] ={ + {"md5", 0, md5_run }, + {"crc", 0, crc_run }, + {"fnv1_64", 0, fnv1_64_run }, + {"fnv1a_64", 0, fnv1a_64_run }, + {"fnv1_32", 0, fnv1_32_run }, + {"fnv1a_32", 0, fnv1a_32_run }, + {"hsieh", 0, hsieh_run }, + {"murmur", 0, murmur_run }, + {"jenkis", 0, jenkins_run }, + {0, 0, 0} +}; + collection_st collection[] ={ {"hsieh_availability",0,0,hsieh_availability}, {"udp_setup", init_udp, 0, udp_setup_server_tests}, @@ -4002,6 +4330,7 @@ collection_st collection[] ={ {"poll_timeout", poll_timeout, 0, tests}, {"gets", enable_cas, 0, tests}, {"consistent", enable_consistent, 0, tests}, + {"deprecated_memory_allocators", deprecated_set_memory_alloc, 0, tests}, {"memory_allocators", set_memory_alloc, 0, tests}, {"prefix", set_prefix, 0, tests}, {"version_1_2_3", check_for_1_2_3, 0, version_1_2_3}, @@ -4021,6 +4350,7 @@ collection_st collection[] ={ {"consistent_not", 0, 0, consistent_tests}, {"consistent_ketama", pre_behavior_ketama, 0, consistent_tests}, {"consistent_ketama_weighted", pre_behavior_ketama_weighted, 0, consistent_weighted_tests}, + {"test_hashes", 0, 0, hash_tests}, {0, 0, 0, 0} };