+static test_return_t hsieh_avaibility_test (memcached_st *memc)
+{
+ memcached_return expected_rc= MEMCACHED_FAILURE;
+#ifdef HAVE_HSIEH_HASH
+ expected_rc= MEMCACHED_SUCCESS;
+#endif
+ memcached_return rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH,
+ (uint64_t)MEMCACHED_HASH_HSIEH);
+ assert(rc == expected_rc);
+ return TEST_SUCCESS;
+}
+
+static const 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_t md5_run (memcached_st *memc __attribute__((unused)))
+{
+ uint32_t x;
+ const char **ptr;
+ uint32_t values[]= { 3195025439U, 2556848621U, 3724893440U, 3332385401U,
+ 245758794U, 2550894432U, 121710495U, 3053817768U,
+ 1250994555U, 1862072655U, 2631955953U, 2951528551U,
+ 1451250070U, 2820856945U, 2060845566U, 3646985608U,
+ 2138080750U, 217675895U, 2230934345U, 1234361223U,
+ 3968582726U, 2455685270U, 1293568479U, 199067604U,
+ 2042482093U };
+
+
+ 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_t crc_run (memcached_st *memc __attribute__((unused)))
+{
+ uint32_t x;
+ const char **ptr;
+ uint32_t values[]= { 10542U, 22009U, 14526U, 19510U, 19432U, 10199U, 20634U,
+ 9369U, 11511U, 10362U, 7893U, 31289U, 11313U, 9354U,
+ 7621U, 30628U, 15218U, 25967U, 2695U, 9380U,
+ 17300U, 28156U, 9192U, 20484U, 16925U };
+
+ 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_t fnv1_64_run (memcached_st *memc __attribute__((unused)))
+{
+ uint32_t x;
+ const char **ptr;
+ uint32_t values[]= { 473199127U, 4148981457U, 3971873300U, 3257986707U,
+ 1722477987U, 2991193800U, 4147007314U, 3633179701U,
+ 1805162104U, 3503289120U, 3395702895U, 3325073042U,
+ 2345265314U, 3340346032U, 2722964135U, 1173398992U,
+ 2815549194U, 2562818319U, 224996066U, 2680194749U,
+ 3035305390U, 246890365U, 2395624193U, 4145193337U,
+ 1801941682U };
+
+ 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_t fnv1a_64_run (memcached_st *memc __attribute__((unused)))
+{
+ uint32_t x;
+ const char **ptr;
+ uint32_t values[]= { 1488911807U, 2500855813U, 1510099634U, 1390325195U,
+ 3647689787U, 3241528582U, 1669328060U, 2604311949U,
+ 734810122U, 1516407546U, 560948863U, 1767346780U,
+ 561034892U, 4156330026U, 3716417003U, 3475297030U,
+ 1518272172U, 227211583U, 3938128828U, 126112909U,
+ 3043416448U, 3131561933U, 1328739897U, 2455664041U,
+ 2272238452U };
+
+ 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_t fnv1_32_run (memcached_st *memc __attribute__((unused)))
+{
+ uint32_t x;
+ const char **ptr;
+ uint32_t values[]= { 67176023U, 1190179409U, 2043204404U, 3221866419U,
+ 2567703427U, 3787535528U, 4147287986U, 3500475733U,
+ 344481048U, 3865235296U, 2181839183U, 119581266U,
+ 510234242U, 4248244304U, 1362796839U, 103389328U,
+ 1449620010U, 182962511U, 3554262370U, 3206747549U,
+ 1551306158U, 4127558461U, 1889140833U, 2774173721U,
+ 1180552018U };
+
+
+ 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_t fnv1a_32_run (memcached_st *memc __attribute__((unused)))
+{
+ uint32_t x;
+ const char **ptr;
+ uint32_t values[]= { 280767167U, 2421315013U, 3072375666U, 855001899U,
+ 459261019U, 3521085446U, 18738364U, 1625305005U,
+ 2162232970U, 777243802U, 3323728671U, 132336572U,
+ 3654473228U, 260679466U, 1169454059U, 2698319462U,
+ 1062177260U, 235516991U, 2218399068U, 405302637U,
+ 1128467232U, 3579622413U, 2138539289U, 96429129U,
+ 2877453236U };
+
+ 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_t hsieh_run (memcached_st *memc __attribute__((unused)))
+{
+ uint32_t x;
+ const 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_t murmur_run (memcached_st *memc __attribute__((unused)))
+{
+ uint32_t x;
+ const char **ptr;
+ uint32_t values[]= { 473199127U, 4148981457U, 3971873300U, 3257986707U,
+ 1722477987U, 2991193800U, 4147007314U, 3633179701U,
+ 1805162104U, 3503289120U, 3395702895U, 3325073042U,
+ 2345265314U, 3340346032U, 2722964135U, 1173398992U,
+ 2815549194U, 2562818319U, 224996066U, 2680194749U,
+ 3035305390U, 246890365U, 2395624193U, 4145193337U,
+ 1801941682U };
+
+ 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_t jenkins_run (memcached_st *memc __attribute__((unused)))
+{
+ uint32_t x;
+ const char **ptr;
+ uint32_t values[]= { 1442444624U, 4253821186U, 1885058256U, 2120131735U,
+ 3261968576U, 3515188778U, 4232909173U, 4288625128U,
+ 1812047395U, 3689182164U, 2502979932U, 1214050606U,
+ 2415988847U, 1494268927U, 1025545760U, 3920481083U,
+ 4153263658U, 3824871822U, 3072759809U, 798622255U,
+ 3065432577U, 1453328165U, 2691550971U, 3408888387U,
+ 2629893356U };
+
+
+ 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;
+}
+
+static test_return_t regression_bug_434484(memcached_st *memc)
+{
+ if (pre_binary(memc) != MEMCACHED_SUCCESS)
+ return TEST_SKIPPED;
+
+ memcached_return ret;
+ const char *key= "regression_bug_434484";
+ size_t keylen= strlen(key);
+
+ ret= memcached_append(memc, key, keylen, key, keylen, 0, 0);
+ assert(ret == MEMCACHED_NOTSTORED);
+
+ size_t size= 2048 * 1024;
+ void *data= calloc(1, size);
+ assert(data != NULL);
+ ret= memcached_set(memc, key, keylen, data, size, 0, 0);
+ assert(ret == MEMCACHED_E2BIG);
+ free(data);
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t regression_bug_434843(memcached_st *memc)
+{
+ if (pre_binary(memc) != MEMCACHED_SUCCESS)
+ return TEST_SKIPPED;
+
+ memcached_return rc;
+ unsigned int counter= 0;
+ memcached_execute_function callbacks[1]= { [0]= &callback_counter };
+
+ /*
+ * I only want to hit only _one_ server so I know the number of requests I'm
+ * sending in the pipleine to the server. Let's try to do a multiget of
+ * 10240 (that should satisfy most users don't you tink?)
+ */
+ uint32_t number_of_hosts= memc->number_of_hosts;
+ memc->number_of_hosts= 1;
+ const size_t max_keys= 10240;
+ char **keys= calloc(max_keys, sizeof(char*));
+ size_t *key_length=calloc(max_keys, sizeof(size_t));
+
+ for (int x= 0; x < (int)max_keys; ++x)
+ {
+ char k[251];
+ key_length[x]= (size_t)snprintf(k, sizeof(k), "0200%u", x);
+ keys[x]= strdup(k);
+ assert(keys[x] != NULL);
+ }
+
+ /*
+ * Run two times.. the first time we should have 100% cache miss,
+ * and the second time we should have 100% cache hits
+ */
+ for (int y= 0; y < 2; ++y)
+ {
+ rc= memcached_mget(memc, (const char**)keys, key_length, max_keys);
+ assert(rc == MEMCACHED_SUCCESS);
+ rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1);
+ if (y == 0)
+ {
+ /* The first iteration should give me a 100% cache miss. verify that*/
+ assert(counter == 0);
+ char blob[1024]= { 0 };
+ for (int x= 0; x < (int)max_keys; ++x)
+ {
+ rc= memcached_add(memc, keys[x], key_length[x],
+ blob, sizeof(blob), 0, 0);
+ assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
+ }
+ }
+ else
+ {
+ /* Verify that we received all of the key/value pairs */
+ assert(counter == (unsigned int)max_keys);
+ }
+ }
+
+ /* Release allocated resources */
+ for (size_t x= 0; x < max_keys; ++x)
+ free(keys[x]);
+ free(keys);
+ free(key_length);
+
+ memc->number_of_hosts= number_of_hosts;
+ return TEST_SUCCESS;
+}
+
+static test_return_t regression_bug_434843_buffered(memcached_st *memc)
+{
+ memcached_return rc;
+ rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 1);
+ assert(rc == MEMCACHED_SUCCESS);
+
+ return regression_bug_434843(memc);
+}
+
+static test_return_t regression_bug_421108(memcached_st *memc)
+{
+ memcached_return rc;
+ memcached_stat_st *memc_stat= memcached_stat(memc, NULL, &rc);
+ assert(rc == MEMCACHED_SUCCESS);
+
+ char *bytes= memcached_stat_get_value(memc, memc_stat, "bytes", &rc);
+ assert(rc == MEMCACHED_SUCCESS);
+ assert(bytes != NULL);
+ char *bytes_read= memcached_stat_get_value(memc, memc_stat,
+ "bytes_read", &rc);
+ assert(rc == MEMCACHED_SUCCESS);
+ assert(bytes_read != NULL);
+
+ char *bytes_written= memcached_stat_get_value(memc, memc_stat,
+ "bytes_written", &rc);
+ assert(rc == MEMCACHED_SUCCESS);
+ assert(bytes_written != NULL);
+
+ assert(strcmp(bytes, bytes_read) != 0);
+ assert(strcmp(bytes, bytes_written) != 0);
+
+ /* Release allocated resources */
+ free(bytes);
+ free(bytes_read);
+ free(bytes_written);
+ memcached_stat_free(NULL, memc_stat);
+ return TEST_SUCCESS;
+}
+
+/*
+ * The test case isn't obvious so I should probably document why
+ * it works the way it does. Bug 442914 was caused by a bug
+ * in the logic in memcached_purge (it did not handle the case
+ * where the number of bytes sent was equal to the watermark).
+ * In this test case, create messages so that we hit that case
+ * and then disable noreply mode and issue a new command to
+ * verify that it isn't stuck. If we change the format for the
+ * delete command or the watermarks, we need to update this
+ * test....
+ */
+static test_return_t regression_bug_442914(memcached_st *memc)
+{
+ memcached_return rc;
+ rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, 1);
+ assert(rc == MEMCACHED_SUCCESS);
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, 1);
+
+ uint32_t number_of_hosts= memc->number_of_hosts;
+ memc->number_of_hosts= 1;
+
+ char k[250];
+ size_t len;
+
+ for (int x= 0; x < 250; ++x)
+ {
+ len= (size_t)snprintf(k, sizeof(k), "%0250u", x);
+ rc= memcached_delete(memc, k, len, 0);
+ assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
+ }
+
+ len= (size_t)snprintf(k, sizeof(k), "%037u", 251);
+ rc= memcached_delete(memc, k, len, 0);
+ assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
+
+ rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, 0);
+ assert(rc == MEMCACHED_SUCCESS);
+ rc= memcached_delete(memc, k, len, 0);
+ assert(rc == MEMCACHED_NOTFOUND);
+
+ memc->number_of_hosts= number_of_hosts;
+
+ return TEST_SUCCESS;
+}
+