/*
Sample test application.
*/
+
#include "libmemcached/common.h"
#include <assert.h>
assert(results);
assert(results->cas);
assert(rc == MEMCACHED_SUCCESS);
- WATCHPOINT_ASSERT(memcached_result_cas(results));
+ assert(memcached_result_cas(results));
assert(!memcmp(value, "we the people", strlen("we the people")));
assert(strlen("we the people") == value_length);
results= memcached_fetch_result(memc, &results_obj, &rc);
assert(results);
assert(rc == MEMCACHED_SUCCESS);
- WATCHPOINT_ASSERT(memcached_result_cas(results));
+ assert(memcached_result_cas(results));
assert(!memcmp(value, memcached_result_value(results), value_length));
assert(strlen(memcached_result_value(results)) == value_length);
assert(rc == MEMCACHED_SUCCESS);
errors++;
else
{
- WATCHPOINT_ERROR(rc);
- assert(0);
+ assert(rc);
}
continue;
return rc;
}
+static memcached_return pre_replication_noblock(memcached_st *memc)
+{
+ memcached_return rc= MEMCACHED_FAILURE;
+ if (pre_replication(memc) == MEMCACHED_SUCCESS &&
+ pre_nonblock(memc) == MEMCACHED_SUCCESS)
+ rc= MEMCACHED_SUCCESS;
+
+ return rc;
+}
+
static void my_free(memcached_st *ptr __attribute__((unused)), void *mem)
{
free(mem);
return MEMCACHED_SUCCESS;
}
+#ifdef MEMCACHED_ENABLE_DEPRECATED
static memcached_return deprecated_set_memory_alloc(memcached_st *memc)
{
void *test_ptr= NULL;
}
return MEMCACHED_SUCCESS;
}
+#endif
static memcached_return set_memory_alloc(memcached_st *memc)
{
static test_return replication_set_test(memcached_st *memc)
{
memcached_return rc;
- memcached_st *clone= memcached_clone(NULL, memc);
- memcached_behavior_set(clone, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, 0);
+ memcached_st *memc_clone= memcached_clone(NULL, memc);
+ memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, 0);
rc= memcached_set(memc, "bubba", 5, "0", 1, 0, 0);
assert(rc == MEMCACHED_SUCCESS);
+ /*
+ ** We are using the quiet commands to store the replicas, so we need
+ ** to ensure that all of them are processed before we can continue.
+ ** In the test we go directly from storing the object to trying to
+ ** receive the object from all of the different servers, so we
+ ** could end up in a race condition (the memcached server hasn't yet
+ ** processed the quiet command from the replication set when it process
+ ** the request from the other client (created by the clone)). As a
+ ** workaround for that we call memcached_quit to send the quit command
+ ** to the server and wait for the response ;-) If you use the test code
+ ** as an example for your own code, please note that you shouldn't need
+ ** to do this ;-)
+ */
+ memcached_quit(memc);
+
/*
** "bubba" should now be stored on all of our servers. We don't have an
** easy to use API to address each individual server, so I'll just iterate
char key[2]= { [0]= (char)x };
size_t len;
uint32_t flags;
- char *val= memcached_get_by_key(clone, key, 1, "bubba", 5,
+ char *val= memcached_get_by_key(memc_clone, key, 1, "bubba", 5,
&len, &flags, &rc);
assert(rc == MEMCACHED_SUCCESS);
assert(val != NULL);
free(val);
}
- memcached_free(clone);
+ memcached_free(memc_clone);
return TEST_SUCCESS;
}
*/
for (uint32_t host= 0; host < memc->number_of_hosts; ++host)
{
- memcached_st *clone= memcached_clone(NULL, memc);
- clone->hosts[host].port= 0;
+ memcached_st *memc_clone= memcached_clone(NULL, memc);
+ memc_clone->hosts[host].port= 0;
for (int x= 'a'; x <= 'z'; ++x)
{
char key[2]= { [0]= (char)x };
size_t len;
uint32_t flags;
- char *val= memcached_get_by_key(clone, key, 1, "bubba", 5,
+ char *val= memcached_get_by_key(memc_clone, key, 1, "bubba", 5,
&len, &flags, &rc);
assert(rc == MEMCACHED_SUCCESS);
assert(val != NULL);
free(val);
}
- memcached_free(clone);
+ memcached_free(memc_clone);
}
return TEST_SUCCESS;
static test_return replication_mget_test(memcached_st *memc)
{
memcached_return rc;
- memcached_st *clone= memcached_clone(NULL, memc);
- memcached_behavior_set(clone, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, 0);
+ memcached_st *memc_clone= memcached_clone(NULL, memc);
+ memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, 0);
char *keys[]= { "bubba", "key1", "key2", "key3" };
size_t len[]= { 5, 4, 4, 4 };
assert(rc == MEMCACHED_SUCCESS);
}
+ /*
+ ** We are using the quiet commands to store the replicas, so we need
+ ** to ensure that all of them are processed before we can continue.
+ ** In the test we go directly from storing the object to trying to
+ ** receive the object from all of the different servers, so we
+ ** could end up in a race condition (the memcached server hasn't yet
+ ** processed the quiet command from the replication set when it process
+ ** the request from the other client (created by the clone)). As a
+ ** workaround for that we call memcached_quit to send the quit command
+ ** to the server and wait for the response ;-) If you use the test code
+ ** as an example for your own code, please note that you shouldn't need
+ ** to do this ;-)
+ */
+ memcached_quit(memc);
+
/*
* Don't do the following in your code. I am abusing the internal details
* within the library, and this is not a supported interface.
* This is to verify correct behavior in the library
*/
memcached_result_st result_obj;
- for (uint32_t host= 0; host < clone->number_of_hosts; host++)
+ for (uint32_t host= 0; host < memc_clone->number_of_hosts; host++)
{
memcached_st *new_clone= memcached_clone(NULL, memc);
new_clone->hosts[host].port= 0;
static test_return replication_delete_test(memcached_st *memc)
{
memcached_return rc;
- memcached_st *clone= memcached_clone(NULL, memc);
+ memcached_st *memc_clone= memcached_clone(NULL, memc);
/* Delete the items from all of the servers except 1 */
uint64_t repl= memcached_behavior_get(memc,
MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS);
uint32_t hash= memcached_generate_hash(memc, keys[0], len[0]);
for (uint32_t x= 0; x < (repl + 1); ++x)
{
- clone->hosts[hash].port= 0;
- if (++hash == clone->number_of_hosts)
+ memc_clone->hosts[hash].port= 0;
+ if (++hash == memc_clone->number_of_hosts)
hash= 0;
}
memcached_result_st result_obj;
- for (uint32_t host= 0; host < clone->number_of_hosts; ++host)
+ for (uint32_t host= 0; host < memc_clone->number_of_hosts; ++host)
{
for (int x= 'a'; x <= 'z'; ++x)
{
char key[2]= { [0]= (char)x };
- rc= memcached_mget_by_key(clone, key, 1, keys, len, 4);
+ rc= memcached_mget_by_key(memc_clone, key, 1, keys, len, 4);
assert(rc == MEMCACHED_SUCCESS);
- memcached_result_st *results= memcached_result_create(clone, &result_obj);
+ memcached_result_st *results= memcached_result_create(memc_clone, &result_obj);
assert(results);
int hits= 0;
- while ((results= memcached_fetch_result(clone, &result_obj, &rc)) != NULL)
+ while ((results= memcached_fetch_result(memc_clone, &result_obj, &rc)) != NULL)
{
++hits;
}
memcached_result_free(&result_obj);
}
}
- memcached_free(clone);
+ memcached_free(memc_clone);
return TEST_SUCCESS;
}
{
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 };
+ 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 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 };
+ 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 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 };
+ 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 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 };
+ 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 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 };
+ 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 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 };
+ 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 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 };
+ 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 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 };
+ 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++)
{"poll_timeout", poll_timeout, 0, tests},
{"gets", enable_cas, 0, tests},
{"consistent", enable_consistent, 0, tests},
+#ifdef MEMCACHED_ENABLE_DEPRECATED
{"deprecated_memory_allocators", deprecated_set_memory_alloc, 0, tests},
+#endif
{"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},
{"consistent_ketama_weighted", pre_behavior_ketama_weighted, 0, consistent_weighted_tests},
{"test_hashes", 0, 0, hash_tests},
{"replication", pre_replication, 0, replication_tests},
+ {"replication_noblock", pre_replication_noblock, 0, replication_tests},
{0, 0, 0, 0}
};