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 clone_test(memcached_st
*memc
)
45 clone
= memcached_clone(NULL
, NULL
);
47 memcached_free(clone
);
50 /* Can we init from null? */
53 clone
= memcached_clone(NULL
, memc
);
55 memcached_free(clone
);
58 /* Can we init from struct? */
60 memcached_st declared_clone
;
62 clone
= memcached_clone(&declared_clone
, NULL
);
64 memcached_free(clone
);
67 /* Can we init from struct? */
69 memcached_st declared_clone
;
71 clone
= memcached_clone(&declared_clone
, memc
);
73 memcached_free(clone
);
77 void connection_test(memcached_st
*memc
)
81 rc
= memcached_server_add(memc
, "localhost", 0);
82 assert(rc
== MEMCACHED_SUCCESS
);
85 void error_test(memcached_st
*memc
)
89 for (rc
= MEMCACHED_SUCCESS
; rc
< MEMCACHED_MAXIMUM_RETURN
; rc
++)
91 printf("Error %d -> %s\n", rc
, memcached_strerror(memc
, rc
));
95 void set_test(memcached_st
*memc
)
99 char *value
= "when we sanitize";
101 rc
= memcached_set(memc
, key
, strlen(key
),
102 value
, strlen(value
),
103 (time_t)0, (uint16_t)0);
104 assert(rc
== MEMCACHED_SUCCESS
);
107 void add_test(memcached_st
*memc
)
111 char *value
= "when we sanitize";
113 rc
= memcached_add(memc
, key
, strlen(key
),
114 value
, strlen(value
),
115 (time_t)0, (uint16_t)0);
116 assert(rc
== MEMCACHED_NOTSTORED
);
119 void replace_test(memcached_st
*memc
)
123 char *value
= "when we sanitize";
125 rc
= memcached_replace(memc
, key
, strlen(key
),
126 value
, strlen(value
),
127 (time_t)0, (uint16_t)0);
128 assert(rc
== MEMCACHED_SUCCESS
);
131 void delete_test(memcached_st
*memc
)
135 char *value
= "when we sanitize";
137 rc
= memcached_set(memc
, key
, strlen(key
),
138 value
, strlen(value
),
139 (time_t)0, (uint16_t)0);
140 assert(rc
== MEMCACHED_SUCCESS
);
142 rc
= memcached_delete(memc
, key
, strlen(key
), (time_t)0);
143 assert(rc
== MEMCACHED_SUCCESS
);
146 void flush_test(memcached_st
*memc
)
150 rc
= memcached_flush(memc
, 0);
151 assert(rc
== MEMCACHED_SUCCESS
);
154 void get_test(memcached_st
*memc
)
159 size_t string_length
;
162 rc
= memcached_delete(memc
, key
, strlen(key
), (time_t)0);
163 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOTFOUND
);
165 string
= memcached_get(memc
, key
, strlen(key
),
166 &string_length
, &flags
, &rc
);
168 assert(rc
== MEMCACHED_NOTFOUND
);
169 assert(string_length
== 0);
173 void get_test2(memcached_st
*memc
)
177 char *value
= "when we sanitize";
179 size_t string_length
;
182 rc
= memcached_set(memc
, key
, strlen(key
),
183 value
, strlen(value
),
184 (time_t)0, (uint16_t)0);
185 assert(rc
== MEMCACHED_SUCCESS
);
187 string
= memcached_get(memc
, key
, strlen(key
),
188 &string_length
, &flags
, &rc
);
191 assert(rc
== MEMCACHED_SUCCESS
);
192 assert(string_length
== strlen(value
));
193 assert(!memcmp(string
, value
, string_length
));
198 void set_test2(memcached_st
*memc
)
202 char *value
= "train in the brain";
203 size_t value_length
= strlen(value
);
206 for (x
= 0; x
< 10; x
++)
208 rc
= memcached_set(memc
, key
, strlen(key
),
210 (time_t)0, (uint16_t)0);
211 assert(rc
== MEMCACHED_SUCCESS
);
215 void set_test3(memcached_st
*memc
)
220 size_t value_length
= 8191;
223 value
= (char*)malloc(value_length
);
226 for (x
= 0; x
< value_length
; x
++)
227 value
[x
] = (char) (x
% 127);
229 for (x
= 0; x
< 1; x
++)
231 rc
= memcached_set(memc
, key
, strlen(key
),
233 (time_t)0, (uint16_t)0);
234 assert(rc
== MEMCACHED_SUCCESS
);
240 void get_test3(memcached_st
*memc
)
245 size_t value_length
= 8191;
247 size_t string_length
;
251 value
= (char*)malloc(value_length
);
254 for (x
= 0; x
< value_length
; x
++)
255 value
[x
] = (char) (x
% 127);
257 rc
= memcached_set(memc
, key
, strlen(key
),
259 (time_t)0, (uint16_t)0);
260 assert(rc
== MEMCACHED_SUCCESS
);
262 string
= memcached_get(memc
, key
, strlen(key
),
263 &string_length
, &flags
, &rc
);
265 assert(rc
== MEMCACHED_SUCCESS
);
267 assert(string_length
== value_length
);
268 assert(!memcmp(string
, value
, string_length
));
274 void get_test4(memcached_st
*memc
)
279 size_t value_length
= 8191;
281 size_t string_length
;
285 value
= (char*)malloc(value_length
);
288 for (x
= 0; x
< value_length
; x
++)
289 value
[x
] = (char) (x
% 127);
291 rc
= memcached_set(memc
, key
, strlen(key
),
293 (time_t)0, (uint16_t)0);
294 assert(rc
== MEMCACHED_SUCCESS
);
296 for (x
= 0; x
< 10; x
++)
298 string
= memcached_get(memc
, key
, strlen(key
),
299 &string_length
, &flags
, &rc
);
301 assert(rc
== MEMCACHED_SUCCESS
);
303 assert(string_length
== value_length
);
304 assert(!memcmp(string
, value
, string_length
));
311 void stats_servername_test(memcached_st
*memc
)
314 memcached_stat_st stat
;
315 rc
= memcached_stat_servername(&stat
, NULL
,
317 MEMCACHED_DEFAULT_PORT
);
320 void increment_test(memcached_st
*memc
)
322 unsigned int new_number
;
327 rc
= memcached_set(memc
, key
, strlen(key
),
328 value
, strlen(value
),
329 (time_t)0, (uint16_t)0);
330 assert(rc
== MEMCACHED_SUCCESS
);
332 rc
= memcached_increment(memc
, key
, strlen(key
),
334 assert(rc
== MEMCACHED_SUCCESS
);
335 assert(new_number
== 1);
337 rc
= memcached_increment(memc
, key
, strlen(key
),
339 assert(rc
== MEMCACHED_SUCCESS
);
340 assert(new_number
== 2);
343 void decrement_test(memcached_st
*memc
)
345 unsigned int new_number
;
350 rc
= memcached_set(memc
, key
, strlen(key
),
351 value
, strlen(value
),
352 (time_t)0, (uint16_t)0);
353 assert(rc
== MEMCACHED_SUCCESS
);
355 rc
= memcached_decrement(memc
, key
, strlen(key
),
357 assert(rc
== MEMCACHED_SUCCESS
);
358 assert(new_number
== 2);
360 rc
= memcached_decrement(memc
, key
, strlen(key
),
362 assert(rc
== MEMCACHED_SUCCESS
);
363 assert(new_number
== 1);
366 void quit_test(memcached_st
*memc
)
370 char *value
= "sanford and sun";
372 rc
= memcached_set(memc
, key
, strlen(key
),
373 value
, strlen(value
),
374 (time_t)10, (uint16_t)3);
375 assert(rc
== MEMCACHED_SUCCESS
);
376 memcached_quit(memc
);
378 rc
= memcached_set(memc
, key
, strlen(key
),
379 value
, strlen(value
),
380 (time_t)50, (uint16_t)9);
381 assert(rc
== MEMCACHED_SUCCESS
);
384 void mget_test(memcached_st
*memc
)
387 char *keys
[]= {"fudge", "son", "food"};
388 size_t key_length
[]= {5, 3, 4};
392 char return_key
[MEMCACHED_MAX_KEY
];
393 size_t return_key_length
;
395 size_t return_value_length
;
397 /* We need to empty the server before continueing test */
398 rc
= memcached_flush(memc
, 0);
399 assert(rc
== MEMCACHED_SUCCESS
);
401 rc
= memcached_mget(memc
, keys
, key_length
, 3);
402 assert(rc
== MEMCACHED_SUCCESS
);
404 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
405 &return_value_length
, &flags
, &rc
)) != NULL
)
407 assert(return_value
);
409 assert(!return_value
);
410 assert(return_value_length
== 0);
411 assert(rc
== MEMCACHED_NOTFOUND
);
413 for (x
= 0; x
< 3; x
++)
415 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
416 keys
[x
], key_length
[x
],
417 (time_t)50, (uint16_t)9);
418 assert(rc
== MEMCACHED_SUCCESS
);
421 rc
= memcached_mget(memc
, keys
, key_length
, 3);
422 assert(rc
== MEMCACHED_SUCCESS
);
425 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
426 &return_value_length
, &flags
, &rc
)))
428 assert(return_value
);
429 assert(rc
== MEMCACHED_SUCCESS
);
430 assert(return_key_length
== return_value_length
);
431 assert(!memcmp(return_value
, return_key
, return_value_length
));
437 void get_stats_keys(memcached_st
*memc
)
441 memcached_stat_st stat
;
444 list
= memcached_stat_get_keys(memc
, &stat
, &rc
);
445 assert(rc
== MEMCACHED_SUCCESS
);
446 for (ptr
= list
; *ptr
; ptr
++)
447 printf("Found key %s\n", *ptr
);
453 void get_stats(memcached_st
*memc
)
459 memcached_stat_st
*stat
;
461 stat
= memcached_stat(memc
, NULL
, &rc
);
462 assert(rc
== MEMCACHED_SUCCESS
);
464 assert(rc
== MEMCACHED_SUCCESS
);
467 for (x
= 0; x
< memcached_server_count(memc
); x
++)
469 list
= memcached_stat_get_keys(memc
, &stat
[x
], &rc
);
470 assert(rc
== MEMCACHED_SUCCESS
);
471 for (ptr
= list
; *ptr
; ptr
++)
472 printf("Found key %s\n", *ptr
);
480 void add_host_test(memcached_st
*memc
)
483 memcached_server_st
*servers
;
485 char servername
[]= "0.example.com";
487 servers
= memcached_server_list_append(NULL
, servername
, 400, &rc
);
489 assert(1 == memcached_server_list_count(servers
));
491 for (x
= 2; x
< 20; x
++)
493 char buffer
[SMALL_STRING_LEN
];
495 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
496 servers
= memcached_server_list_append(servers
, buffer
, 401,
498 assert(rc
== MEMCACHED_SUCCESS
);
499 assert(x
== memcached_server_list_count(servers
));
502 rc
= memcached_server_push(memc
, servers
);
503 assert(rc
== MEMCACHED_SUCCESS
);
504 rc
= memcached_server_push(memc
, servers
);
505 assert(rc
== MEMCACHED_SUCCESS
);
507 memcached_server_list_free(servers
);
510 /* We don't test the behavior itself, we test the switches */
511 void behavior_test(memcached_st
*memc
)
513 unsigned long long value
;
516 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, &set
);
517 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
520 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, &set
);
521 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
524 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_MD5_HASHING
, &set
);
525 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_MD5_HASHING
);
530 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, &set
);
531 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
534 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, &set
);
535 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
538 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_MD5_HASHING
, &set
);
539 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_MD5_HASHING
);
542 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
545 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
549 /* Test case provided by Cal Haldenbrand */
550 void user_supplied_bug1(memcached_st
*memc
)
552 unsigned int setter
= 1;
555 unsigned long long total
= 0;
558 char randomstuff
[6 * 1024];
561 memset(randomstuff
, 0, 6 * 1024);
563 /* We just keep looking at the same values over and over */
566 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, &setter
);
567 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, &setter
);
571 for (x
= 0 ; total
< 20 * 1024576 ; x
++ )
575 size
= (rand() % ( 5 * 1024 ) ) + 400;
576 memset(randomstuff
, 0, 6 * 1024);
577 assert(size
< 6 * 1024); /* Being safe here */
579 for (j
= 0 ; j
< size
;j
++)
580 randomstuff
[j
] = (char) (rand() % 26) + 97;
583 sprintf(key
, "%d", x
);
584 rc
= memcached_set(memc
, key
, strlen(key
),
585 randomstuff
, strlen(randomstuff
), 10, 0);
586 /* If we fail, lets try again */
587 if (rc
!= MEMCACHED_SUCCESS
)
588 rc
= memcached_set(memc
, key
, strlen(key
),
589 randomstuff
, strlen(randomstuff
), 10, 0);
590 assert(rc
== MEMCACHED_SUCCESS
);
594 /* Test case provided by Cal Haldenbrand */
595 void user_supplied_bug2(memcached_st
*memc
)
600 unsigned long long total
;
603 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, &setter
);
604 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, &setter
);
606 setter
= 20 * 1024576;
607 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, &setter
);
608 setter
= 20 * 1024576;
609 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, &setter
);
610 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
611 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
614 for (x
= 0, errors
= 0, total
= 0 ; total
< 20 * 1024576 ; x
++)
616 memcached_return rc
= MEMCACHED_SUCCESS
;
617 char buffer
[SMALL_STRING_LEN
];
622 memset(buffer
, 0, SMALL_STRING_LEN
);
624 snprintf(buffer
, SMALL_STRING_LEN
, "%u", x
);
625 getval
= memcached_get(memc
, buffer
, strlen(buffer
),
626 &val_len
, &flags
, &rc
);
627 if (rc
!= MEMCACHED_SUCCESS
)
629 if (rc
== MEMCACHED_NOTFOUND
)
642 /* Do a large mget() over all the keys we think exist */
643 #define KEY_COUNT 3000 // * 1024576
644 void user_supplied_bug3(memcached_st
*memc
)
650 size_t key_lengths
[KEY_COUNT
];
653 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, &setter
);
654 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, &setter
);
656 setter
= 20 * 1024576;
657 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, &setter
);
658 setter
= 20 * 1024576;
659 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, &setter
);
660 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
661 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
664 keys
= (char **)malloc(sizeof(char *) * KEY_COUNT
);
666 memset(keys
, 0, (sizeof(char *) * KEY_COUNT
));
667 for (x
= 0; x
< KEY_COUNT
; x
++)
671 snprintf(buffer
, 30, "%u", x
);
672 keys
[x
]= strdup(buffer
);
673 key_lengths
[x
]= strlen(keys
[x
]);
676 rc
= memcached_mget(memc
, keys
, key_lengths
, KEY_COUNT
);
677 assert(rc
== MEMCACHED_SUCCESS
);
679 /* Turn this into a help function */
681 char return_key
[MEMCACHED_MAX_KEY
];
682 size_t return_key_length
;
684 size_t return_value_length
;
687 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
688 &return_value_length
, &flags
, &rc
)))
690 assert(return_value
);
691 assert(rc
== MEMCACHED_SUCCESS
);
696 for (x
= 0; x
< KEY_COUNT
; x
++)
701 void string_alloc_null(memcached_st
*memc
)
703 memcached_string_st
*string
;
705 string
= memcached_string_create(memc
, 0);
707 memcached_string_free(memc
, string
);
710 void string_alloc_with_size(memcached_st
*memc
)
712 memcached_string_st
*string
;
714 string
= memcached_string_create(memc
, 1024);
716 memcached_string_free(memc
, string
);
719 void string_alloc_with_size_toobig(memcached_st
*memc
)
721 memcached_string_st
*string
;
723 string
= memcached_string_create(memc
, INT64_MAX
);
724 assert(string
== NULL
);
727 void string_alloc_append(memcached_st
*memc
)
730 char buffer
[SMALL_STRING_LEN
];
731 memcached_string_st
*string
;
734 memset(buffer
, 6, SMALL_STRING_LEN
);
736 string
= memcached_string_create(memc
, 100);
739 for (x
= 0; x
< 1024; x
++)
742 rc
= memcached_string_append(memc
, string
, buffer
, SMALL_STRING_LEN
);
743 assert(rc
== MEMCACHED_SUCCESS
);
745 memcached_string_free(memc
, string
);
748 void string_alloc_append_toobig(memcached_st
*memc
)
752 char buffer
[SMALL_STRING_LEN
];
753 memcached_string_st
*string
;
756 memset(buffer
, 6, SMALL_STRING_LEN
);
758 string
= memcached_string_create(memc
, 100);
761 for (x
= 0; x
< 1024; x
++)
763 rc
= memcached_string_append(memc
, string
, buffer
, SMALL_STRING_LEN
);
764 assert(rc
== MEMCACHED_SUCCESS
);
766 rc
= memcached_string_append(memc
, string
, buffer
, INT64_MAX
);
767 assert(rc
== MEMCACHED_MEMORY_ALLOCATION_FAILURE
);
768 memcached_string_free(memc
, string
);
771 void add_host_test1(memcached_st
*memc
)
775 char servername
[]= "0.example.com";
776 memcached_server_st
*servers
;
778 servers
= memcached_server_list_append(NULL
, servername
, 400, &rc
);
780 assert(1 == memcached_server_list_count(servers
));
782 for (x
= 2; x
< 20; x
++)
784 char buffer
[SMALL_STRING_LEN
];
786 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
787 servers
= memcached_server_list_append(servers
, buffer
, 401,
789 assert(rc
== MEMCACHED_SUCCESS
);
790 assert(x
== memcached_server_list_count(servers
));
793 rc
= memcached_server_push(memc
, servers
);
794 assert(rc
== MEMCACHED_SUCCESS
);
795 rc
= memcached_server_push(memc
, servers
);
796 assert(rc
== MEMCACHED_SUCCESS
);
798 memcached_server_list_free(servers
);
801 void pre_nonblock(memcached_st
*memc
)
803 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, NULL
);
806 void pre_md5(memcached_st
*memc
)
808 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_MD5_HASHING
, NULL
);
811 void pre_nodelay(memcached_st
*memc
)
813 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, NULL
);
814 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, NULL
);
817 typedef struct collection_st collection_st
;
818 typedef struct test_st test_st
;
822 unsigned int requires_flush
;
823 void (*function
)(memcached_st
*memc
);
826 struct collection_st
{
828 void (*pre
)(memcached_st
*memc
);
829 void (*post
)(memcached_st
*memc
);
833 int main(int argc
, char *argv
[])
837 char *collection_to_run
= NULL
;
838 char *wildcard
= NULL
;
839 memcached_server_st
*servers
;
843 collection_to_run
= argv
[1];
848 if (!(server_list
= getenv("MEMCACHED_SERVERS")))
849 server_list
= "localhost";
851 printf("servers %s\n", server_list
);
854 servers
= memcached_servers_parse(server_list
);
857 for (x
= 0; x
< memcached_server_list_count(servers
); x
++)
859 printf("\t%s : %u\n", servers
[x
].hostname
, servers
[x
].port
);
860 assert(servers
[x
].stack_responses
== 0);
861 assert(servers
[x
].fd
== -1);
862 assert(servers
[x
].cursor_active
== 0);
867 /* Clean the server before beginning testing */
869 {"flush", 0, flush_test
},
870 {"init", 0, init_test
},
871 {"allocation", 0, allocation_test
},
872 {"clone_test", 0, clone_test
},
873 {"error", 0, error_test
},
874 {"set", 0, set_test
},
875 {"set2", 0, set_test2
},
876 {"set3", 0, set_test3
},
877 {"add", 0, add_test
},
878 {"replace", 0, replace_test
},
879 {"delete", 1, delete_test
},
880 {"get", 1, get_test
},
881 {"get2", 0, get_test2
},
882 {"get3", 0, get_test3
},
883 {"get4", 0, get_test4
},
884 {"stats_servername", 0, stats_servername_test
},
885 {"increment", 0, increment_test
},
886 {"decrement", 0, decrement_test
},
887 {"quit", 0, quit_test
},
888 {"mget", 0, mget_test
},
889 {"get_stats", 0, get_stats
},
890 {"add_host_test", 0, add_host_test
},
891 {"get_stats_keys", 0, get_stats_keys
},
892 {"behavior_test", 0, get_stats_keys
},
896 test_st string_tests
[] ={
897 {"string alloc with null", 0, string_alloc_null
},
898 {"string alloc with 1K", 0, string_alloc_with_size
},
899 {"string alloc with malloc failure", 0, string_alloc_with_size_toobig
},
900 {"string append", 0, string_alloc_append
},
901 {"string append failure (too big)", 0, string_alloc_append_toobig
},
905 test_st user_tests
[] ={
906 {"user_supplied_bug1", 0, user_supplied_bug1
},
907 {"user_supplied_bug2", 0, user_supplied_bug2
},
908 {"user_supplied_bug3", 0, user_supplied_bug3
},
913 collection_st collection
[] ={
914 {"block", 0, 0, tests
},
915 {"nonblock", pre_nonblock
, 0, tests
},
916 {"nodelay", pre_nodelay
, 0, tests
},
917 {"md5", pre_md5
, 0, tests
},
918 {"string", 0, 0, string_tests
},
919 {"user", 0, 0, user_tests
},
924 for (next
= collection
; next
->name
; next
++)
930 if (collection_to_run
&& strcmp(collection_to_run
, next
->name
))
933 fprintf(stderr
, "\n%s\n\n", next
->name
);
935 for (x
= 0; run
->name
; run
++)
937 if (wildcard
&& strcmp(wildcard
, run
->name
))
940 fprintf(stderr
, "Testing %s", run
->name
);
944 struct timeval start_time
, end_time
;
946 memc
= memcached_create(NULL
);
949 if (run
->requires_flush
)
950 memcached_flush(memc
, 0);
952 rc
= memcached_server_push(memc
, servers
);
953 assert(rc
== MEMCACHED_SUCCESS
);
956 for (loop
= 0; loop
< memcached_server_list_count(servers
); loop
++)
958 assert(memc
->hosts
[loop
].stack_responses
== 0);
959 assert(memc
->hosts
[loop
].fd
== -1);
960 assert(memc
->hosts
[loop
].cursor_active
== 0);
966 gettimeofday(&start_time
, NULL
);
968 gettimeofday(&end_time
, NULL
);
969 long int load_time
= timedif(end_time
, start_time
);
970 fprintf(stderr
, "\t\t\t\t\t %ld.%03ld [ ok ]\n", load_time
/ 1000,
977 memcached_free(memc
);
981 /* Clean up whatever we might have left */
984 memc
= memcached_create(NULL
);
987 memcached_free(memc
);
990 fprintf(stderr
, "All tests completed successfully\n\n");
992 memcached_server_list_free(servers
);