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 */
644 char return_key
[MEMCACHED_MAX_KEY
];
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
, UINT64_MAX
);
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
);
730 rc
= memcached_string_append(memc
, string
, buffer
, UINT64_MAX
);
732 assert(rc
== MEMCACHED_MEMORY_ALLOCATION_FAILURE
);
733 memcached_string_free(memc
, string
);
736 void add_host_test1(memcached_st
*memc
)
740 char servername
[]= "0.example.com";
741 memcached_server_st
*servers
;
743 servers
= memcached_server_list_append(NULL
, servername
, 400, &rc
);
745 assert(1 == memcached_server_list_count(servers
));
747 for (x
= 2; x
< 20; x
++)
749 char buffer
[SMALL_STRING_LEN
];
751 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
752 servers
= memcached_server_list_append(servers
, buffer
, 401,
754 assert(rc
== MEMCACHED_SUCCESS
);
755 assert(x
== memcached_server_list_count(servers
));
758 rc
= memcached_server_push(memc
, servers
);
759 assert(rc
== MEMCACHED_SUCCESS
);
760 rc
= memcached_server_push(memc
, servers
);
761 assert(rc
== MEMCACHED_SUCCESS
);
763 memcached_server_list_free(servers
);
766 typedef struct test_st test_st
;
770 unsigned int requires_flush
;
771 void (*function
)(memcached_st
*memc
);
774 int main(int argc
, char *argv
[])
778 char *test_to_run
= NULL
;
779 char *wildcard
= NULL
;
780 memcached_server_st
*servers
;
783 test_to_run
= argv
[1];
788 if (!(server_list
= getenv("MEMCACHED_SERVERS")))
789 server_list
= "localhost";
791 printf("servers %s\n", server_list
);
794 servers
= memcached_servers_parse(server_list
);
797 for (x
= 0; x
< memcached_server_list_count(servers
); x
++)
799 printf("\t%s : %u\n", servers
[x
].hostname
, servers
[x
].port
);
800 assert(servers
[x
].stack_responses
== 0);
801 assert(servers
[x
].fd
== -1);
802 assert(servers
[x
].cursor_active
== 0);
807 /* Clean the server before beginning testing */
809 {"flush", 0, flush_test
},
810 {"init", 0, init_test
},
811 {"allocation", 0, allocation_test
},
812 {"error", 0, error_test
},
813 {"set", 0, set_test
},
814 {"set2", 0, set_test2
},
815 {"set3", 0, set_test3
},
816 {"add", 0, add_test
},
817 {"replace", 0, replace_test
},
818 {"delete", 1, delete_test
},
819 {"get", 1, get_test
},
820 {"get2", 0, get_test2
},
821 {"get3", 0, get_test3
},
822 {"get4", 0, get_test4
},
823 {"stats_servername", 0, stats_servername_test
},
824 {"increment", 0, increment_test
},
825 {"decrement", 0, decrement_test
},
826 {"quit", 0, quit_test
},
827 {"mget", 0, mget_test
},
828 {"get_stats", 0, get_stats
},
829 {"add_host_test", 0, add_host_test
},
830 {"get_stats_keys", 0, get_stats_keys
},
831 {"behavior_test", 0, get_stats_keys
},
835 test_st string_tests
[] ={
836 {"string alloc with null", 0, string_alloc_null
},
837 {"string alloc with 1K", 0, string_alloc_with_size
},
838 {"string alloc with malloc failure", 0, string_alloc_with_size_toobig
},
839 {"string append", 0, string_alloc_append
},
840 {"string append failure (too big)", 0, string_alloc_append_toobig
},
844 test_st user_tests
[] ={
845 {"user_supplied_bug1", 0, user_supplied_bug1
},
846 {"user_supplied_bug2", 0, user_supplied_bug2
},
847 // {"user_supplied_bug3", 0, user_supplied_bug3 },
851 if ((test_to_run
&& !strcmp(test_to_run
, "block")) || !test_to_run
)
853 fprintf(stderr
, "\nBlock tests\n\n");
854 for (x
= 0; tests
[x
].function_name
; x
++)
857 if (strcmp(wildcard
, tests
[x
].function_name
))
862 struct timeval start_time
, end_time
;
864 memc
= memcached_create(NULL
);
867 if (tests
[x
].requires_flush
)
868 memcached_flush(memc
, 0);
870 rc
= memcached_server_push(memc
, servers
);
871 assert(rc
== MEMCACHED_SUCCESS
);
874 for (loop
= 0; loop
< memcached_server_list_count(servers
); loop
++)
876 assert(memc
->hosts
[loop
].stack_responses
== 0);
877 assert(memc
->hosts
[loop
].fd
== -1);
878 assert(memc
->hosts
[loop
].cursor_active
== 0);
881 fprintf(stderr
, "Testing %s", tests
[x
].function_name
);
882 gettimeofday(&start_time
, NULL
);
883 tests
[x
].function(memc
);
884 gettimeofday(&end_time
, NULL
);
885 long int load_time
= timedif(end_time
, start_time
);
886 fprintf(stderr
, "\t\t\t\t\t %ld.%03ld [ ok ]\n", load_time
/ 1000,
889 memcached_free(memc
);
893 if ((test_to_run
&& !strcmp(test_to_run
, "nonblock")) || !test_to_run
)
895 fprintf(stderr
, "\nNonblock tests\n\n");
896 for (x
= 0; tests
[x
].function_name
; x
++)
899 if (strcmp(wildcard
, tests
[x
].function_name
))
904 struct timeval start_time
, end_time
;
906 memc
= memcached_create(NULL
);
909 if (tests
[x
].requires_flush
)
910 memcached_flush(memc
, 0);
912 rc
= memcached_server_push(memc
, servers
);
913 assert(rc
== MEMCACHED_SUCCESS
);
915 fprintf(stderr
, "Testing %s", tests
[x
].function_name
);
916 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, NULL
);
917 gettimeofday(&start_time
, NULL
);
918 tests
[x
].function(memc
);
919 gettimeofday(&end_time
, NULL
);
920 long int load_time
= timedif(end_time
, start_time
);
921 fprintf(stderr
, "\t\t\t\t\t %ld.%03ld [ ok ]\n", load_time
/ 1000,
924 memcached_free(memc
);
928 if ((test_to_run
&& !strcmp(test_to_run
, "nodelay")) || !test_to_run
)
930 fprintf(stderr
, "\nTCP Nodelay tests\n\n");
931 for (x
= 0; tests
[x
].function_name
; x
++)
934 if (strcmp(wildcard
, tests
[x
].function_name
))
939 struct timeval start_time
, end_time
;
941 memc
= memcached_create(NULL
);
944 if (tests
[x
].requires_flush
)
945 memcached_flush(memc
, 0);
947 rc
= memcached_server_push(memc
, servers
);
948 assert(rc
== MEMCACHED_SUCCESS
);
950 fprintf(stderr
, "Testing %s", tests
[x
].function_name
);
951 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, NULL
);
952 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, NULL
);
953 gettimeofday(&start_time
, NULL
);
954 tests
[x
].function(memc
);
955 gettimeofday(&end_time
, NULL
);
956 long int load_time
= timedif(end_time
, start_time
);
957 fprintf(stderr
, "\t\t\t\t\t %ld.%03ld [ ok ]\n", load_time
/ 1000,
960 memcached_free(memc
);
964 if ((test_to_run
&& !strcmp(test_to_run
, "md5")) || !test_to_run
)
966 fprintf(stderr
, "\nMD5 Hashing\n\n");
967 for (x
= 0; tests
[x
].function_name
; x
++)
970 if (strcmp(wildcard
, tests
[x
].function_name
))
975 struct timeval start_time
, end_time
;
977 memc
= memcached_create(NULL
);
980 if (tests
[x
].requires_flush
)
981 memcached_flush(memc
, 0);
983 rc
= memcached_server_push(memc
, servers
);
984 assert(rc
== MEMCACHED_SUCCESS
);
986 fprintf(stderr
, "Testing %s", tests
[x
].function_name
);
987 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_MD5_HASHING
, NULL
);
988 gettimeofday(&start_time
, NULL
);
989 tests
[x
].function(memc
);
990 gettimeofday(&end_time
, NULL
);
991 long int load_time
= timedif(end_time
, start_time
);
992 fprintf(stderr
, "\t\t\t\t\t %ld.%03ld [ ok ]\n", load_time
/ 1000,
995 memcached_free(memc
);
999 if ((test_to_run
&& !strcmp(test_to_run
, "string")) || !test_to_run
)
1001 fprintf(stderr
, "\nString tests (internal API)\n\n");
1002 for (x
= 0; string_tests
[x
].function_name
; x
++)
1005 if (strcmp(wildcard
, string_tests
[x
].function_name
))
1009 memcached_return rc
;
1010 struct timeval start_time
, end_time
;
1012 memc
= memcached_create(NULL
);
1015 if (tests
[x
].requires_flush
)
1016 memcached_flush(memc
, 0);
1018 rc
= memcached_server_push(memc
, servers
);
1019 assert(rc
== MEMCACHED_SUCCESS
);
1021 fprintf(stderr
, "Testing %s", string_tests
[x
].function_name
);
1022 gettimeofday(&start_time
, NULL
);
1023 string_tests
[x
].function(memc
);
1024 gettimeofday(&end_time
, NULL
);
1025 long int load_time
= timedif(end_time
, start_time
);
1026 fprintf(stderr
, "\t\t\t\t\t %ld.%03ld [ ok ]\n", load_time
/ 1000,
1029 memcached_free(memc
);
1033 if ((test_to_run
&& !strcmp(test_to_run
, "user")) || !test_to_run
)
1035 fprintf(stderr
, "\nUser Supplied tests\n\n");
1036 for (x
= 0; user_tests
[x
].function_name
; x
++)
1039 if (strcmp(wildcard
, user_tests
[x
].function_name
))
1043 memcached_return rc
;
1044 struct timeval start_time
, end_time
;
1046 memc
= memcached_create(NULL
);
1049 if (tests
[x
].requires_flush
)
1050 memcached_flush(memc
, 0);
1052 rc
= memcached_server_push(memc
, servers
);
1053 assert(rc
== MEMCACHED_SUCCESS
);
1055 fprintf(stderr
, "Testing %s", user_tests
[x
].function_name
);
1056 gettimeofday(&start_time
, NULL
);
1057 user_tests
[x
].function(memc
);
1058 gettimeofday(&end_time
, NULL
);
1059 long int load_time
= timedif(end_time
, start_time
);
1060 fprintf(stderr
, "\t\t\t\t\t %ld.%03ld [ ok ]\n", load_time
/ 1000,
1063 memcached_free(memc
);
1067 /* Clean up whatever we might have left */
1070 memc
= memcached_create(NULL
);
1073 memcached_free(memc
);
1076 fprintf(stderr
, "All tests completed successfully\n\n");
1078 memcached_server_list_free(servers
);