2 Sample test application.
11 #include "../lib/common.h"
13 long int timedif(struct timeval a
, struct timeval b
)
17 us
= a
.tv_usec
- b
.tv_usec
;
19 s
= a
.tv_sec
- b
.tv_sec
;
24 void init_test(memcached_st
*not_used
)
28 (void)memcached_create(&memc
);
29 memcached_free(&memc
);
32 void allocation_test(memcached_st
*not_used
)
35 memc
= memcached_create(NULL
);
40 void connection_test(memcached_st
*memc
)
44 rc
= memcached_server_add(memc
, "localhost", 0);
45 assert(rc
== MEMCACHED_SUCCESS
);
48 void error_test(memcached_st
*memc
)
52 for (rc
= MEMCACHED_SUCCESS
; rc
< MEMCACHED_MAXIMUM_RETURN
; rc
++)
54 printf("Error %d -> %s\n", rc
, memcached_strerror(memc
, rc
));
58 void set_test(memcached_st
*memc
)
62 char *value
= "when we sanitize";
64 rc
= memcached_set(memc
, key
, strlen(key
),
66 (time_t)0, (uint16_t)0);
67 assert(rc
== MEMCACHED_SUCCESS
);
70 void add_test(memcached_st
*memc
)
74 char *value
= "when we sanitize";
76 rc
= memcached_add(memc
, key
, strlen(key
),
78 (time_t)0, (uint16_t)0);
79 assert(rc
== MEMCACHED_NOTSTORED
);
82 void replace_test(memcached_st
*memc
)
86 char *value
= "when we sanitize";
88 rc
= memcached_replace(memc
, key
, strlen(key
),
90 (time_t)0, (uint16_t)0);
91 assert(rc
== MEMCACHED_SUCCESS
);
94 void delete_test(memcached_st
*memc
)
98 char *value
= "when we sanitize";
100 rc
= memcached_set(memc
, key
, strlen(key
),
101 value
, strlen(value
),
102 (time_t)0, (uint16_t)0);
103 assert(rc
== MEMCACHED_SUCCESS
);
105 rc
= memcached_delete(memc
, key
, strlen(key
), (time_t)0);
106 assert(rc
== MEMCACHED_SUCCESS
);
109 void flush_test(memcached_st
*memc
)
113 rc
= memcached_flush(memc
, 0);
114 assert(rc
== MEMCACHED_SUCCESS
);
117 void get_test(memcached_st
*memc
)
122 size_t string_length
;
125 rc
= memcached_delete(memc
, key
, strlen(key
), (time_t)0);
126 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOTFOUND
);
128 string
= memcached_get(memc
, key
, strlen(key
),
129 &string_length
, &flags
, &rc
);
131 assert(rc
== MEMCACHED_NOTFOUND
);
132 assert(string_length
== 0);
136 void get_test2(memcached_st
*memc
)
140 char *value
= "when we sanitize";
142 size_t string_length
;
145 rc
= memcached_set(memc
, key
, strlen(key
),
146 value
, strlen(value
),
147 (time_t)0, (uint16_t)0);
148 assert(rc
== MEMCACHED_SUCCESS
);
150 string
= memcached_get(memc
, key
, strlen(key
),
151 &string_length
, &flags
, &rc
);
154 assert(rc
== MEMCACHED_SUCCESS
);
155 assert(string_length
== strlen(value
));
156 assert(!memcmp(string
, value
, string_length
));
161 void set_test2(memcached_st
*memc
)
165 char *value
= "train in the brain";
166 size_t value_length
= strlen(value
);
169 for (x
= 0; x
< 10; x
++)
171 rc
= memcached_set(memc
, key
, strlen(key
),
173 (time_t)0, (uint16_t)0);
174 assert(rc
== MEMCACHED_SUCCESS
);
178 void set_test3(memcached_st
*memc
)
183 size_t value_length
= 8191;
186 value
= (char*)malloc(value_length
);
189 for (x
= 0; x
< value_length
; x
++)
190 value
[x
] = (char) (x
% 127);
192 for (x
= 0; x
< 1; x
++)
194 rc
= memcached_set(memc
, key
, strlen(key
),
196 (time_t)0, (uint16_t)0);
197 assert(rc
== MEMCACHED_SUCCESS
);
203 void get_test3(memcached_st
*memc
)
208 size_t value_length
= 8191;
210 size_t string_length
;
214 value
= (char*)malloc(value_length
);
217 for (x
= 0; x
< value_length
; x
++)
218 value
[x
] = (char) (x
% 127);
220 rc
= memcached_set(memc
, key
, strlen(key
),
222 (time_t)0, (uint16_t)0);
223 assert(rc
== MEMCACHED_SUCCESS
);
225 string
= memcached_get(memc
, key
, strlen(key
),
226 &string_length
, &flags
, &rc
);
228 assert(rc
== MEMCACHED_SUCCESS
);
230 assert(string_length
== value_length
);
231 assert(!memcmp(string
, value
, string_length
));
237 void get_test4(memcached_st
*memc
)
242 size_t value_length
= 8191;
244 size_t string_length
;
248 value
= (char*)malloc(value_length
);
251 for (x
= 0; x
< value_length
; x
++)
252 value
[x
] = (char) (x
% 127);
254 rc
= memcached_set(memc
, key
, strlen(key
),
256 (time_t)0, (uint16_t)0);
257 assert(rc
== MEMCACHED_SUCCESS
);
259 for (x
= 0; x
< 10; x
++)
261 string
= memcached_get(memc
, key
, strlen(key
),
262 &string_length
, &flags
, &rc
);
264 assert(rc
== MEMCACHED_SUCCESS
);
266 assert(string_length
== value_length
);
267 assert(!memcmp(string
, value
, string_length
));
274 void stats_servername_test(memcached_st
*memc
)
277 memcached_stat_st stat
;
278 rc
= memcached_stat_servername(&stat
, NULL
,
280 MEMCACHED_DEFAULT_PORT
);
283 void increment_test(memcached_st
*memc
)
285 unsigned int new_number
;
290 rc
= memcached_set(memc
, key
, strlen(key
),
291 value
, strlen(value
),
292 (time_t)0, (uint16_t)0);
293 assert(rc
== MEMCACHED_SUCCESS
);
295 rc
= memcached_increment(memc
, key
, strlen(key
),
297 assert(rc
== MEMCACHED_SUCCESS
);
298 assert(new_number
== 1);
300 rc
= memcached_increment(memc
, key
, strlen(key
),
302 assert(rc
== MEMCACHED_SUCCESS
);
303 assert(new_number
== 2);
306 void decrement_test(memcached_st
*memc
)
308 unsigned int new_number
;
313 rc
= memcached_set(memc
, key
, strlen(key
),
314 value
, strlen(value
),
315 (time_t)0, (uint16_t)0);
316 assert(rc
== MEMCACHED_SUCCESS
);
318 rc
= memcached_decrement(memc
, key
, strlen(key
),
320 assert(rc
== MEMCACHED_SUCCESS
);
321 assert(new_number
== 2);
323 rc
= memcached_decrement(memc
, key
, strlen(key
),
325 assert(rc
== MEMCACHED_SUCCESS
);
326 assert(new_number
== 1);
329 void quit_test(memcached_st
*memc
)
333 char *value
= "sanford and sun";
335 rc
= memcached_set(memc
, key
, strlen(key
),
336 value
, strlen(value
),
337 (time_t)10, (uint16_t)3);
338 assert(rc
== MEMCACHED_SUCCESS
);
339 memcached_quit(memc
);
341 rc
= memcached_set(memc
, key
, strlen(key
),
342 value
, strlen(value
),
343 (time_t)50, (uint16_t)9);
344 assert(rc
== MEMCACHED_SUCCESS
);
347 void mget_test(memcached_st
*memc
)
350 char *keys
[]= {"fudge", "son", "food"};
351 size_t key_length
[]= {5, 3, 4};
355 char return_key
[MEMCACHED_MAX_KEY
];
356 size_t return_key_length
;
358 size_t return_value_length
;
360 /* We need to empty the server before continueing test */
361 rc
= memcached_flush(memc
, 0);
362 assert(rc
== MEMCACHED_SUCCESS
);
364 rc
= memcached_mget(memc
, keys
, key_length
, 3);
365 assert(rc
== MEMCACHED_SUCCESS
);
367 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
368 &return_value_length
, &flags
, &rc
)) != NULL
)
370 assert(return_value
);
372 assert(!return_value
);
373 assert(return_value_length
== 0);
374 assert(rc
== MEMCACHED_NOTFOUND
);
376 for (x
= 0; x
< 3; x
++)
378 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
379 keys
[x
], key_length
[x
],
380 (time_t)50, (uint16_t)9);
381 assert(rc
== MEMCACHED_SUCCESS
);
384 rc
= memcached_mget(memc
, keys
, key_length
, 3);
385 assert(rc
== MEMCACHED_SUCCESS
);
388 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
389 &return_value_length
, &flags
, &rc
)))
391 assert(return_value
);
392 assert(rc
== MEMCACHED_SUCCESS
);
393 assert(return_key_length
== return_value_length
);
394 assert(!memcmp(return_value
, return_key
, return_value_length
));
400 void get_stats_keys(memcached_st
*memc
)
404 memcached_stat_st stat
;
407 list
= memcached_stat_get_keys(memc
, &stat
, &rc
);
408 assert(rc
== MEMCACHED_SUCCESS
);
409 for (ptr
= list
; *ptr
; ptr
++)
410 printf("Found key %s\n", *ptr
);
416 void get_stats(memcached_st
*memc
)
422 memcached_stat_st
*stat
;
424 stat
= memcached_stat(memc
, NULL
, &rc
);
425 assert(rc
== MEMCACHED_SUCCESS
);
427 assert(rc
== MEMCACHED_SUCCESS
);
430 for (x
= 0; x
< memcached_server_count(memc
); x
++)
432 list
= memcached_stat_get_keys(memc
, &stat
[x
], &rc
);
433 assert(rc
== MEMCACHED_SUCCESS
);
434 for (ptr
= list
; *ptr
; ptr
++)
435 printf("Found key %s\n", *ptr
);
443 void add_host_test(memcached_st
*memc
)
446 memcached_server_st
*servers
;
448 char servername
[]= "0.example.com";
450 servers
= memcached_server_list_append(NULL
, servername
, 400, &rc
);
452 assert(1 == memcached_server_list_count(servers
));
454 for (x
= 2; x
< 20; x
++)
456 char buffer
[SMALL_STRING_LEN
];
458 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
459 servers
= memcached_server_list_append(servers
, buffer
, 401,
461 assert(rc
== MEMCACHED_SUCCESS
);
462 assert(x
== memcached_server_list_count(servers
));
465 rc
= memcached_server_push(memc
, servers
);
466 assert(rc
== MEMCACHED_SUCCESS
);
467 rc
= memcached_server_push(memc
, servers
);
468 assert(rc
== MEMCACHED_SUCCESS
);
470 memcached_server_list_free(servers
);
473 /* We don't test the behavior itself, we test the switches */
474 void behavior_test(memcached_st
*memc
)
476 unsigned long long value
;
479 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, &set
);
480 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
483 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, &set
);
484 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
487 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_MD5_HASHING
, &set
);
488 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_MD5_HASHING
);
493 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, &set
);
494 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
497 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, &set
);
498 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
501 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_MD5_HASHING
, &set
);
502 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_MD5_HASHING
);
505 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
508 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
512 /* Test case provided by Cal Haldenbrand */
513 void user_supplied_bug1(memcached_st
*memc
)
515 unsigned int setter
= 1;
518 unsigned long long total
= 0;
521 char randomstuff
[6 * 1024];
524 memset(randomstuff
, 0, 6 * 1024);
526 /* We just keep looking at the same values over and over */
529 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, &setter
);
530 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, &setter
);
534 for (x
= 0 ; total
< 20 * 1024576 ; x
++ )
538 size
= (rand() % ( 5 * 1024 ) ) + 400;
539 memset(randomstuff
, 0, 6 * 1024);
540 assert(size
< 6 * 1024); /* Being safe here */
542 for (j
= 0 ; j
< size
;j
++)
543 randomstuff
[j
] = (char) (rand() % 26) + 97;
546 sprintf(key
, "%d", x
);
547 rc
= memcached_set(memc
, key
, strlen(key
),
548 randomstuff
, strlen(randomstuff
), 10, 0);
549 /* If we fail, lets try again */
550 if (rc
!= MEMCACHED_SUCCESS
)
551 rc
= memcached_set(memc
, key
, strlen(key
),
552 randomstuff
, strlen(randomstuff
), 10, 0);
553 assert(rc
== MEMCACHED_SUCCESS
);
557 /* Test case provided by Cal Haldenbrand */
558 void user_supplied_bug2(memcached_st
*memc
)
563 unsigned long long total
;
566 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, &setter
);
567 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, &setter
);
569 setter
= 20 * 1024576;
570 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, &setter
);
571 setter
= 20 * 1024576;
572 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, &setter
);
573 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
574 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
577 for (x
= 0, errors
= 0, total
= 0 ; total
< 20 * 1024576 ; x
++)
579 memcached_return rc
= MEMCACHED_SUCCESS
;
580 char buffer
[SMALL_STRING_LEN
];
585 memset(buffer
, 0, SMALL_STRING_LEN
);
587 snprintf(buffer
, SMALL_STRING_LEN
, "%u", x
);
588 getval
= memcached_get(memc
, buffer
, strlen(buffer
),
589 &val_len
, &flags
, &rc
);
590 if (rc
!= MEMCACHED_SUCCESS
)
592 if (rc
== MEMCACHED_NOTFOUND
)
605 /* Do a large mget() over all the keys we think exist */
606 #define KEY_COUNT 3000 // * 1024576
607 void user_supplied_bug3(memcached_st
*memc
)
613 size_t key_lengths
[KEY_COUNT
];
616 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, &setter
);
617 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, &setter
);
619 setter
= 20 * 1024576;
620 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, &setter
);
621 setter
= 20 * 1024576;
622 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, &setter
);
623 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
624 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
627 keys
= (char **)malloc(sizeof(char *) * KEY_COUNT
);
629 memset(keys
, 0, (sizeof(char *) * KEY_COUNT
));
630 for (x
= 0; x
< KEY_COUNT
; x
++)
634 snprintf(buffer
, 30, "%u", x
);
635 keys
[x
]= strdup(buffer
);
636 key_lengths
[x
]= strlen(keys
[x
]);
639 rc
= memcached_mget(memc
, keys
, key_lengths
, KEY_COUNT
);
640 assert(rc
== MEMCACHED_SUCCESS
);
642 /* Turn this into a help function */
645 size_t return_key_length
;
647 size_t return_value_length
;
650 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
651 &return_value_length
, &flags
, &rc
)))
653 assert(return_value
);
654 assert(rc
== MEMCACHED_SUCCESS
);
659 for (x
= 0; x
< KEY_COUNT
; x
++)
664 void string_alloc_null(memcached_st
*memc
)
666 memcached_string_st
*string
;
668 string
= memcached_string_create(memc
, 0);
670 memcached_string_free(memc
, string
);
673 void string_alloc_with_size(memcached_st
*memc
)
675 memcached_string_st
*string
;
677 string
= memcached_string_create(memc
, 1024);
679 memcached_string_free(memc
, string
);
682 void string_alloc_with_size_toobig(memcached_st
*memc
)
684 memcached_string_st
*string
;
686 string
= memcached_string_create(memc
, 1024*100000000000);
687 assert(string
== NULL
);
690 void string_alloc_append(memcached_st
*memc
)
693 char buffer
[SMALL_STRING_LEN
];
694 memcached_string_st
*string
;
697 memset(buffer
, 6, SMALL_STRING_LEN
);
699 string
= memcached_string_create(memc
, 100);
702 for (x
= 0; x
< 1024; x
++)
705 rc
= memcached_string_append(memc
, string
, buffer
, SMALL_STRING_LEN
);
706 assert(rc
== MEMCACHED_SUCCESS
);
708 memcached_string_free(memc
, string
);
711 void string_alloc_append_toobig(memcached_st
*memc
)
715 char buffer
[SMALL_STRING_LEN
];
716 memcached_string_st
*string
;
719 memset(buffer
, 6, SMALL_STRING_LEN
);
721 string
= memcached_string_create(memc
, 100);
724 for (x
= 0; x
< 1024; x
++)
726 rc
= memcached_string_append(memc
, string
, buffer
, SMALL_STRING_LEN
);
727 assert(rc
== MEMCACHED_SUCCESS
);
729 rc
= memcached_string_append(memc
, string
, buffer
, 1024*100000000000);
730 assert(rc
== MEMCACHED_MEMORY_ALLOCATION_FAILURE
);
731 memcached_string_free(memc
, string
);
734 void add_host_test1(memcached_st
*memc
)
738 char servername
[]= "0.example.com";
739 memcached_server_st
*servers
;
741 servers
= memcached_server_list_append(NULL
, servername
, 400, &rc
);
743 assert(1 == memcached_server_list_count(servers
));
745 for (x
= 2; x
< 20; x
++)
747 char buffer
[SMALL_STRING_LEN
];
749 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
750 servers
= memcached_server_list_append(servers
, buffer
, 401,
752 assert(rc
== MEMCACHED_SUCCESS
);
753 assert(x
== memcached_server_list_count(servers
));
756 rc
= memcached_server_push(memc
, servers
);
757 assert(rc
== MEMCACHED_SUCCESS
);
758 rc
= memcached_server_push(memc
, servers
);
759 assert(rc
== MEMCACHED_SUCCESS
);
761 memcached_server_list_free(servers
);
764 typedef struct test_st test_st
;
768 unsigned int requires_flush
;
769 void (*function
)(memcached_st
*memc
);
772 int main(int argc
, char *argv
[])
776 char *test_to_run
= NULL
;
777 char *wildcard
= NULL
;
778 memcached_server_st
*servers
;
781 test_to_run
= argv
[1];
786 if (!(server_list
= getenv("MEMCACHED_SERVERS")))
787 server_list
= "localhost";
789 printf("servers %s\n", server_list
);
792 servers
= memcached_servers_parse(server_list
);
795 for (x
= 0; x
< memcached_server_list_count(servers
); x
++)
797 printf("\t%s : %u\n", servers
[x
].hostname
, servers
[x
].port
);
798 assert(servers
[x
].stack_responses
== 0);
799 assert(servers
[x
].fd
== -1);
800 assert(servers
[x
].cursor_active
== 0);
805 /* Clean the server before beginning testing */
807 {"flush", 0, flush_test
},
808 {"init", 0, init_test
},
809 {"allocation", 0, allocation_test
},
810 {"error", 0, error_test
},
811 {"set", 0, set_test
},
812 {"set2", 0, set_test2
},
813 {"set3", 0, set_test3
},
814 {"add", 0, add_test
},
815 {"replace", 0, replace_test
},
816 {"delete", 1, delete_test
},
817 {"get", 1, get_test
},
818 {"get2", 0, get_test2
},
819 {"get3", 0, get_test3
},
820 {"get4", 0, get_test4
},
821 {"stats_servername", 0, stats_servername_test
},
822 {"increment", 0, increment_test
},
823 {"decrement", 0, decrement_test
},
824 {"quit", 0, quit_test
},
825 {"mget", 0, mget_test
},
826 {"get_stats", 0, get_stats
},
827 {"add_host_test", 0, add_host_test
},
828 {"get_stats_keys", 0, get_stats_keys
},
829 {"behavior_test", 0, get_stats_keys
},
833 test_st string_tests
[] ={
834 {"string alloc with null", 0, string_alloc_null
},
835 {"string alloc with 1K", 0, string_alloc_with_size
},
836 {"string alloc with malloc failure", 0, string_alloc_with_size_toobig
},
837 {"string append", 0, string_alloc_append
},
838 {"string append failure (too big)", 0, string_alloc_append_toobig
},
842 test_st user_tests
[] ={
843 {"user_supplied_bug1", 0, user_supplied_bug1
},
844 {"user_supplied_bug2", 0, user_supplied_bug2
},
845 // {"user_supplied_bug3", 0, user_supplied_bug3 },
849 if ((test_to_run
&& !strcmp(test_to_run
, "block")) || !test_to_run
)
851 fprintf(stderr
, "\nBlock tests\n\n");
852 for (x
= 0; tests
[x
].function_name
; x
++)
855 if (strcmp(wildcard
, tests
[x
].function_name
))
860 struct timeval start_time
, end_time
;
862 memc
= memcached_create(NULL
);
865 if (tests
[x
].requires_flush
)
866 memcached_flush(memc
, 0);
868 rc
= memcached_server_push(memc
, servers
);
869 assert(rc
== MEMCACHED_SUCCESS
);
872 for (loop
= 0; loop
< memcached_server_list_count(servers
); loop
++)
874 assert(memc
->hosts
[loop
].stack_responses
== 0);
875 assert(memc
->hosts
[loop
].fd
== -1);
876 assert(memc
->hosts
[loop
].cursor_active
== 0);
879 fprintf(stderr
, "Testing %s", tests
[x
].function_name
);
880 gettimeofday(&start_time
, NULL
);
881 tests
[x
].function(memc
);
882 gettimeofday(&end_time
, NULL
);
883 long int load_time
= timedif(end_time
, start_time
);
884 fprintf(stderr
, "\t\t\t\t\t %ld.%03ld [ ok ]\n", load_time
/ 1000,
887 memcached_free(memc
);
891 if ((test_to_run
&& !strcmp(test_to_run
, "nonblock")) || !test_to_run
)
893 fprintf(stderr
, "\nNonblock tests\n\n");
894 for (x
= 0; tests
[x
].function_name
; x
++)
897 if (strcmp(wildcard
, tests
[x
].function_name
))
902 struct timeval start_time
, end_time
;
904 memc
= memcached_create(NULL
);
907 if (tests
[x
].requires_flush
)
908 memcached_flush(memc
, 0);
910 rc
= memcached_server_push(memc
, servers
);
911 assert(rc
== MEMCACHED_SUCCESS
);
913 fprintf(stderr
, "Testing %s", tests
[x
].function_name
);
914 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, NULL
);
915 gettimeofday(&start_time
, NULL
);
916 tests
[x
].function(memc
);
917 gettimeofday(&end_time
, NULL
);
918 long int load_time
= timedif(end_time
, start_time
);
919 fprintf(stderr
, "\t\t\t\t\t %ld.%03ld [ ok ]\n", load_time
/ 1000,
922 memcached_free(memc
);
926 if ((test_to_run
&& !strcmp(test_to_run
, "nodelay")) || !test_to_run
)
928 fprintf(stderr
, "\nTCP Nodelay tests\n\n");
929 for (x
= 0; tests
[x
].function_name
; x
++)
932 if (strcmp(wildcard
, tests
[x
].function_name
))
937 struct timeval start_time
, end_time
;
939 memc
= memcached_create(NULL
);
942 if (tests
[x
].requires_flush
)
943 memcached_flush(memc
, 0);
945 rc
= memcached_server_push(memc
, servers
);
946 assert(rc
== MEMCACHED_SUCCESS
);
948 fprintf(stderr
, "Testing %s", tests
[x
].function_name
);
949 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, NULL
);
950 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, NULL
);
951 gettimeofday(&start_time
, NULL
);
952 tests
[x
].function(memc
);
953 gettimeofday(&end_time
, NULL
);
954 long int load_time
= timedif(end_time
, start_time
);
955 fprintf(stderr
, "\t\t\t\t\t %ld.%03ld [ ok ]\n", load_time
/ 1000,
958 memcached_free(memc
);
962 if ((test_to_run
&& !strcmp(test_to_run
, "md5")) || !test_to_run
)
964 fprintf(stderr
, "\nMD5 Hashing\n\n");
965 for (x
= 0; tests
[x
].function_name
; x
++)
968 if (strcmp(wildcard
, tests
[x
].function_name
))
973 struct timeval start_time
, end_time
;
975 memc
= memcached_create(NULL
);
978 if (tests
[x
].requires_flush
)
979 memcached_flush(memc
, 0);
981 rc
= memcached_server_push(memc
, servers
);
982 assert(rc
== MEMCACHED_SUCCESS
);
984 fprintf(stderr
, "Testing %s", tests
[x
].function_name
);
985 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_MD5_HASHING
, NULL
);
986 gettimeofday(&start_time
, NULL
);
987 tests
[x
].function(memc
);
988 gettimeofday(&end_time
, NULL
);
989 long int load_time
= timedif(end_time
, start_time
);
990 fprintf(stderr
, "\t\t\t\t\t %ld.%03ld [ ok ]\n", load_time
/ 1000,
993 memcached_free(memc
);
997 if ((test_to_run
&& !strcmp(test_to_run
, "string")) || !test_to_run
)
999 fprintf(stderr
, "\nString tests (internal API)\n\n");
1000 for (x
= 0; string_tests
[x
].function_name
; x
++)
1003 if (strcmp(wildcard
, string_tests
[x
].function_name
))
1007 memcached_return rc
;
1008 struct timeval start_time
, end_time
;
1010 memc
= memcached_create(NULL
);
1013 if (tests
[x
].requires_flush
)
1014 memcached_flush(memc
, 0);
1016 rc
= memcached_server_push(memc
, servers
);
1017 assert(rc
== MEMCACHED_SUCCESS
);
1019 fprintf(stderr
, "Testing %s", string_tests
[x
].function_name
);
1020 gettimeofday(&start_time
, NULL
);
1021 string_tests
[x
].function(memc
);
1022 gettimeofday(&end_time
, NULL
);
1023 long int load_time
= timedif(end_time
, start_time
);
1024 fprintf(stderr
, "\t\t\t\t\t %ld.%03ld [ ok ]\n", load_time
/ 1000,
1027 memcached_free(memc
);
1031 if ((test_to_run
&& !strcmp(test_to_run
, "user")) || !test_to_run
)
1033 fprintf(stderr
, "\nUser Supplied tests\n\n");
1034 for (x
= 0; user_tests
[x
].function_name
; x
++)
1037 if (strcmp(wildcard
, user_tests
[x
].function_name
))
1041 memcached_return rc
;
1042 struct timeval start_time
, end_time
;
1044 memc
= memcached_create(NULL
);
1047 if (tests
[x
].requires_flush
)
1048 memcached_flush(memc
, 0);
1050 rc
= memcached_server_push(memc
, servers
);
1051 assert(rc
== MEMCACHED_SUCCESS
);
1053 fprintf(stderr
, "Testing %s", user_tests
[x
].function_name
);
1054 gettimeofday(&start_time
, NULL
);
1055 user_tests
[x
].function(memc
);
1056 gettimeofday(&end_time
, NULL
);
1057 long int load_time
= timedif(end_time
, start_time
);
1058 fprintf(stderr
, "\t\t\t\t\t %ld.%03ld [ ok ]\n", load_time
/ 1000,
1061 memcached_free(memc
);
1065 /* Clean up whatever we might have left */
1068 memc
= memcached_create(NULL
);
1071 memcached_free(memc
);
1074 fprintf(stderr
, "All tests completed successfully\n\n");
1076 memcached_server_list_free(servers
);