return MEMCACHED_SUCCESS;
}
+static memcached_return_t dump_server_information(const memcached_st *ptr __attribute__((unused)),
+ const memcached_server_st *instance,
+ void *context)
+{
+ /* Do Nothing */
+ FILE *stream= (FILE *)context;
+
+ fprintf(stream, "Memcached Server: %s %u Version %u.%u.%u\n",
+ memcached_server_name(instance),
+ memcached_server_port(instance),
+ instance->major_version,
+ instance->minor_version,
+ instance->micro_version);
+
+ return MEMCACHED_SUCCESS;
+}
+
static test_return_t server_sort_test(memcached_st *ptr __attribute__((unused)))
{
size_t bigger= 0; /* Prime the value for the test_true in server_display_function */
{
char key[16];
- sprintf(key, "foo%u", x);
+ snprintf(key, sizeof(key), "foo%u", x);
rc= memcached_set(memc, key, strlen(key),
value, value_length,
{
char k[251];
- key_length[x]= (size_t)snprintf(k, sizeof(k), "0200%zu", x);
+ key_length[x]= (size_t)snprintf(k, sizeof(k), "0200%lu", (unsigned long)x);
keys[x]= strdup(k);
test_true(keys[x] != NULL);
rc= memcached_add(memc, keys[x], key_length[x], blob, sizeof(blob), 0, 0);
free(return_value);
}
- return ((rc == MEMCACHED_END) || (rc == MEMCACHED_SUCCESS)) ? TEST_SUCCESS : TEST_FAILURE;
+ test_true_got(rc == MEMCACHED_END || rc == MEMCACHED_SUCCESS, memcached_strerror(NULL, rc));
+
+ return TEST_SUCCESS;
}
/* Test case provided by Cal Haldenbrand */
return TEST_SUCCESS;
}
-#ifndef __sun
+#if !defined(__sun) && !defined(__OpenBSD__)
/* Check the validity of chinese key*/
static test_return_t user_supplied_bug17(memcached_st *memc)
{
static test_return_t _user_supplied_bug21(memcached_st* memc, size_t key_count)
{
+#ifdef WIN32
+ (void)memc;
+ (void)key_count;
+ return TEST_SKIPPED;
+#else
memcached_return_t rc;
unsigned int x;
char **keys;
memcached_free(memc_clone);
return TEST_SUCCESS;
+#endif
}
static test_return_t user_supplied_bug21(memcached_st *memc)
for (int x= 0; x < 10000; x++)
{
char key[10];
- sprintf(key, "%d", x);
+ snprintf(key, sizeof(key), "%d", x);
uint32_t server_idx = memcached_generate_hash(memc, key, strlen(key));
char *hostname = memc->hosts[server_idx].hostname;
static test_return_t generate_data(memcached_st *memc)
{
- execute_set(memc, global_pairs, global_count);
+ unsigned int check_execute= execute_set(memc, global_pairs, global_count);
+
+ test_true(check_execute == global_count);
return TEST_SUCCESS;
}
memcached_stat_st *stat_p;
memcached_return_t rc;
uint32_t host_index= 0;
- execute_set(memc, global_pairs, global_count);
+ unsigned int check_execute= execute_set(memc, global_pairs, global_count);
+
+ test_true(check_execute == global_count);
//TODO: hosts used size stats
stat_p= memcached_stat(memc, NULL, &rc);
memcached_return_t rc;
rc= memcached_mget(memc, global_keys, global_keys_length, global_count);
- test_true(rc == MEMCACHED_SUCCESS);
+ test_true_got(rc == MEMCACHED_SUCCESS, memcached_strerror(NULL, rc));
test_true(fetch_all_results(memc) == TEST_SUCCESS);
return TEST_SUCCESS;
memcached_return_t rc;
rc= memcached_mget(memc, global_keys, global_keys_length, global_count);
- test_true(rc == MEMCACHED_SUCCESS);
+ test_true_got(rc == MEMCACHED_SUCCESS, memcached_strerror(NULL, rc));
/* Turn this into a help function */
{
memcached_result_st results_obj;
memcached_execute_fn callbacks[1];
rc= memcached_mget(memc, global_keys, global_keys_length, global_count);
- test_true(rc == MEMCACHED_SUCCESS);
+ test_true_got(rc == MEMCACHED_SUCCESS, memcached_strerror(NULL, rc));
callbacks[0]= &callback_counter;
counter= 0;
{
char buffer[SMALL_STRING_LEN];
- snprintf(buffer, SMALL_STRING_LEN, "%zu.example.com", 400+x);
+ snprintf(buffer, SMALL_STRING_LEN, "%lu.example.com", (unsigned long)(400 +x));
servers= memcached_server_list_append_with_weight(servers, buffer, 401, 0,
&rc);
test_true(rc == MEMCACHED_SUCCESS);
// will not toggle protocol on an connection.
memcached_version(memc_clone);
- if (libmemcached_util_version_check(memc_clone, 1, 3, 0))
+ if (libmemcached_util_version_check(memc_clone, 1, 4, 4))
{
memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 0);
rc = memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
{
memcached_return_t rc= MEMCACHED_FAILURE;
- if (libmemcached_util_version_check(memc, 1, 3, 0))
+ if (libmemcached_util_version_check(memc, 1, 4, 4))
{
rc = memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
test_true(rc == MEMCACHED_SUCCESS);
for (size_t x= 0; x < 100; ++x)
{
char key[10];
- size_t len= (size_t)sprintf(key, "%zu", x);
+ int check_length= (size_t)snprintf(key, sizeof(key), "%lu", (unsigned long)x);
+ test_false((size_t)check_length >= sizeof(key) || check_length < 0);
+
+ size_t len= (size_t)check_length;
+
switch (count)
{
case 0:
{
char key[10];
- size_t len= (size_t)sprintf(key, "%zu", x);
+ int check_length= (size_t)snprintf(key, sizeof(key), "%lu", (unsigned long)x);
+
+ test_false((size_t)check_length >= sizeof(key) || check_length < 0);
+
+ size_t len= (size_t)check_length;
size_t length;
uint32_t flags;
char* value=memcached_get(memc, key, strlen(key),
return arg;
}
+#define POOL_SIZE 10
static test_return_t connection_pool_test(memcached_st *memc)
{
- memcached_pool_st* pool= memcached_pool_create(memc, 5, 10);
+ memcached_pool_st* pool= memcached_pool_create(memc, 5, POOL_SIZE);
test_true(pool != NULL);
- memcached_st* mmc[10];
+ memcached_st *mmc[POOL_SIZE];
memcached_return_t rc;
- for (size_t x= 0; x < 10; ++x)
+ for (size_t x= 0; x < POOL_SIZE; ++x)
{
mmc[x]= memcached_pool_pop(pool, false, &rc);
test_true(mmc[x] != NULL);
rc= memcached_set(mmc[0], key, keylen, "0", 1, 0, 0);
test_true(rc == MEMCACHED_SUCCESS);
- for (size_t x= 0; x < 10; ++x)
+ for (size_t x= 0; x < POOL_SIZE; ++x)
{
uint64_t number_value;
rc= memcached_increment(mmc[x], key, keylen, 1, &number_value);
}
// Release them..
- for (size_t x= 0; x < 10; ++x)
+ for (size_t x= 0; x < POOL_SIZE; ++x)
{
test_true(memcached_pool_push(pool, mmc[x]) == MEMCACHED_SUCCESS);
}
test_true(memcached_behavior_get(mmc[0], MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK) == 9999);
test_true(memcached_pool_push(pool, mmc[0]) == MEMCACHED_SUCCESS);
-
test_true(memcached_pool_destroy(pool) == memc);
+
return TEST_SUCCESS;
}
test_true(if_successful == true);
if_successful= libmemcached_util_version_check(memc, 9, 9, 9);
+
+ // We expect failure
+ if (if_successful)
+ {
+ fprintf(stderr, "\n----------------------------------------------------------------------\n");
+ fprintf(stderr, "\nDumping Server Information\n\n");
+ memcached_server_fn callbacks[1];
+
+ callbacks[0]= dump_server_information;
+ memcached_server_cursor(memc, callbacks, (void *)stderr, 1);
+ fprintf(stderr, "\n----------------------------------------------------------------------\n");
+ }
test_true(if_successful == false);
memcached_server_instance_st instance=
test_true(if_successful == true);
if (instance->micro_version > 0)
- if_successful= libmemcached_util_version_check(memc, instance->major_version, instance->minor_version, instance->micro_version -1);
+ if_successful= libmemcached_util_version_check(memc, instance->major_version, instance->minor_version, (uint8_t)(instance->micro_version -1));
else if (instance->minor_version > 0)
- if_successful= libmemcached_util_version_check(memc, instance->major_version, instance->minor_version - 1, instance->micro_version);
+ if_successful= libmemcached_util_version_check(memc, instance->major_version, (uint8_t)(instance->minor_version - 1), instance->micro_version);
else if (instance->major_version > 0)
- if_successful= libmemcached_util_version_check(memc, instance->major_version -1, instance->minor_version, instance->micro_version);
+ if_successful= libmemcached_util_version_check(memc, (uint8_t)(instance->major_version -1), instance->minor_version, instance->micro_version);
test_true(if_successful == true);
if (instance->micro_version > 0)
- if_successful= libmemcached_util_version_check(memc, instance->major_version, instance->minor_version, instance->micro_version +1);
+ if_successful= libmemcached_util_version_check(memc, instance->major_version, instance->minor_version, (uint8_t)(instance->micro_version +1));
else if (instance->minor_version > 0)
- if_successful= libmemcached_util_version_check(memc, instance->major_version, instance->minor_version +1, instance->micro_version);
+ if_successful= libmemcached_util_version_check(memc, instance->major_version, (uint8_t)(instance->minor_version +1), instance->micro_version);
else if (instance->major_version > 0)
- if_successful= libmemcached_util_version_check(memc, instance->major_version +1, instance->minor_version, instance->micro_version);
+ if_successful= libmemcached_util_version_check(memc, (uint8_t)(instance->major_version +1), instance->minor_version, instance->micro_version);
test_true(if_successful == false);
// See if memcached is reachable.
value= memcached_get(tl_memc_h, key, strlen(key), &len, &flags, &rc);
- if (value)
- {
- free(value);
- test_true(value); // Pointer won't be zero so this is fine.
- }
-
+ test_false(value);
test_true(len == 0);
- test_true(rc == MEMCACHED_ERRNO);
+ test_false(rc == MEMCACHED_SUCCESS);
+
+ memcached_free(tl_memc_h);
return TEST_SUCCESS;
}
// See if memcached is reachable.
value= memcached_get(memc, key, strlen(key), &len, &flags, &rc);
- if (value)
- {
- free(value);
- test_true(value); // Pointer won't be zero so this is fine.
- }
-
+ test_false(value);
test_true(len == 0);
test_true(rc == MEMCACHED_NOTFOUND);
// See if memcached is reachable.
value= memcached_get_by_key(tl_memc_h, key, strlen(key), key, strlen(key), &len, &flags, &rc);
- if (value)
- {
- free(value);
- test_true(value); // Pointer won't be zero so this is fine.
- }
-
+ test_false(value);
test_true(len == 0);
- test_true(rc == MEMCACHED_ERRNO);
+ test_false(rc == MEMCACHED_SUCCESS);
+
+ memcached_free(tl_memc_h);
return TEST_SUCCESS;
}
// See if memcached is reachable.
value= memcached_get_by_key(memc, key, strlen(key), key, strlen(key), &len, &flags, &rc);
- if (value)
- {
- free(value);
- test_true(value); // Pointer won't be zero so this is fine.
- }
-
+ test_false(value);
test_true(len == 0);
test_true(rc == MEMCACHED_NOTFOUND);
{
char k[251];
- key_length[x]= (size_t)snprintf(k, sizeof(k), "0200%zu", x);
+ key_length[x]= (size_t)snprintf(k, sizeof(k), "0200%lu", (unsigned long)x);
keys[x]= strdup(k);
test_true(keys[x] != NULL);
}
memcached_server_instance_st instance_one;
memcached_server_instance_st instance_two;
- if (memcached_server_count(memc) < 3 || pre_replication(memc) != MEMCACHED_SUCCESS)
+ if (memcached_server_count(memc) < 3 || pre_replication(memc) != TEST_SUCCESS)
return TEST_SKIPPED;
memcached_return_t rc;
{
char k[251];
- key_length[x]= (size_t)snprintf(k, sizeof(k), "0200%zu", x);
+ key_length[x]= (size_t)snprintf(k, sizeof(k), "0200%lu", (unsigned long)x);
keys[x]= strdup(k);
test_true(keys[x] != NULL);
rc= memcached_set(memc, k, key_length[x], k, key_length[x], 0, 0);
memcached_return_t rc= memcached_delete(memc, "foo", 3, 1);
/* but there is a bug in some of the memcached servers (1.4) that treats
- * the counter as noreply so it doesn't send the proper error message
- */
- test_true(rc == MEMCACHED_PROTOCOL_ERROR || rc == MEMCACHED_NOTFOUND || rc == MEMCACHED_CLIENT_ERROR);
+ * the counter as noreply so it doesn't send the proper error message
+ */
+ test_true_got(rc == MEMCACHED_PROTOCOL_ERROR || rc == MEMCACHED_NOTFOUND || rc == MEMCACHED_CLIENT_ERROR || rc == MEMCACHED_INVALID_ARGUMENTS, memcached_strerror(NULL, rc));
/* And buffered mode should be disabled and we should get protocol error */
test_true(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 1) == MEMCACHED_SUCCESS);
rc= memcached_delete(memc, "foo", 3, 1);
- test_true(rc == MEMCACHED_PROTOCOL_ERROR || rc == MEMCACHED_NOTFOUND || rc == MEMCACHED_CLIENT_ERROR);
+ test_true_got(rc == MEMCACHED_PROTOCOL_ERROR || rc == MEMCACHED_NOTFOUND || rc == MEMCACHED_CLIENT_ERROR || rc == MEMCACHED_INVALID_ARGUMENTS, memcached_strerror(NULL, rc));
/* Same goes for noreply... */
test_true(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, 1) == MEMCACHED_SUCCESS);
rc= memcached_delete(memc, "foo", 3, 1);
- test_true(rc == MEMCACHED_PROTOCOL_ERROR || rc == MEMCACHED_NOTFOUND || rc == MEMCACHED_CLIENT_ERROR);
+ test_true_got(rc == MEMCACHED_PROTOCOL_ERROR || rc == MEMCACHED_NOTFOUND || rc == MEMCACHED_CLIENT_ERROR || rc == MEMCACHED_INVALID_ARGUMENTS, memcached_strerror(NULL, rc));
/* but a normal request should go through (and be buffered) */
test_true((rc= memcached_delete(memc, "foo", 3, 0)) == MEMCACHED_BUFFERED);
return TEST_SUCCESS;
}
+
+static memcached_return_t stat_printer(memcached_server_instance_st server,
+ const char *key, size_t key_length,
+ const char *value, size_t value_length,
+ void *context)
+{
+ (void)server;
+ (void)context;
+ (void)key;
+ (void)key_length;
+ (void)value;
+ (void)value_length;
+
+ return MEMCACHED_SUCCESS;
+}
+
+static test_return_t memcached_stat_execute_test(memcached_st *memc)
+{
+ memcached_return_t rc= memcached_stat_execute(memc, NULL, stat_printer, NULL);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ rc= memcached_stat_execute(memc, "slabs", stat_printer, NULL);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ rc= memcached_stat_execute(memc, "items", stat_printer, NULL);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ rc= memcached_stat_execute(memc, "sizes", stat_printer, NULL);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ return TEST_SUCCESS;
+}
+
/*
* This test ensures that the failure counter isn't incremented during
* normal termination of the memcached instance.
for (size_t x= 0; x < max_keys; ++x)
{
char k[251];
- key_length[x]= (size_t)snprintf(k, sizeof(k), "0200%zu", x);
+ key_length[x]= (size_t)snprintf(k, sizeof(k), "0200%lu", (unsigned long)x);
keys[x]= strdup(k);
assert(keys[x] != NULL);
rc= memcached_set(memc, keys[x], key_length[x], blob, sizeof(blob), 0, 0);
(void)memcached_get(memc, "dsf", 3, &length, &flags, &rc);
- test_true(rc == MEMCACHED_TIMEOUT);
+ test_true_got(rc == MEMCACHED_TIMEOUT, memcached_strerror(NULL, rc));
memcached_free(memc);
{"verbosity", 1, (test_callback_fn)test_verbosity},
{"test_server_failure", 1, (test_callback_fn)test_server_failure},
{"cull_servers", 1, (test_callback_fn)test_cull_servers},
+ {"memcached_stat_execute", 1, (test_callback_fn)memcached_stat_execute_test},
{0, 0, 0}
};
{"user_supplied_bug14", 1, (test_callback_fn)user_supplied_bug14 },
{"user_supplied_bug15", 1, (test_callback_fn)user_supplied_bug15 },
{"user_supplied_bug16", 1, (test_callback_fn)user_supplied_bug16 },
-#ifndef __sun
+#if !defined(__sun) && !defined(__OpenBSD__)
/*
** It seems to be something weird with the character sets..
** value_fetch is unable to parse the value line (iscntrl "fails"), so I
projects / awesomized / libmemcached / blobdiff