1 /* libMemcached Functions Test
2 * Copyright (C) 2006-2009 Brian Aker
5 * Use and distribution licensed under the BSD license. See
6 * the COPYING file in the parent directory for full text.
10 Sample test application.
13 #include "libmemcached/common.h"
20 #include <sys/types.h>
29 #define INT64_MAX LONG_MAX
32 #define INT32_MAX INT_MAX
38 #define SERVERS_TO_CREATE 5
42 @note This should be testing to see if the server really supports the binary protocol.
44 static test_return_t
pre_binary(memcached_st
*memc
)
46 memcached_return_t rc
= MEMCACHED_FAILURE
;
47 memcached_st
*memc_clone
;
48 memcached_server_instance_st instance
;
50 memc_clone
= memcached_clone(NULL
, memc
);
51 test_true(memc_clone
);
52 // The memcached_version needs to be done on a clone, because the server
53 // will not toggle protocol on an connection.
54 memcached_version(memc_clone
);
56 instance
= memcached_server_instance_by_position(memc_clone
, 0);
58 if (instance
->major_version
>= 1 && instance
->minor_version
> 2)
60 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
61 test_true(rc
== MEMCACHED_SUCCESS
);
62 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1);
65 memcached_free(memc_clone
);
67 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
70 static void increment_request_id(uint16_t *id
)
73 if ((*id
& UDP_REQUEST_ID_THREAD_MASK
) != 0)
77 static uint16_t *get_udp_request_ids(memcached_st
*memc
)
79 uint16_t *ids
= malloc(sizeof(uint16_t) * memcached_server_count(memc
));
82 for (uint32_t x
= 0; x
< memcached_server_count(memc
); x
++)
84 memcached_server_instance_st instance
=
85 memcached_server_instance_by_position(memc
, x
);
87 ids
[x
]= get_udp_datagram_request_id((struct udp_datagram_header_st
*) ((memcached_server_instance_st
)instance
)->write_buffer
);
93 static test_return_t
post_udp_op_check(memcached_st
*memc
, uint16_t *expected_req_ids
)
96 (void)expected_req_ids
;
98 memcached_server_st
*cur_server
= memcached_server_list(memc
);
99 uint16_t *cur_req_ids
= get_udp_request_ids(memc
);
101 for (size_t x
= 0; x
< memcached_server_count(memc
); x
++)
103 test_true(cur_server
[x
].cursor_active
== 0);
104 test_true(cur_req_ids
[x
] == expected_req_ids
[x
]);
106 free(expected_req_ids
);
114 ** There is a little bit of a hack here, instead of removing
115 ** the servers, I just set num host to 0 and them add then new udp servers
117 static test_return_t
init_udp(memcached_st
*memc
)
119 memcached_version(memc
);
121 memcached_server_instance_st instance
=
122 memcached_server_instance_by_position(memc
, 0);
124 /* For the time being, only support udp test for >= 1.2.6 && < 1.3 */
125 if (instance
->major_version
!= 1 || instance
->minor_version
!= 2
126 || instance
->micro_version
< 6)
129 uint32_t num_hosts
= memcached_server_count(memc
);
130 memcached_server_st servers
[num_hosts
];
131 memcpy(servers
, memcached_server_list(memc
), sizeof(memcached_server_st
) * num_hosts
);
132 for (uint32_t x
= 0; x
< num_hosts
; x
++)
134 memcached_server_instance_st set_instance
=
135 memcached_server_instance_by_position(memc
, x
);
137 memcached_server_free(((memcached_server_write_instance_st
)set_instance
));
140 memc
->number_of_hosts
= 0;
141 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_USE_UDP
, 1);
142 for (uint32_t x
= 0; x
< num_hosts
; x
++)
144 memcached_server_instance_st set_instance
=
145 memcached_server_instance_by_position(memc
, x
);
147 test_true(memcached_server_add_udp(memc
, servers
[x
].hostname
, servers
[x
].port
) == MEMCACHED_SUCCESS
);
148 test_true(set_instance
->write_buffer_offset
== UDP_DATAGRAM_HEADER_LENGTH
);
155 static test_return_t
binary_init_udp(memcached_st
*memc
)
157 test_return_t test_rc
;
158 test_rc
= pre_binary(memc
);
160 if (test_rc
!= TEST_SUCCESS
)
163 return init_udp(memc
);
166 /* Make sure that I cant add a tcp server to a udp client */
167 static test_return_t
add_tcp_server_udp_client_test(memcached_st
*memc
)
171 memcached_server_st server
;
172 memcached_server_instance_st instance
=
173 memcached_server_instance_by_position(memc
, 0);
174 memcached_server_clone(&server
, &memc
->hosts
[0]);
175 test_true(memcached_server_remove(&(memc
->hosts
[0])) == MEMCACHED_SUCCESS
);
176 test_true(memcached_server_add(memc
, server
.hostname
, server
.port
) == MEMCACHED_INVALID_HOST_PROTOCOL
);
181 /* Make sure that I cant add a udp server to a tcp client */
182 static test_return_t
add_udp_server_tcp_client_test(memcached_st
*memc
)
186 memcached_server_st server
;
187 memcached_server_instance_st instance
=
188 memcached_server_instance_by_position(memc
, 0);
189 memcached_server_clone(&server
, &memc
->hosts
[0]);
190 test_true(memcached_server_remove(&(memc
->hosts
[0])) == MEMCACHED_SUCCESS
);
192 memcached_st tcp_client
;
193 memcached_create(&tcp_client
);
194 test_true(memcached_server_add_udp(&tcp_client
, server
.hostname
, server
.port
) == MEMCACHED_INVALID_HOST_PROTOCOL
);
200 static test_return_t
set_udp_behavior_test(memcached_st
*memc
)
203 memcached_quit(memc
);
204 memc
->number_of_hosts
= 0;
205 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, memc
->distribution
);
206 test_true(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_USE_UDP
, 1) == MEMCACHED_SUCCESS
);
207 test_true(memc
->flags
.use_udp
);
208 test_true(memc
->flags
.no_reply
);
210 test_true(memcached_server_count(memc
) == 0);
212 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_USE_UDP
,0);
213 test_true(! (memc
->flags
.use_udp
));
214 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
,0);
215 test_true(! (memc
->flags
.no_reply
));
220 static test_return_t
udp_set_test(memcached_st
*memc
)
222 unsigned int num_iters
= 1025; //request id rolls over at 1024
224 for (size_t x
= 0; x
< num_iters
;x
++)
226 memcached_return_t rc
;
227 const char *key
= "foo";
228 const char *value
= "when we sanitize";
229 uint16_t *expected_ids
= get_udp_request_ids(memc
);
230 unsigned int server_key
= memcached_generate_hash(memc
, key
, strlen(key
));
231 memcached_server_instance_st instance
=
232 memcached_server_instance_by_position(memc
, server_key
);
233 size_t init_offset
= instance
->write_buffer_offset
;
235 rc
= memcached_set(memc
, key
, strlen(key
),
236 value
, strlen(value
),
237 (time_t)0, (uint32_t)0);
238 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
239 /** NB, the check below assumes that if new write_ptr is less than
240 * the original write_ptr that we have flushed. For large payloads, this
241 * maybe an invalid assumption, but for the small payload we have it is OK
243 if (rc
== MEMCACHED_SUCCESS
||
244 instance
->write_buffer_offset
< init_offset
)
245 increment_request_id(&expected_ids
[server_key
]);
247 if (rc
== MEMCACHED_SUCCESS
)
249 test_true(instance
->write_buffer_offset
== UDP_DATAGRAM_HEADER_LENGTH
);
253 test_true(instance
->write_buffer_offset
!= UDP_DATAGRAM_HEADER_LENGTH
);
254 test_true(instance
->write_buffer_offset
<= MAX_UDP_DATAGRAM_LENGTH
);
256 test_true(post_udp_op_check(memc
, expected_ids
) == TEST_SUCCESS
);
261 static test_return_t
udp_buffered_set_test(memcached_st
*memc
)
263 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
264 return udp_set_test(memc
);
267 static test_return_t
udp_set_too_big_test(memcached_st
*memc
)
269 memcached_return_t rc
;
270 const char *key
= "bar";
271 char value
[MAX_UDP_DATAGRAM_LENGTH
];
272 uint16_t *expected_ids
= get_udp_request_ids(memc
);
273 rc
= memcached_set(memc
, key
, strlen(key
),
274 value
, MAX_UDP_DATAGRAM_LENGTH
,
275 (time_t)0, (uint32_t)0);
276 test_true(rc
== MEMCACHED_WRITE_FAILURE
);
278 return post_udp_op_check(memc
,expected_ids
);
281 static test_return_t
udp_delete_test(memcached_st
*memc
)
283 unsigned int num_iters
= 1025; //request id rolls over at 1024
285 for (size_t x
= 0; x
< num_iters
;x
++)
287 memcached_return_t rc
;
288 const char *key
= "foo";
289 uint16_t *expected_ids
=get_udp_request_ids(memc
);
290 unsigned int server_key
= memcached_generate_hash(memc
, key
, strlen(key
));
291 memcached_server_instance_st instance
=
292 memcached_server_instance_by_position(memc
, server_key
);
293 size_t init_offset
= instance
->write_buffer_offset
;
295 rc
= memcached_delete(memc
, key
, strlen(key
), 0);
296 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
298 if (rc
== MEMCACHED_SUCCESS
|| instance
->write_buffer_offset
< init_offset
)
299 increment_request_id(&expected_ids
[server_key
]);
300 if (rc
== MEMCACHED_SUCCESS
)
302 test_true(instance
->write_buffer_offset
== UDP_DATAGRAM_HEADER_LENGTH
);
306 test_true(instance
->write_buffer_offset
!= UDP_DATAGRAM_HEADER_LENGTH
);
307 test_true(instance
->write_buffer_offset
<= MAX_UDP_DATAGRAM_LENGTH
);
309 test_true(post_udp_op_check(memc
,expected_ids
) == TEST_SUCCESS
);
314 static test_return_t
udp_buffered_delete_test(memcached_st
*memc
)
316 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
317 return udp_delete_test(memc
);
320 static test_return_t
udp_verbosity_test(memcached_st
*memc
)
322 memcached_return_t rc
;
323 uint16_t *expected_ids
= get_udp_request_ids(memc
);
325 for (size_t x
= 0; x
< memcached_server_count(memc
); x
++)
327 increment_request_id(&expected_ids
[x
]);
330 rc
= memcached_verbosity(memc
,3);
331 test_true(rc
== MEMCACHED_SUCCESS
);
332 return post_udp_op_check(memc
,expected_ids
);
335 static test_return_t
udp_quit_test(memcached_st
*memc
)
337 uint16_t *expected_ids
= get_udp_request_ids(memc
);
338 memcached_quit(memc
);
339 return post_udp_op_check(memc
, expected_ids
);
342 static test_return_t
udp_flush_test(memcached_st
*memc
)
344 memcached_return_t rc
;
345 uint16_t *expected_ids
= get_udp_request_ids(memc
);
347 for (size_t x
= 0; x
< memcached_server_count(memc
); x
++)
349 increment_request_id(&expected_ids
[x
]);
352 rc
= memcached_flush(memc
,0);
353 test_true(rc
== MEMCACHED_SUCCESS
);
354 return post_udp_op_check(memc
,expected_ids
);
357 static test_return_t
udp_incr_test(memcached_st
*memc
)
359 memcached_return_t rc
;
360 const char *key
= "incr";
361 const char *value
= "1";
362 rc
= memcached_set(memc
, key
, strlen(key
),
363 value
, strlen(value
),
364 (time_t)0, (uint32_t)0);
366 test_true(rc
== MEMCACHED_SUCCESS
);
367 uint16_t *expected_ids
= get_udp_request_ids(memc
);
368 unsigned int server_key
= memcached_generate_hash(memc
, key
, strlen(key
));
369 increment_request_id(&expected_ids
[server_key
]);
371 rc
= memcached_increment(memc
, key
, strlen(key
), 1, &newvalue
);
372 test_true(rc
== MEMCACHED_SUCCESS
);
373 return post_udp_op_check(memc
, expected_ids
);
376 static test_return_t
udp_decr_test(memcached_st
*memc
)
378 memcached_return_t rc
;
379 const char *key
= "decr";
380 const char *value
= "1";
381 rc
= memcached_set(memc
, key
, strlen(key
),
382 value
, strlen(value
),
383 (time_t)0, (uint32_t)0);
385 test_true(rc
== MEMCACHED_SUCCESS
);
386 uint16_t *expected_ids
= get_udp_request_ids(memc
);
387 unsigned int server_key
= memcached_generate_hash(memc
, key
, strlen(key
));
388 increment_request_id(&expected_ids
[server_key
]);
390 rc
= memcached_decrement(memc
, key
, strlen(key
), 1, &newvalue
);
391 test_true(rc
== MEMCACHED_SUCCESS
);
392 return post_udp_op_check(memc
, expected_ids
);
396 static test_return_t
udp_stat_test(memcached_st
*memc
)
398 memcached_stat_st
* rv
= NULL
;
399 memcached_return_t rc
;
401 uint16_t *expected_ids
= get_udp_request_ids(memc
);
402 rv
= memcached_stat(memc
, args
, &rc
);
404 test_true(rc
== MEMCACHED_NOT_SUPPORTED
);
405 return post_udp_op_check(memc
, expected_ids
);
408 static test_return_t
udp_version_test(memcached_st
*memc
)
410 memcached_return_t rc
;
411 uint16_t *expected_ids
= get_udp_request_ids(memc
);
412 rc
= memcached_version(memc
);
413 test_true(rc
== MEMCACHED_NOT_SUPPORTED
);
414 return post_udp_op_check(memc
, expected_ids
);
417 static test_return_t
udp_get_test(memcached_st
*memc
)
419 memcached_return_t rc
;
420 const char *key
= "foo";
422 uint16_t *expected_ids
= get_udp_request_ids(memc
);
423 char *val
= memcached_get(memc
, key
, strlen(key
), &vlen
, (uint32_t)0, &rc
);
424 test_true(rc
== MEMCACHED_NOT_SUPPORTED
);
425 test_true(val
== NULL
);
426 return post_udp_op_check(memc
, expected_ids
);
429 static test_return_t
udp_mixed_io_test(memcached_st
*memc
)
432 test_st mixed_io_ops
[] ={
434 (test_callback_fn
)udp_set_test
},
435 {"udp_set_too_big_test", 0,
436 (test_callback_fn
)udp_set_too_big_test
},
437 {"udp_delete_test", 0,
438 (test_callback_fn
)udp_delete_test
},
439 {"udp_verbosity_test", 0,
440 (test_callback_fn
)udp_verbosity_test
},
442 (test_callback_fn
)udp_quit_test
},
443 {"udp_flush_test", 0,
444 (test_callback_fn
)udp_flush_test
},
446 (test_callback_fn
)udp_incr_test
},
448 (test_callback_fn
)udp_decr_test
},
449 {"udp_version_test", 0,
450 (test_callback_fn
)udp_version_test
}
453 for (size_t x
= 0; x
< 500; x
++)
455 current_op
= mixed_io_ops
[random() % 9];
456 test_true(current_op
.test_fn(memc
) == TEST_SUCCESS
);
461 test_st udp_setup_server_tests
[] ={
462 {"set_udp_behavior_test", 0, (test_callback_fn
)set_udp_behavior_test
},
463 {"add_tcp_server_udp_client_test", 0, (test_callback_fn
)add_tcp_server_udp_client_test
},
464 {"add_udp_server_tcp_client_test", 0, (test_callback_fn
)add_udp_server_tcp_client_test
},
468 test_st upd_io_tests
[] ={
469 {"udp_set_test", 0, (test_callback_fn
)udp_set_test
},
470 {"udp_buffered_set_test", 0, (test_callback_fn
)udp_buffered_set_test
},
471 {"udp_set_too_big_test", 0, (test_callback_fn
)udp_set_too_big_test
},
472 {"udp_delete_test", 0, (test_callback_fn
)udp_delete_test
},
473 {"udp_buffered_delete_test", 0, (test_callback_fn
)udp_buffered_delete_test
},
474 {"udp_verbosity_test", 0, (test_callback_fn
)udp_verbosity_test
},
475 {"udp_quit_test", 0, (test_callback_fn
)udp_quit_test
},
476 {"udp_flush_test", 0, (test_callback_fn
)udp_flush_test
},
477 {"udp_incr_test", 0, (test_callback_fn
)udp_incr_test
},
478 {"udp_decr_test", 0, (test_callback_fn
)udp_decr_test
},
479 {"udp_stat_test", 0, (test_callback_fn
)udp_stat_test
},
480 {"udp_version_test", 0, (test_callback_fn
)udp_version_test
},
481 {"udp_get_test", 0, (test_callback_fn
)udp_get_test
},
482 {"udp_mixed_io_test", 0, (test_callback_fn
)udp_mixed_io_test
},
486 collection_st collection
[] ={
487 {"udp_setup", (test_callback_fn
)init_udp
, 0, udp_setup_server_tests
},
488 {"udp_io", (test_callback_fn
)init_udp
, 0, upd_io_tests
},
489 {"udp_binary_io", (test_callback_fn
)binary_init_udp
, 0, upd_io_tests
},
493 #define SERVERS_TO_CREATE 5
495 #include "libmemcached_world.h"
497 void get_world(world_st
*world
)
499 world
->collections
= collection
;
501 world
->create
= (test_callback_create_fn
)world_create
;
502 world
->destroy
= (test_callback_fn
)world_destroy
;
504 world
->test
.startup
= (test_callback_fn
)world_test_startup
;
505 world
->test
.flush
= (test_callback_fn
)world_flush
;
506 world
->test
.pre_run
= (test_callback_fn
)world_pre_run
;
507 world
->test
.post_run
= (test_callback_fn
)world_post_run
;
508 world
->test
.on_error
= (test_callback_error_fn
)world_on_error
;
510 world
->collection
.startup
= (test_callback_fn
)world_container_startup
;
511 world
->collection
.shutdown
= (test_callback_fn
)world_container_shutdown
;
513 world
->runner
= &defualt_libmemcached_runner
;