*
*/
-#include <config.h>
-#include <libtest/test.hpp>
+#include "mem_config.h"
+#include "libtest/test.hpp"
-#include <libmemcached/util.h>
-#include <libmemcached/is.h>
+#include "libmemcachedutil-1.0/util.h"
+#include "libmemcached/is.h"
-#include <tests/libmemcached-1.0/generate.h>
-#include <tests/libmemcached-1.0/fetch_all_results.h>
+#include "tests/libmemcached-1.0/generate.h"
+#include "tests/libmemcached-1.0/fetch_all_results.h"
#include "tests/libmemcached-1.0/callback_counter.h"
-#include "clients/generator.h"
-#include "clients/execute.h"
+#include "bin/generator.h"
+#include "bin/execute.h"
+
+#include "tests/memc.hpp"
+
+#ifdef __APPLE__
+# define GLOBAL_COUNT 3000
+#else
+# define GLOBAL_COUNT 10000
+#endif
-#define GLOBAL_COUNT 10000
#define GLOBAL2_COUNT 100
-static pairs_st *global_pairs;
+using namespace libtest;
+
+static pairs_st *global_pairs= NULL;
static const char *global_keys[GLOBAL_COUNT];
static size_t global_keys_length[GLOBAL_COUNT];
static size_t global_count= 0;
-test_return_t cleanup_pairs(memcached_st *memc)
+test_return_t cleanup_pairs(memcached_st*)
{
- (void)memc;
pairs_free(global_pairs);
+ global_pairs= NULL;
return TEST_SUCCESS;
}
-test_return_t generate_pairs(memcached_st *)
+static test_return_t generate_pairs(memcached_st *)
{
global_pairs= pairs_generate(GLOBAL_COUNT, 400);
- global_count= GLOBAL_COUNT;
- for (size_t x= 0; x < global_count; x++)
+ for (size_t x= 0; x < GLOBAL_COUNT; ++x)
{
global_keys[x]= global_pairs[x].key;
global_keys_length[x]= global_pairs[x].key_length;
return TEST_SUCCESS;
}
-test_return_t generate_large_pairs(memcached_st *)
+test_return_t generate_large_pairs(memcached_st *memc)
{
global_pairs= pairs_generate(GLOBAL2_COUNT, MEMCACHED_MAX_BUFFER+10);
- global_count= GLOBAL2_COUNT;
- for (size_t x= 0; x < global_count; x++)
+ for (size_t x= 0; x < GLOBAL2_COUNT; x++)
{
global_keys[x]= global_pairs[x].key;
global_keys_length[x]= global_pairs[x].key_length;
}
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, true);
+ global_count= execute_set(memc, global_pairs, (unsigned int)GLOBAL2_COUNT);
+
+ ASSERT_TRUE(global_count > (GLOBAL2_COUNT / 2));
+
return TEST_SUCCESS;
}
test_return_t generate_data(memcached_st *memc)
{
- unsigned int check_execute= execute_set(memc, global_pairs, global_count);
+ test_compare(TEST_SUCCESS, generate_pairs(memc));
+
+ global_count= execute_set(memc, global_pairs, (unsigned int)GLOBAL_COUNT);
- test_compare_warn_hint(global_count, check_execute, "Possible false, positive, memcached may have ejected key/value based on memory needs");
+ /* Possible false, positive, memcached may have ejected key/value based on
+ * memory needs. */
+
+ ASSERT_TRUE(global_count > (GLOBAL2_COUNT / 2));
return TEST_SUCCESS;
}
test_return_t generate_data_with_stats(memcached_st *memc)
{
- unsigned int check_execute= execute_set(memc, global_pairs, global_count);
+ test_compare(TEST_SUCCESS, generate_pairs(memc));
+
+ global_count= execute_set(memc, global_pairs, (unsigned int)GLOBAL2_COUNT);
- test_compare(check_execute, global_count);
+ ASSERT_EQ(global_count, GLOBAL2_COUNT);
// @todo hosts used size stats
memcached_return_t rc;
/* This test was changes so that "make test" would work properlly */
if (DEBUG)
{
- memcached_server_instance_st instance=
+ const memcached_instance_st * instance=
memcached_server_instance_by_position(memc, host_index);
- printf("\nserver %u|%s|%u bytes: %llu\n", host_index, instance->hostname, instance->port, (unsigned long long)(stat_p + host_index)->bytes);
+ printf("\nserver %u|%s|%u bytes: %llu\n",
+ host_index,
+ memcached_server_name(instance),
+ memcached_server_port(instance),
+ (unsigned long long)(stat_p + host_index)->bytes);
}
test_true((unsigned long long)(stat_p + host_index)->bytes);
}
uint32_t flags;
uint32_t count;
- for (size_t x= count= 0; x < global_count; x++)
+ for (size_t x= count= 0; x < global_count; ++x)
{
memcached_return_t rc;
return_value= memcached_get(memc_clone, global_keys[x], global_keys_length[x],
test_return_t get_read(memcached_st *memc)
{
+ test::Memc clone(memc);
size_t keys_returned= 0;
- for (size_t x= 0; x < global_count; x++)
+ for (size_t x= 0; x < global_count; ++x)
{
size_t return_value_length;
uint32_t flags;
memcached_return_t rc;
- char *return_value= memcached_get(memc, global_keys[x], global_keys_length[x],
+ char *return_value= memcached_get(&clone, global_keys[x], global_keys_length[x],
&return_value_length, &flags, &rc);
/*
test_true(return_value);
free(return_value);
}
}
- test_compare_warn_hint(global_count, keys_returned, "Possible false, positive, memcached may have ejected key/value based on memory needs");
+ /*
+ Possible false, positive, memcached may have ejected key/value based on memory needs.
+ */
+ test_true(keys_returned > (global_count / 2));
return TEST_SUCCESS;
}
{
unsigned int keys_returned;
test_compare(TEST_SUCCESS, fetch_all_results(memc, keys_returned));
- test_true(keys_returned > 0);
- test_compare_warn_hint(global_count, keys_returned, "Possible false, positive, memcached may have ejected key/value based on memory needs");
+ test_true(keys_returned > (global_count / 2));
}
return TEST_SUCCESS;
total++;
}
}
- test_compare_warn_hint(global_count, total, "Possible false, positive, memcached may have ejected key/value based on memory needs");
+
+ /*
+ Possible false, positive, memcached may have ejected key/value based on memory needs.
+ */
+ ASSERT_TRUE(total);
return TEST_SUCCESS;
}
total++;
}
}
- test_compare_warn_hint(global_count, total, "Possible false, positive, memcached may have ejected key/value based on memory needs");
+
+ ASSERT_TRUE(total);
return TEST_SUCCESS;
}
projects / m6w6 / libmemcached / blobdiff