static pairs_st *global_pairs;
static char *global_keys[GLOBAL_COUNT];
static size_t global_keys_length[GLOBAL_COUNT];
-static char *global_values[GLOBAL_COUNT];
-static size_t global_values_length[GLOBAL_COUNT];
uint8_t init_test(memcached_st *not_used)
{
list= memcached_stat_get_keys(memc, &stat, &rc);
assert(rc == MEMCACHED_SUCCESS);
for (ptr= list; *ptr; ptr++)
- printf("Found key %s\n", *ptr);
+ assert(*ptr);
fflush(stdout);
free(list);
return 0;
}
+uint8_t version_string_test
+{
+ const char *version_string;
+ version_string= memcached_lib_version();
+ assert(!strcmp(version_string, LIBMEMCACHE_VERSION_STRING));
+ return 0;
+}
+
uint8_t get_stats(memcached_st *memc)
{
unsigned int x;
return 0;
}
+memcached_return clone_test_callback(memcached_st *parent, memcached_st *clone)
+{
+ return MEMCACHED_SUCCESS;
+}
+
+memcached_return cleanup_test_callback(memcached_st *ptr)
+{
+ return MEMCACHED_SUCCESS;
+}
+
+uint8_t callback_test(memcached_st *memc)
+{
+ /* Test User Data */
+ {
+ int x= 5;
+ int *test_ptr;
+ memcached_return rc;
+
+ rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_USER_DATA, &x);
+ assert(rc == MEMCACHED_SUCCESS);
+ test_ptr= (int *)memcached_callback_get(memc, MEMCACHED_CALLBACK_USER_DATA, &rc);
+ assert(*test_ptr == x);
+ }
+
+ /* Test Clone Callback */
+ {
+ memcached_clone_func temp_function;
+ memcached_return rc;
+
+ rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION, clone_test_callback);
+ assert(rc == MEMCACHED_SUCCESS);
+ temp_function= (memcached_clone_func)memcached_callback_get(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION, &rc);
+ assert(temp_function == clone_test_callback);
+ }
+
+ /* Test Cleanup Callback */
+ {
+ memcached_cleanup_func temp_function;
+ memcached_return rc;
+
+ rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION, cleanup_test_callback);
+ assert(rc == MEMCACHED_SUCCESS);
+ temp_function= (memcached_cleanup_func)memcached_callback_get(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION, &rc);
+ assert(temp_function == cleanup_test_callback);
+ }
+
+ return 0;
+}
+
/* We don't test the behavior itself, we test the switches */
uint8_t behavior_test(memcached_st *memc)
{
memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_NO_BLOCK, &set);
memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_TCP_NODELAY, &set);
timeout= 2;
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, &timeout);
+ memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, &timeout);
value = (char*)malloc(value_length * sizeof(char));
memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_NO_BLOCK, &set);
memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_TCP_NODELAY, &set);
timeout= -1;
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, &timeout);
+ memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, &timeout);
- timeout= (int32_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT);
+ timeout= (int32_t)memcached_behavior_get(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT);
assert(timeout == -1);
for (x= 1; x <= 100000; ++x)
{
rc= memcached_set(mclone, key, key_len,value, value_length, 0, 0);
-
- WATCHPOINT_IFERROR(rc);
}
free(value);
return 0;
}
-uint8_t mdelete_generate(memcached_st *memc)
-{
- memcached_return rc;
-
- rc= memcached_mdelete(memc, global_keys, global_keys_length, GLOBAL_COUNT, 0);
-
- return 0;
-}
-
-
uint8_t free_data(memcached_st *memc)
{
pairs_free(global_pairs);
return MEMCACHED_SUCCESS;
}
+void my_free(memcached_st *ptr, void *mem)
+{
+ free(mem);
+}
+
+void *my_malloc(memcached_st *ptr, const size_t size)
+{
+ return malloc(size);
+}
+
+void *my_realloc(memcached_st *ptr, void *mem, const size_t size)
+{
+ return realloc(mem, size);
+}
+
+memcached_return set_memory_alloc(memcached_st *memc)
+{
+ {
+ memcached_malloc_function test_ptr;
+ memcached_return rc;
+
+ rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_MALLOC_FUNCTION, &my_malloc);
+ assert(rc == MEMCACHED_SUCCESS);
+ test_ptr= (memcached_malloc_function)memcached_callback_get(memc, MEMCACHED_CALLBACK_USER_DATA, &rc);
+ assert(test_ptr == (memcached_malloc_function)my_malloc);
+ }
+
+ {
+ memcached_realloc_function test_ptr;
+ memcached_return rc;
+
+ rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_REALLOC_FUNCTION, &my_realloc);
+ assert(rc == MEMCACHED_SUCCESS);
+ test_ptr= (memcached_realloc_function)memcached_callback_get(memc, MEMCACHED_CALLBACK_USER_DATA, &rc);
+ assert(test_ptr == my_realloc);
+ }
+
+ {
+ memcached_free_function test_ptr;
+ memcached_return rc;
+
+ rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_FREE_FUNCTION, my_free);
+ assert(rc == MEMCACHED_SUCCESS);
+ test_ptr= (memcached_free_function)memcached_callback_get(memc, MEMCACHED_CALLBACK_USER_DATA, &rc);
+ assert(test_ptr == my_free);
+ }
+
+ return MEMCACHED_SUCCESS;
+}
memcached_return enable_consistent(memcached_st *memc)
{
{"add_host_test", 0, add_host_test },
{"get_stats_keys", 0, get_stats_keys },
{"behavior_test", 0, get_stats_keys },
+ {"callback_test", 0, get_stats_keys },
+ {"version_string_test", 0, version_string_test},
{0, 0, 0}
};
{"mget_read", 0, mget_read },
{"mget_read_result", 0, mget_read_result },
{"mget_read_function", 0, mget_read_function },
- {"mdelete_generate", 0, mdelete_generate },
{"cleanup", 1, cleanup_pairs },
{0, 0, 0}
};
{"poll_timeout", poll_timeout, 0, tests},
{"gets", enable_cas, 0, tests},
{"consistent", enable_consistent, 0, tests},
+ {"memory_allocators", set_memory_alloc, 0, tests},
// {"udp", pre_udp, 0, tests},
{"version_1_2_3", check_for_1_2_3, 0, version_1_2_3},
{"string", 0, 0, string_tests},