#include <stdio.h>
#include <stdlib.h>
#include <string.h>
+#include <sys/time.h>
+
+long int timedif(struct timeval a, struct timeval b)
+{
+ register int us, s;
+
+ us = a.tv_usec - b.tv_usec;
+ us /= 1000;
+ s = a.tv_sec - b.tv_sec;
+ s *= 1000;
+ return s + us;
+}
void init_test(memcached_st *not_used)
{
string= memcached_get(memc, key, strlen(key),
&string_length, &flags, &rc);
+ WATCHPOINT_ERRNO(memc->my_errno);
+ WATCHPOINT_ERROR(rc);
assert(rc == MEMCACHED_SUCCESS);
assert(string);
assert(string_length == value_length);
assert(rc == MEMCACHED_SUCCESS);
for (ptr= list; *ptr; ptr++)
printf("Found key %s\n", *ptr);
+ fflush(stdout);
free(list);
}
memcached_server_list_free(servers);
}
+/* We don't test the behavior itself, we test the switches */
+void behavior_test(memcached_st *memc)
+{
+ unsigned long long value;
+ unsigned int set= 1;
+
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, &set);
+ value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK);
+ assert(value == 1);
+
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, &set);
+ value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY);
+ assert(value == 1);
+
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_MD5_HASHING, &set);
+ value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_MD5_HASHING);
+ assert(value == 1);
+
+ set= 0;
+
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, &set);
+ value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK);
+ assert(value == 0);
+
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, &set);
+ value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY);
+ assert(value == 0);
+
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_MD5_HASHING, &set);
+ value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_MD5_HASHING);
+ assert(value == 0);
+}
+
+/* Test case provided by Cal Haldenbrand */
+void user_supplied_bug1(memcached_st *memc)
+{
+ unsigned int setter= 1;
+ unsigned int x;
+
+ long total= 0;
+ int size= 0;
+ srand(time(NULL));
+ char key[10];
+ char *randomstuff = (char *)malloc(6 * 1024);
+ memset(randomstuff, 0, 6 * 1024);
+
+ memcached_return rc;
+
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, &setter);
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, &setter);
+
+
+ /* add key */
+ for (x= 0 ; total < 20 * 1024576 ; x++ )
+ {
+ unsigned int j= 0;
+
+ size= (rand() % ( 5 * 1024 ) ) + 400;
+ memset(randomstuff, 0, 6 * 1024);
+ assert(size < 6 * 1024); /* Being safe here */
+
+ for (j= 0 ; j < size ;j++)
+ randomstuff[j] = (char) (rand() % 26) + 97;
+
+ total += size;
+ sprintf(key, "%d", x);
+ rc = memcached_set(memc, key, strlen(key),
+ randomstuff, strlen(randomstuff), 10, 0);
+ /* If we fail, lets try again */
+ if (rc != MEMCACHED_SUCCESS)
+ rc = memcached_set(memc, key, strlen(key),
+ randomstuff, strlen(randomstuff), 10, 0);
+ assert(rc == MEMCACHED_SUCCESS);
+ }
+}
void add_host_test1(memcached_st *memc)
{
unsigned int x;
{
unsigned int x;
char *server_list;
+ char *test_to_run= NULL;
+ char *wildcard= NULL;
memcached_server_st *servers;
+ if (argc > 2)
+ test_to_run= argv[1];
+
+ if (argc == 3)
+ wildcard= argv[2];
+
if (!(server_list= getenv("MEMCACHED_SERVERS")))
server_list= "localhost";
printf("servers %s\n", server_list);
+ srandom(time(NULL));
servers= memcached_servers_parse(server_list);
assert(servers);
+ for (x= 0; x < memcached_server_list_count(servers); x++)
+ {
+ printf("\t%s : %u\n", servers[x].hostname, servers[x].port);
+ assert(servers[x].stack_responses == 0);
+ assert(servers[x].fd == -1);
+ assert(servers[x].cursor_active == 0);
+ }
+
+ printf("\n");
+
/* Clean the server before beginning testing */
test_st tests[] ={
{"flush", 0, flush_test },
{"get_stats", 0, get_stats },
{"add_host_test", 0, add_host_test },
{"get_stats_keys", 0, get_stats_keys },
+ {"behavior_test", 0, get_stats_keys },
{0, 0, 0}
};
- fprintf(stderr, "\nBlock tests\n\n");
- for (x= 0; tests[x].function_name; x++)
- {
- memcached_st *memc;
- memcached_return rc;
- memc= memcached_create(NULL);
- assert(memc);
-
- rc= memcached_server_push(memc, servers);
- assert(rc == MEMCACHED_SUCCESS);
+ test_st user_tests[] ={
+ {"user_supplied_bug1", 0, user_supplied_bug1 },
+ {0, 0, 0}
+ };
- fprintf(stderr, "Testing %s", tests[x].function_name);
- tests[x].function(memc);
- fprintf(stderr, "\t\t\t\t\t[ ok ]\n");
- assert(memc);
- memcached_free(memc);
+ if ((test_to_run && !strcmp(test_to_run, "block")) || !test_to_run)
+ {
+ fprintf(stderr, "\nBlock tests\n\n");
+ for (x= 0; tests[x].function_name; x++)
+ {
+ if (wildcard)
+ if (strcmp(wildcard, tests[x].function_name))
+ continue;
+
+ memcached_st *memc;
+ memcached_return rc;
+ struct timeval start_time, end_time;
+
+ memc= memcached_create(NULL);
+ assert(memc);
+
+ rc= memcached_server_push(memc, servers);
+ assert(rc == MEMCACHED_SUCCESS);
+
+ unsigned int loop;
+ for (loop= 0; loop < memcached_server_list_count(servers); loop++)
+ {
+ assert(memc->hosts[loop].stack_responses == 0);
+ assert(memc->hosts[loop].fd == -1);
+ assert(memc->hosts[loop].cursor_active == 0);
+ }
+
+ fprintf(stderr, "Testing %s", tests[x].function_name);
+ gettimeofday(&start_time, NULL);
+ tests[x].function(memc);
+ gettimeofday(&end_time, NULL);
+ long int load_time= timedif(end_time, start_time);
+ fprintf(stderr, "\t\t\t\t\t %ld.%03ld [ ok ]\n", load_time / 1000,
+ load_time % 1000);
+ assert(memc);
+ memcached_free(memc);
+ }
}
- fprintf(stderr, "\nNonblock tests\n\n");
- for (x= 0; tests[x].function_name; x++)
+ if ((test_to_run && !strcmp(test_to_run, "nonblock")) || !test_to_run)
{
- memcached_st *memc;
- memcached_return rc;
- memc= memcached_create(NULL);
- assert(memc);
-
- rc= memcached_server_push(memc, servers);
- assert(rc == MEMCACHED_SUCCESS);
-
- fprintf(stderr, "Testing %s", tests[x].function_name);
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, NULL);
- tests[x].function(memc);
- fprintf(stderr, "\t\t\t\t\t[ ok ]\n");
- assert(memc);
- memcached_free(memc);
+ fprintf(stderr, "\nNonblock tests\n\n");
+ for (x= 0; tests[x].function_name; x++)
+ {
+ if (wildcard)
+ if (strcmp(wildcard, tests[x].function_name))
+ continue;
+
+ memcached_st *memc;
+ memcached_return rc;
+ struct timeval start_time, end_time;
+
+ memc= memcached_create(NULL);
+ assert(memc);
+
+ rc= memcached_server_push(memc, servers);
+ assert(rc == MEMCACHED_SUCCESS);
+
+ fprintf(stderr, "Testing %s", tests[x].function_name);
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, NULL);
+ gettimeofday(&start_time, NULL);
+ tests[x].function(memc);
+ gettimeofday(&end_time, NULL);
+ long int load_time= timedif(end_time, start_time);
+ fprintf(stderr, "\t\t\t\t\t %ld.%03ld [ ok ]\n", load_time / 1000,
+ load_time % 1000);
+ assert(memc);
+ memcached_free(memc);
+ }
}
- fprintf(stderr, "\nTCP Nodelay tests\n\n");
- for (x= 0; tests[x].function_name; x++)
+ if ((test_to_run && !strcmp(test_to_run, "nodelay")) || !test_to_run)
{
- memcached_st *memc;
- memcached_return rc;
- memc= memcached_create(NULL);
- assert(memc);
+ fprintf(stderr, "\nTCP Nodelay tests\n\n");
+ for (x= 0; tests[x].function_name; x++)
+ {
+ if (wildcard)
+ if (strcmp(wildcard, tests[x].function_name))
+ continue;
+
+ memcached_st *memc;
+ memcached_return rc;
+ struct timeval start_time, end_time;
+
+ memc= memcached_create(NULL);
+ assert(memc);
+
+ rc= memcached_server_push(memc, servers);
+ assert(rc == MEMCACHED_SUCCESS);
+
+ fprintf(stderr, "Testing %s", tests[x].function_name);
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, NULL);
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, NULL);
+ gettimeofday(&start_time, NULL);
+ tests[x].function(memc);
+ gettimeofday(&end_time, NULL);
+ long int load_time= timedif(end_time, start_time);
+ fprintf(stderr, "\t\t\t\t\t %ld.%03ld [ ok ]\n", load_time / 1000,
+ load_time % 1000);
+ assert(memc);
+ memcached_free(memc);
+ }
+ }
- rc= memcached_server_push(memc, servers);
- assert(rc == MEMCACHED_SUCCESS);
+ if ((test_to_run && !strcmp(test_to_run, "md5")) || !test_to_run)
+ {
+ fprintf(stderr, "\nMD5 Hashing\n\n");
+ for (x= 0; tests[x].function_name; x++)
+ {
+ if (wildcard)
+ if (strcmp(wildcard, tests[x].function_name))
+ continue;
+
+ memcached_st *memc;
+ memcached_return rc;
+ struct timeval start_time, end_time;
+
+ memc= memcached_create(NULL);
+ assert(memc);
+
+ rc= memcached_server_push(memc, servers);
+ assert(rc == MEMCACHED_SUCCESS);
+
+ fprintf(stderr, "Testing %s", tests[x].function_name);
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_MD5_HASHING, NULL);
+ gettimeofday(&start_time, NULL);
+ tests[x].function(memc);
+ gettimeofday(&end_time, NULL);
+ long int load_time= timedif(end_time, start_time);
+ fprintf(stderr, "\t\t\t\t\t %ld.%03ld [ ok ]\n", load_time / 1000,
+ load_time % 1000);
+ assert(memc);
+ memcached_free(memc);
+ }
+ }
- fprintf(stderr, "Testing %s", tests[x].function_name);
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, NULL);
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, NULL);
- tests[x].function(memc);
- fprintf(stderr, "\t\t\t\t\t[ ok ]\n");
- assert(memc);
- memcached_free(memc);
+ if ((test_to_run && !strcmp(test_to_run, "user")) || !test_to_run)
+ {
+ fprintf(stderr, "\nUser Supplied tests\n\n");
+ for (x= 0; user_tests[x].function_name; x++)
+ {
+ if (wildcard)
+ if (strcmp(wildcard, tests[x].function_name))
+ continue;
+
+ memcached_st *memc;
+ memcached_return rc;
+ struct timeval start_time, end_time;
+
+ memc= memcached_create(NULL);
+ assert(memc);
+
+ rc= memcached_server_push(memc, servers);
+ assert(rc == MEMCACHED_SUCCESS);
+
+ fprintf(stderr, "Testing %s", user_tests[x].function_name);
+ gettimeofday(&start_time, NULL);
+ user_tests[x].function(memc);
+ gettimeofday(&end_time, NULL);
+ long int load_time= timedif(end_time, start_time);
+ fprintf(stderr, "\t\t\t\t\t %ld.%03ld [ ok ]\n", load_time / 1000,
+ load_time % 1000);
+ assert(memc);
+ memcached_free(memc);
+ }
}
/* Clean up whatever we might have left */
flush_test(memc);
memcached_free(memc);
}
+
+ fprintf(stderr, "All tests completed successfully\n\n");
+
return 0;
}
projects / awesomized / libmemcached / blobdiff