7b8c462e247380f326811caaf6184e7b60fe828e
[awesomized/libmemcached] / tests / test.c
1 /*
2 Sample test application.
3 */
4 #include <assert.h>
5 #include <memcached.h>
6 #include <stdio.h>
7 #include <stdlib.h>
8 #include <string.h>
9 #include <sys/time.h>
10 #include <sys/types.h>
11 #include <sys/stat.h>
12 #include <unistd.h>
13 #include <time.h>
14 #include "../lib/common.h"
15
16 long int timedif(struct timeval a, struct timeval b)
17 {
18 register int us, s;
19
20 us = a.tv_usec - b.tv_usec;
21 us /= 1000;
22 s = a.tv_sec - b.tv_sec;
23 s *= 1000;
24 return s + us;
25 }
26
27 void init_test(memcached_st *not_used)
28 {
29 memcached_st memc;
30
31 (void)memcached_create(&memc);
32 memcached_free(&memc);
33 }
34
35 void allocation_test(memcached_st *not_used)
36 {
37 memcached_st *memc;
38 memc= memcached_create(NULL);
39 assert(memc);
40 memcached_free(memc);
41 }
42
43 void clone_test(memcached_st *memc)
44 {
45 /* All null? */
46 {
47 memcached_st *clone;
48 clone= memcached_clone(NULL, NULL);
49 assert(clone);
50 memcached_free(clone);
51 }
52
53 /* Can we init from null? */
54 {
55 memcached_st *clone;
56 clone= memcached_clone(NULL, memc);
57 assert(clone);
58 memcached_free(clone);
59 }
60
61 /* Can we init from struct? */
62 {
63 memcached_st declared_clone;
64 memcached_st *clone;
65 clone= memcached_clone(&declared_clone, NULL);
66 assert(clone);
67 memcached_free(clone);
68 }
69
70 /* Can we init from struct? */
71 {
72 memcached_st declared_clone;
73 memcached_st *clone;
74 clone= memcached_clone(&declared_clone, memc);
75 assert(clone);
76 memcached_free(clone);
77 }
78 }
79
80 void connection_test(memcached_st *memc)
81 {
82 memcached_return rc;
83
84 rc= memcached_server_add(memc, "localhost", 0);
85 assert(rc == MEMCACHED_SUCCESS);
86 }
87
88 void error_test(memcached_st *memc)
89 {
90 memcached_return rc;
91
92 for (rc= MEMCACHED_SUCCESS; rc < MEMCACHED_MAXIMUM_RETURN; rc++)
93 {
94 printf("Error %d -> %s\n", rc, memcached_strerror(memc, rc));
95 }
96 }
97
98 void set_test(memcached_st *memc)
99 {
100 memcached_return rc;
101 char *key= "foo";
102 char *value= "when we sanitize";
103
104 rc= memcached_set(memc, key, strlen(key),
105 value, strlen(value),
106 (time_t)0, (uint16_t)0);
107 assert(rc == MEMCACHED_SUCCESS);
108 }
109
110 void add_test(memcached_st *memc)
111 {
112 memcached_return rc;
113 char *key= "foo";
114 char *value= "when we sanitize";
115
116 rc= memcached_add(memc, key, strlen(key),
117 value, strlen(value),
118 (time_t)0, (uint16_t)0);
119 assert(rc == MEMCACHED_NOTSTORED);
120 }
121
122 void replace_test(memcached_st *memc)
123 {
124 memcached_return rc;
125 char *key= "foo";
126 char *value= "when we sanitize";
127
128 rc= memcached_replace(memc, key, strlen(key),
129 value, strlen(value),
130 (time_t)0, (uint16_t)0);
131 assert(rc == MEMCACHED_SUCCESS);
132 }
133
134 void delete_test(memcached_st *memc)
135 {
136 memcached_return rc;
137 char *key= "foo";
138 char *value= "when we sanitize";
139
140 rc= memcached_set(memc, key, strlen(key),
141 value, strlen(value),
142 (time_t)0, (uint16_t)0);
143 assert(rc == MEMCACHED_SUCCESS);
144
145 rc= memcached_delete(memc, key, strlen(key), (time_t)0);
146 assert(rc == MEMCACHED_SUCCESS);
147 }
148
149 void flush_test(memcached_st *memc)
150 {
151 memcached_return rc;
152
153 rc= memcached_flush(memc, 0);
154 assert(rc == MEMCACHED_SUCCESS);
155 }
156
157 void get_test(memcached_st *memc)
158 {
159 memcached_return rc;
160 char *key= "foo";
161 char *string;
162 size_t string_length;
163 uint16_t flags;
164
165 rc= memcached_delete(memc, key, strlen(key), (time_t)0);
166 assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_NOTFOUND);
167
168 string= memcached_get(memc, key, strlen(key),
169 &string_length, &flags, &rc);
170
171 assert(rc == MEMCACHED_NOTFOUND);
172 assert(string_length == 0);
173 assert(!string);
174 }
175
176 void get_test2(memcached_st *memc)
177 {
178 memcached_return rc;
179 char *key= "foo";
180 char *value= "when we sanitize";
181 char *string;
182 size_t string_length;
183 uint16_t flags;
184
185 rc= memcached_set(memc, key, strlen(key),
186 value, strlen(value),
187 (time_t)0, (uint16_t)0);
188 assert(rc == MEMCACHED_SUCCESS);
189
190 string= memcached_get(memc, key, strlen(key),
191 &string_length, &flags, &rc);
192
193 assert(string);
194 assert(rc == MEMCACHED_SUCCESS);
195 assert(string_length == strlen(value));
196 assert(!memcmp(string, value, string_length));
197
198 free(string);
199 }
200
201 void set_test2(memcached_st *memc)
202 {
203 memcached_return rc;
204 char *key= "foo";
205 char *value= "train in the brain";
206 size_t value_length= strlen(value);
207 unsigned int x;
208
209 for (x= 0; x < 10; x++)
210 {
211 rc= memcached_set(memc, key, strlen(key),
212 value, value_length,
213 (time_t)0, (uint16_t)0);
214 assert(rc == MEMCACHED_SUCCESS);
215 }
216 }
217
218 void set_test3(memcached_st *memc)
219 {
220 memcached_return rc;
221 char *key= "foo";
222 char *value;
223 size_t value_length= 8191;
224 unsigned int x;
225
226 value = (char*)malloc(value_length);
227 assert(value);
228
229 for (x= 0; x < value_length; x++)
230 value[x] = (char) (x % 127);
231
232 for (x= 0; x < 1; x++)
233 {
234 rc= memcached_set(memc, key, strlen(key),
235 value, value_length,
236 (time_t)0, (uint16_t)0);
237 assert(rc == MEMCACHED_SUCCESS);
238 }
239
240 free(value);
241 }
242
243 void get_test3(memcached_st *memc)
244 {
245 memcached_return rc;
246 char *key= "foo";
247 char *value;
248 size_t value_length= 8191;
249 char *string;
250 size_t string_length;
251 uint16_t flags;
252 int x;
253
254 value = (char*)malloc(value_length);
255 assert(value);
256
257 for (x= 0; x < value_length; x++)
258 value[x] = (char) (x % 127);
259
260 rc= memcached_set(memc, key, strlen(key),
261 value, value_length,
262 (time_t)0, (uint16_t)0);
263 assert(rc == MEMCACHED_SUCCESS);
264
265 string= memcached_get(memc, key, strlen(key),
266 &string_length, &flags, &rc);
267
268 assert(rc == MEMCACHED_SUCCESS);
269 assert(string);
270 assert(string_length == value_length);
271 assert(!memcmp(string, value, string_length));
272
273 free(string);
274 free(value);
275 }
276
277 void get_test4(memcached_st *memc)
278 {
279 memcached_return rc;
280 char *key= "foo";
281 char *value;
282 size_t value_length= 8191;
283 char *string;
284 size_t string_length;
285 uint16_t flags;
286 int x;
287
288 value = (char*)malloc(value_length);
289 assert(value);
290
291 for (x= 0; x < value_length; x++)
292 value[x] = (char) (x % 127);
293
294 rc= memcached_set(memc, key, strlen(key),
295 value, value_length,
296 (time_t)0, (uint16_t)0);
297 assert(rc == MEMCACHED_SUCCESS);
298
299 for (x= 0; x < 10; x++)
300 {
301 string= memcached_get(memc, key, strlen(key),
302 &string_length, &flags, &rc);
303
304 assert(rc == MEMCACHED_SUCCESS);
305 assert(string);
306 assert(string_length == value_length);
307 assert(!memcmp(string, value, string_length));
308 free(string);
309 }
310
311 free(value);
312 }
313
314 void stats_servername_test(memcached_st *memc)
315 {
316 memcached_return rc;
317 memcached_stat_st stat;
318 rc= memcached_stat_servername(&stat, NULL,
319 "localhost",
320 MEMCACHED_DEFAULT_PORT);
321 }
322
323 void increment_test(memcached_st *memc)
324 {
325 unsigned int new_number;
326 memcached_return rc;
327 char *key= "number";
328 char *value= "0";
329
330 rc= memcached_set(memc, key, strlen(key),
331 value, strlen(value),
332 (time_t)0, (uint16_t)0);
333 assert(rc == MEMCACHED_SUCCESS);
334
335 rc= memcached_increment(memc, key, strlen(key),
336 1, &new_number);
337 assert(rc == MEMCACHED_SUCCESS);
338 assert(new_number == 1);
339
340 rc= memcached_increment(memc, key, strlen(key),
341 1, &new_number);
342 assert(rc == MEMCACHED_SUCCESS);
343 assert(new_number == 2);
344 }
345
346 void decrement_test(memcached_st *memc)
347 {
348 unsigned int new_number;
349 memcached_return rc;
350 char *key= "number";
351 char *value= "3";
352
353 rc= memcached_set(memc, key, strlen(key),
354 value, strlen(value),
355 (time_t)0, (uint16_t)0);
356 assert(rc == MEMCACHED_SUCCESS);
357
358 rc= memcached_decrement(memc, key, strlen(key),
359 1, &new_number);
360 assert(rc == MEMCACHED_SUCCESS);
361 assert(new_number == 2);
362
363 rc= memcached_decrement(memc, key, strlen(key),
364 1, &new_number);
365 assert(rc == MEMCACHED_SUCCESS);
366 assert(new_number == 1);
367 }
368
369 void quit_test(memcached_st *memc)
370 {
371 memcached_return rc;
372 char *key= "fudge";
373 char *value= "sanford and sun";
374
375 rc= memcached_set(memc, key, strlen(key),
376 value, strlen(value),
377 (time_t)10, (uint16_t)3);
378 assert(rc == MEMCACHED_SUCCESS);
379 memcached_quit(memc);
380
381 rc= memcached_set(memc, key, strlen(key),
382 value, strlen(value),
383 (time_t)50, (uint16_t)9);
384 assert(rc == MEMCACHED_SUCCESS);
385 }
386
387 void mget_test(memcached_st *memc)
388 {
389 memcached_return rc;
390 char *keys[]= {"fudge", "son", "food"};
391 size_t key_length[]= {5, 3, 4};
392 unsigned int x;
393 uint16_t flags;
394
395 char return_key[MEMCACHED_MAX_KEY];
396 size_t return_key_length;
397 char *return_value;
398 size_t return_value_length;
399
400 /* We need to empty the server before continueing test */
401 rc= memcached_flush(memc, 0);
402 assert(rc == MEMCACHED_SUCCESS);
403
404 rc= memcached_mget(memc, keys, key_length, 3);
405 assert(rc == MEMCACHED_SUCCESS);
406
407 while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
408 &return_value_length, &flags, &rc)) != NULL)
409 {
410 assert(return_value);
411 }
412 assert(!return_value);
413 assert(return_value_length == 0);
414 assert(rc == MEMCACHED_NOTFOUND);
415
416 for (x= 0; x < 3; x++)
417 {
418 rc= memcached_set(memc, keys[x], key_length[x],
419 keys[x], key_length[x],
420 (time_t)50, (uint16_t)9);
421 assert(rc == MEMCACHED_SUCCESS);
422 }
423
424 rc= memcached_mget(memc, keys, key_length, 3);
425 assert(rc == MEMCACHED_SUCCESS);
426
427 x= 0;
428 while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
429 &return_value_length, &flags, &rc)))
430 {
431 assert(return_value);
432 assert(rc == MEMCACHED_SUCCESS);
433 assert(return_key_length == return_value_length);
434 assert(!memcmp(return_value, return_key, return_value_length));
435 free(return_value);
436 x++;
437 }
438 }
439
440 void get_stats_keys(memcached_st *memc)
441 {
442 char **list;
443 char **ptr;
444 memcached_stat_st stat;
445 memcached_return rc;
446
447 list= memcached_stat_get_keys(memc, &stat, &rc);
448 assert(rc == MEMCACHED_SUCCESS);
449 for (ptr= list; *ptr; ptr++)
450 printf("Found key %s\n", *ptr);
451 fflush(stdout);
452
453 free(list);
454 }
455
456 void get_stats(memcached_st *memc)
457 {
458 unsigned int x;
459 char **list;
460 char **ptr;
461 memcached_return rc;
462 memcached_stat_st *stat;
463
464 stat= memcached_stat(memc, NULL, &rc);
465 assert(rc == MEMCACHED_SUCCESS);
466
467 assert(rc == MEMCACHED_SUCCESS);
468 assert(stat);
469
470 for (x= 0; x < memcached_server_count(memc); x++)
471 {
472 list= memcached_stat_get_keys(memc, &stat[x], &rc);
473 assert(rc == MEMCACHED_SUCCESS);
474 for (ptr= list; *ptr; ptr++)
475 printf("Found key %s\n", *ptr);
476
477 free(list);
478 }
479
480 free(stat);
481 }
482
483 void add_host_test(memcached_st *memc)
484 {
485 unsigned int x;
486 memcached_server_st *servers;
487 memcached_return rc;
488 char servername[]= "0.example.com";
489
490 servers= memcached_server_list_append(NULL, servername, 400, &rc);
491 assert(servers);
492 assert(1 == memcached_server_list_count(servers));
493
494 for (x= 2; x < 20; x++)
495 {
496 char buffer[SMALL_STRING_LEN];
497
498 snprintf(buffer, SMALL_STRING_LEN, "%u.example.com", 400+x);
499 servers= memcached_server_list_append(servers, buffer, 401,
500 &rc);
501 assert(rc == MEMCACHED_SUCCESS);
502 assert(x == memcached_server_list_count(servers));
503 }
504
505 rc= memcached_server_push(memc, servers);
506 assert(rc == MEMCACHED_SUCCESS);
507 rc= memcached_server_push(memc, servers);
508 assert(rc == MEMCACHED_SUCCESS);
509
510 memcached_server_list_free(servers);
511 }
512
513 /* We don't test the behavior itself, we test the switches */
514 void behavior_test(memcached_st *memc)
515 {
516 unsigned long long value;
517 unsigned int set= 1;
518
519 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, &set);
520 value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK);
521 assert(value == 1);
522
523 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, &set);
524 value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY);
525 assert(value == 1);
526
527 set= MEMCACHED_HASH_MD5;
528 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &set);
529 value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
530 assert(value == MEMCACHED_HASH_MD5);
531
532 set= 0;
533
534 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, &set);
535 value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK);
536 assert(value == 0);
537
538 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, &set);
539 value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY);
540 assert(value == 0);
541
542 set= MEMCACHED_HASH_DEFAULT;
543 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &set);
544 value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
545 assert(value == MEMCACHED_HASH_DEFAULT);
546
547 set= MEMCACHED_HASH_CRC;
548 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &set);
549 value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
550 assert(value == MEMCACHED_HASH_CRC);
551
552 value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE);
553 assert(value > 0);
554
555 value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE);
556 assert(value > 0);
557 }
558
559 /* Test case provided by Cal Haldenbrand */
560 void user_supplied_bug1(memcached_st *memc)
561 {
562 unsigned int setter= 1;
563 unsigned int x;
564
565 unsigned long long total= 0;
566 int size= 0;
567 char key[10];
568 char randomstuff[6 * 1024];
569 memcached_return rc;
570
571 memset(randomstuff, 0, 6 * 1024);
572
573 /* We just keep looking at the same values over and over */
574 srandom(10);
575
576 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, &setter);
577 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, &setter);
578
579
580 /* add key */
581 for (x= 0 ; total < 20 * 1024576 ; x++ )
582 {
583 unsigned int j= 0;
584
585 size= (rand() % ( 5 * 1024 ) ) + 400;
586 memset(randomstuff, 0, 6 * 1024);
587 assert(size < 6 * 1024); /* Being safe here */
588
589 for (j= 0 ; j < size ;j++)
590 randomstuff[j] = (char) (rand() % 26) + 97;
591
592 total += size;
593 sprintf(key, "%d", x);
594 rc = memcached_set(memc, key, strlen(key),
595 randomstuff, strlen(randomstuff), 10, 0);
596 /* If we fail, lets try again */
597 if (rc != MEMCACHED_SUCCESS)
598 rc = memcached_set(memc, key, strlen(key),
599 randomstuff, strlen(randomstuff), 10, 0);
600 assert(rc == MEMCACHED_SUCCESS);
601 }
602 }
603
604 /* Test case provided by Cal Haldenbrand */
605 void user_supplied_bug2(memcached_st *memc)
606 {
607 int errors;
608 unsigned int setter;
609 unsigned int x;
610 unsigned long long total;
611
612 setter= 1;
613 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, &setter);
614 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, &setter);
615 #ifdef NOT_YET
616 setter = 20 * 1024576;
617 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE, &setter);
618 setter = 20 * 1024576;
619 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE, &setter);
620 getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE);
621 getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE);
622
623 for (x= 0, errors= 0, total= 0 ; total < 20 * 1024576 ; x++)
624 #endif
625
626 for (x= 0, errors= 0, total= 0 ; total < 24576 ; x++)
627 {
628 memcached_return rc= MEMCACHED_SUCCESS;
629 char buffer[SMALL_STRING_LEN];
630 uint16_t flags= 0;
631 size_t val_len= 0;
632 char *getval;
633
634 memset(buffer, 0, SMALL_STRING_LEN);
635
636 snprintf(buffer, SMALL_STRING_LEN, "%u", x);
637 getval= memcached_get(memc, buffer, strlen(buffer),
638 &val_len, &flags, &rc);
639 if (rc != MEMCACHED_SUCCESS)
640 {
641 if (rc == MEMCACHED_NOTFOUND)
642 errors++;
643 else
644 assert(0);
645
646 continue;
647 }
648 total+= val_len;
649 errors= 0;
650 free(getval);
651 }
652 }
653
654 /* Do a large mget() over all the keys we think exist */
655 #define KEY_COUNT 3000 // * 1024576
656 void user_supplied_bug3(memcached_st *memc)
657 {
658 memcached_return rc;
659 unsigned int setter;
660 unsigned int x;
661 char **keys;
662 size_t key_lengths[KEY_COUNT];
663
664 setter= 1;
665 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, &setter);
666 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, &setter);
667 #ifdef NOT_YET
668 setter = 20 * 1024576;
669 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE, &setter);
670 setter = 20 * 1024576;
671 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE, &setter);
672 getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE);
673 getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE);
674 #endif
675
676 keys= (char **)malloc(sizeof(char *) * KEY_COUNT);
677 assert(keys);
678 memset(keys, 0, (sizeof(char *) * KEY_COUNT));
679 for (x= 0; x < KEY_COUNT; x++)
680 {
681 char buffer[30];
682
683 snprintf(buffer, 30, "%u", x);
684 keys[x]= strdup(buffer);
685 key_lengths[x]= strlen(keys[x]);
686 }
687
688 rc= memcached_mget(memc, keys, key_lengths, KEY_COUNT);
689 assert(rc == MEMCACHED_SUCCESS);
690
691 /* Turn this into a help function */
692 {
693 char return_key[MEMCACHED_MAX_KEY];
694 size_t return_key_length;
695 char *return_value;
696 size_t return_value_length;
697 uint16_t flags;
698
699 while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
700 &return_value_length, &flags, &rc)))
701 {
702 assert(return_value);
703 assert(rc == MEMCACHED_SUCCESS);
704 free(return_value);
705 }
706 }
707
708 for (x= 0; x < KEY_COUNT; x++)
709 free(keys[x]);
710 free(keys);
711 }
712
713 void string_alloc_null(memcached_st *memc)
714 {
715 memcached_string_st *string;
716
717 string= memcached_string_create(memc, 0);
718 assert(string);
719 memcached_string_free(memc, string);
720 }
721
722 void string_alloc_with_size(memcached_st *memc)
723 {
724 memcached_string_st *string;
725
726 string= memcached_string_create(memc, 1024);
727 assert(string);
728 memcached_string_free(memc, string);
729 }
730
731 void string_alloc_with_size_toobig(memcached_st *memc)
732 {
733 memcached_string_st *string;
734
735 string= memcached_string_create(memc, INT64_MAX);
736 assert(string == NULL);
737 }
738
739 void string_alloc_append(memcached_st *memc)
740 {
741 unsigned int x;
742 char buffer[SMALL_STRING_LEN];
743 memcached_string_st *string;
744
745 /* Ring the bell! */
746 memset(buffer, 6, SMALL_STRING_LEN);
747
748 string= memcached_string_create(memc, 100);
749 assert(string);
750
751 for (x= 0; x < 1024; x++)
752 {
753 memcached_return rc;
754 rc= memcached_string_append(memc, string, buffer, SMALL_STRING_LEN);
755 assert(rc == MEMCACHED_SUCCESS);
756 }
757 memcached_string_free(memc, string);
758 }
759
760 void string_alloc_append_toobig(memcached_st *memc)
761 {
762 memcached_return rc;
763 unsigned int x;
764 char buffer[SMALL_STRING_LEN];
765 memcached_string_st *string;
766
767 /* Ring the bell! */
768 memset(buffer, 6, SMALL_STRING_LEN);
769
770 string= memcached_string_create(memc, 100);
771 assert(string);
772
773 for (x= 0; x < 1024; x++)
774 {
775 rc= memcached_string_append(memc, string, buffer, SMALL_STRING_LEN);
776 assert(rc == MEMCACHED_SUCCESS);
777 }
778 rc= memcached_string_append(memc, string, buffer, INT64_MAX);
779 assert(rc == MEMCACHED_MEMORY_ALLOCATION_FAILURE);
780 memcached_string_free(memc, string);
781 }
782
783 void add_host_test1(memcached_st *memc)
784 {
785 unsigned int x;
786 memcached_return rc;
787 char servername[]= "0.example.com";
788 memcached_server_st *servers;
789
790 servers= memcached_server_list_append(NULL, servername, 400, &rc);
791 assert(servers);
792 assert(1 == memcached_server_list_count(servers));
793
794 for (x= 2; x < 20; x++)
795 {
796 char buffer[SMALL_STRING_LEN];
797
798 snprintf(buffer, SMALL_STRING_LEN, "%u.example.com", 400+x);
799 servers= memcached_server_list_append(servers, buffer, 401,
800 &rc);
801 assert(rc == MEMCACHED_SUCCESS);
802 assert(x == memcached_server_list_count(servers));
803 }
804
805 rc= memcached_server_push(memc, servers);
806 assert(rc == MEMCACHED_SUCCESS);
807 rc= memcached_server_push(memc, servers);
808 assert(rc == MEMCACHED_SUCCESS);
809
810 memcached_server_list_free(servers);
811 }
812
813 memcached_return pre_nonblock(memcached_st *memc)
814 {
815 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, NULL);
816
817 return MEMCACHED_SUCCESS;
818 }
819
820 memcached_return pre_md5(memcached_st *memc)
821 {
822 memcached_hash value= MEMCACHED_HASH_MD5;
823 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
824
825 return MEMCACHED_SUCCESS;
826 }
827
828 memcached_return pre_crc(memcached_st *memc)
829 {
830 memcached_hash value= MEMCACHED_HASH_CRC;
831 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
832
833 return MEMCACHED_SUCCESS;
834 }
835
836 memcached_return pre_hash_fnv1_64(memcached_st *memc)
837 {
838 memcached_hash value= MEMCACHED_HASH_FNV1_64;
839 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
840
841 return MEMCACHED_SUCCESS;
842 }
843
844 memcached_return pre_hash_fnv1a_64(memcached_st *memc)
845 {
846 memcached_hash value= MEMCACHED_HASH_FNV1A_64;
847 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
848
849 return MEMCACHED_SUCCESS;
850 }
851
852 memcached_return pre_hash_fnv1_32(memcached_st *memc)
853 {
854 memcached_hash value= MEMCACHED_HASH_FNV1_32;
855 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
856
857 return MEMCACHED_SUCCESS;
858 }
859
860 memcached_return pre_hash_fnv1a_32(memcached_st *memc)
861 {
862 memcached_hash value= MEMCACHED_HASH_FNV1A_32;
863 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
864
865 return MEMCACHED_SUCCESS;
866 }
867
868 memcached_return pre_hash_ketama(memcached_st *memc)
869 {
870 memcached_hash value= MEMCACHED_HASH_KETAMA;
871 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
872
873 return MEMCACHED_SUCCESS;
874 }
875
876 memcached_return pre_unix_socket(memcached_st *memc)
877 {
878 memcached_return rc;
879 struct stat buf;
880
881 memcached_server_list_free(memc->hosts);
882 memc->hosts= NULL;
883 memc->number_of_hosts= 0;
884
885 if (stat("/tmp/memcached.socket", &buf))
886 return MEMCACHED_FAILURE;
887
888 rc= memcached_server_add_unix_socket(memc, "/tmp/memcached.socket");
889
890 return rc;
891 }
892
893 memcached_return pre_nodelay(memcached_st *memc)
894 {
895 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, NULL);
896 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, NULL);
897
898 return MEMCACHED_SUCCESS;
899 }
900
901 typedef struct collection_st collection_st;
902 typedef struct test_st test_st;
903
904 struct test_st {
905 char *name;
906 unsigned int requires_flush;
907 void (*function)(memcached_st *memc);
908 };
909
910 struct collection_st {
911 char *name;
912 memcached_return (*pre)(memcached_st *memc);
913 memcached_return (*post)(memcached_st *memc);
914 test_st *tests;
915 };
916
917 int main(int argc, char *argv[])
918 {
919 unsigned int x;
920 char *server_list;
921 char *collection_to_run= NULL;
922 char *wildcard= NULL;
923 memcached_server_st *servers;
924
925
926 if (argc > 1)
927 collection_to_run= argv[1];
928
929 if (argc == 3)
930 wildcard= argv[2];
931
932 if (!(server_list= getenv("MEMCACHED_SERVERS")))
933 server_list= "localhost";
934
935 printf("servers %s\n", server_list);
936 srandom(time(NULL));
937
938 servers= memcached_servers_parse(server_list);
939 assert(servers);
940
941 for (x= 0; x < memcached_server_list_count(servers); x++)
942 {
943 printf("\t%s : %u\n", servers[x].hostname, servers[x].port);
944 assert(servers[x].stack_responses == 0);
945 assert(servers[x].fd == -1);
946 assert(servers[x].cursor_active == 0);
947 }
948
949 printf("\n");
950
951 /* Clean the server before beginning testing */
952 test_st tests[] ={
953 {"flush", 0, flush_test },
954 {"init", 0, init_test },
955 {"allocation", 0, allocation_test },
956 {"clone_test", 0, clone_test },
957 {"error", 0, error_test },
958 {"set", 0, set_test },
959 {"set2", 0, set_test2 },
960 {"set3", 0, set_test3 },
961 {"add", 0, add_test },
962 {"replace", 0, replace_test },
963 {"delete", 1, delete_test },
964 {"get", 1, get_test },
965 {"get2", 0, get_test2 },
966 {"get3", 0, get_test3 },
967 {"get4", 0, get_test4 },
968 {"stats_servername", 0, stats_servername_test },
969 {"increment", 0, increment_test },
970 {"decrement", 0, decrement_test },
971 {"quit", 0, quit_test },
972 {"mget", 0, mget_test },
973 {"get_stats", 0, get_stats },
974 {"add_host_test", 0, add_host_test },
975 {"get_stats_keys", 0, get_stats_keys },
976 {"behavior_test", 0, get_stats_keys },
977 {0, 0, 0}
978 };
979
980 test_st string_tests[] ={
981 {"string alloc with null", 0, string_alloc_null },
982 {"string alloc with 1K", 0, string_alloc_with_size },
983 {"string alloc with malloc failure", 0, string_alloc_with_size_toobig },
984 {"string append", 0, string_alloc_append },
985 {"string append failure (too big)", 0, string_alloc_append_toobig },
986 {0, 0, 0}
987 };
988
989 test_st user_tests[] ={
990 {"user_supplied_bug1", 0, user_supplied_bug1 },
991 {"user_supplied_bug2", 0, user_supplied_bug2 },
992 {"user_supplied_bug3", 0, user_supplied_bug3 },
993 {0, 0, 0}
994 };
995
996
997 collection_st collection[] ={
998 {"block", 0, 0, tests},
999 {"nonblock", pre_nonblock, 0, tests},
1000 {"nodelay", pre_nodelay, 0, tests},
1001 {"md5", pre_md5, 0, tests},
1002 {"crc", pre_crc, 0, tests},
1003 {"fnv1_64", pre_hash_fnv1_64, 0, tests},
1004 {"fnv1a_64", pre_hash_fnv1a_64, 0, tests},
1005 {"fnv1_32", pre_hash_fnv1_32, 0, tests},
1006 {"fnv1a_32", pre_hash_fnv1a_32, 0, tests},
1007 {"ketama", pre_hash_ketama, 0, tests},
1008 {"unix_socket", pre_unix_socket, 0, tests},
1009 {"unix_socket_nodelay", pre_nodelay, 0, tests},
1010 {"string", 0, 0, string_tests},
1011 {"user", 0, 0, user_tests},
1012 {0, 0, 0, 0}
1013 };
1014
1015 collection_st *next;
1016 for (next= collection; next->name; next++)
1017 {
1018 test_st *run;
1019
1020 run= next->tests;
1021
1022 if (collection_to_run && strcmp(collection_to_run, next->name))
1023 continue;
1024
1025 fprintf(stderr, "\n%s\n\n", next->name);
1026
1027 for (x= 0; run->name; run++)
1028 {
1029 if (wildcard && strcmp(wildcard, run->name))
1030 continue;
1031
1032 fprintf(stderr, "Testing %s", run->name);
1033
1034 memcached_st *memc;
1035 memcached_return rc;
1036 struct timeval start_time, end_time;
1037
1038 memc= memcached_create(NULL);
1039 assert(memc);
1040
1041 if (run->requires_flush)
1042 memcached_flush(memc, 0);
1043
1044 rc= memcached_server_push(memc, servers);
1045 assert(rc == MEMCACHED_SUCCESS);
1046
1047 unsigned int loop;
1048 for (loop= 0; loop < memcached_server_list_count(servers); loop++)
1049 {
1050 assert(memc->hosts[loop].stack_responses == 0);
1051 assert(memc->hosts[loop].fd == -1);
1052 assert(memc->hosts[loop].cursor_active == 0);
1053 }
1054
1055 if (next->pre)
1056 {
1057 memcached_return rc;
1058 rc= next->pre(memc);
1059
1060 if (rc != MEMCACHED_SUCCESS)
1061 {
1062 fprintf(stderr, "\t\t\t\t\t [ skipping ]\n");
1063 goto error;
1064 }
1065 }
1066
1067 gettimeofday(&start_time, NULL);
1068 run->function(memc);
1069 gettimeofday(&end_time, NULL);
1070 long int load_time= timedif(end_time, start_time);
1071 fprintf(stderr, "\t\t\t\t\t %ld.%03ld [ ok ]\n", load_time / 1000,
1072 load_time % 1000);
1073
1074 if (next->post)
1075 (void)next->post(memc);
1076
1077 assert(memc);
1078 error:
1079 memcached_free(memc);
1080 }
1081 }
1082
1083 /* Clean up whatever we might have left */
1084 {
1085 memcached_st *memc;
1086 memc= memcached_create(NULL);
1087 assert(memc);
1088 flush_test(memc);
1089 memcached_free(memc);
1090 }
1091
1092 fprintf(stderr, "All tests completed successfully\n\n");
1093
1094 memcached_server_list_free(servers);
1095
1096 return 0;
1097 }