#include <sys/stat.h>
#include <unistd.h>
#include <time.h>
+#include "server.h"
#include "../lib/common.h"
#include "../src/generator.h"
#include "../src/execute.h"
return 0;
}
+uint8_t server_sort_test(memcached_st *ptr)
+{
+ unsigned int setting;
+ memcached_server_st *server_list;
+ memcached_return rc;
+
+ setting= 1;
+ memcached_behavior_set(ptr, MEMCACHED_BEHAVIOR_SORT_HOSTS, &setting);
+
+ server_list= memcached_server_list_append(NULL, "arg", 0, &rc);
+ assert(server_list);
+
+ server_list= memcached_server_list_append(server_list, "localhost", 0, &rc);
+ assert(server_list);
+
+ server_list= memcached_server_list_append(server_list, "c", 0, &rc);
+ assert(server_list);
+
+ server_list= memcached_server_list_append(server_list, "abba", 0, &rc);
+ assert(server_list);
+
+ free(server_list);
+
+ return 0;
+}
+
uint8_t allocation_test(memcached_st *not_used)
{
memcached_st *memc;
assert(strlen("we the people") == value_length);
assert(rc == MEMCACHED_SUCCESS);
+ rc= memcached_cas(memc, key, key_length,
+ "change the value", strlen("change the value"),
+ 0, 0, memcached_result_cas(results));
+
+ assert(rc == MEMCACHED_SUCCESS);
+
+ rc= memcached_cas(memc, key, key_length,
+ "change the value", strlen("change the value"),
+ 0, 0, 23);
+
+ assert(rc == MEMCACHED_DATA_EXISTS);
+
+
memcached_result_free(&results_obj);
return 0;
memcached_return rc;
char *key= "foo";
char *value= "when we sanitize";
+ char *original= "first we insert some data";
+
+ rc= memcached_set(memc, key, strlen(key),
+ original, strlen(original),
+ (time_t)0, (uint32_t)0);
+ assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
rc= memcached_replace(memc, key, strlen(key),
value, strlen(value),
return 0;
}
+uint8_t bad_key_test(memcached_st *memc)
+{
+ memcached_return rc;
+ char *key= "foo bad";
+ char *string;
+ size_t string_length;
+ uint32_t flags;
+ memcached_st *clone;
+ unsigned int set= 1;
+
+ clone= memcached_clone(NULL, memc);
+ assert(clone);
+
+ (void)memcached_behavior_set(clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, &set);
+
+ string= memcached_get(clone, key, strlen(key),
+ &string_length, &flags, &rc);
+ assert(rc == MEMCACHED_BAD_KEY_PROVIDED);
+ assert(string_length == 0);
+ assert(!string);
+
+ set= 0;
+ (void)memcached_behavior_set(clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, &set);
+ string= memcached_get(clone, key, strlen(key),
+ &string_length, &flags, &rc);
+ assert(rc == MEMCACHED_NOTFOUND);
+ assert(string_length == 0);
+ assert(!string);
+
+ memcached_free(clone);
+
+ return 0;
+}
+
uint8_t get_test(memcached_st *memc)
{
memcached_return rc;
rc= memcached_set(memc, key, strlen(key),
value, value_length,
(time_t)0, (uint32_t)0);
+ WATCHPOINT_ERROR(rc);
assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
}
Test values of many different sizes
Bug found where command total one more than MEMCACHED_MAX_BUFFER
set key34567890 0 0 8169 \r\n
- is sent
- followed by buffer of size 8169, followed by 8169
+ is sent followed by buffer of size 8169, followed by 8169
*/
uint8_t user_supplied_bug14(memcached_st *memc)
{
for (x= 0; x < value_length; x++)
value[x] = (char) (x % 127);
- for (current_length = 0; current_length < value_length; current_length++)
+ for (current_length= 1; current_length < value_length; current_length++)
{
rc= memcached_set(memc, key, strlen(key),
value, current_length,
{"init", 0, init_test },
{"allocation", 0, allocation_test },
{"server_list_null_test", 0, server_list_null_test},
+ {"server_sort", 0, server_sort_test},
{"clone_test", 0, clone_test },
{"error", 0, error_test },
{"set", 0, set_test },
{"set2", 0, set_test2 },
{"set3", 0, set_test3 },
{"add", 1, add_test },
- {"replace", 0, replace_test },
+ {"replace", 1, replace_test },
{"delete", 1, delete_test },
{"get", 1, get_test },
{"get2", 0, get_test2 },
{"behavior_test", 0, get_stats_keys },
{"callback_test", 0, get_stats_keys },
{"version_string_test", 0, version_string_test},
+ {"bad_key", 1, bad_key_test },
{0, 0, 0}
};
{0, 0, 0, 0}
};
-collection_st *gets_collections(void)
+#define SERVERS_TO_CREATE 5
+
+void *world_create(void)
+{
+ server_startup_st *construct;
+
+ construct= (server_startup_st *)malloc(sizeof(server_startup_st));
+ memset(construct, 0, sizeof(server_startup_st));
+ construct->count= SERVERS_TO_CREATE;
+ construct->udp= 0;
+ server_startup(construct);
+
+ return construct;
+}
+
+void world_destroy(void *p)
+{
+ server_startup_st *construct= (server_startup_st *)p;
+ memcached_server_st *servers= (memcached_server_st *)construct->servers;
+ memcached_server_list_free(servers);
+
+ server_shutdown(construct);
+ free(construct);
+}
+
+void get_world(world_st *world)
{
- return collection;
+ world->collections= collection;
+ world->create= world_create;
+ world->destroy= world_destroy;
}