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.
14 #include <libtest/test.hpp>
16 using namespace libtest
;
18 #include <libmemcached/memcached.h>
19 #include <libmemcached/server_instance.h>
20 #include <libmemcached/io.h>
28 #include <sys/types.h>
34 #include <libtest/server.h>
36 #define SERVERS_TO_CREATE 5
38 #ifndef __INTEL_COMPILER
39 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
43 @note This should be testing to see if the server really supports the binary protocol.
45 static test_return_t
pre_binary(memcached_st
*memc
)
47 memcached_return_t rc
= MEMCACHED_FAILURE
;
48 memcached_st
*memc_clone
;
49 memcached_server_instance_st instance
;
51 memc_clone
= memcached_clone(NULL
, memc
);
52 test_true(memc_clone
);
53 // The memcached_version needs to be done on a clone, because the server
54 // will not toggle protocol on an connection.
55 memcached_version(memc_clone
);
57 instance
= memcached_server_instance_by_position(memc_clone
, 0);
59 if (instance
->major_version
>= 1 && instance
->minor_version
> 2)
61 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
62 test_true(rc
== MEMCACHED_SUCCESS
);
63 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1);
66 memcached_free(memc_clone
);
68 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
71 static void increment_request_id(uint16_t *id
)
74 if ((*id
& UDP_REQUEST_ID_THREAD_MASK
) != 0)
78 static uint16_t *get_udp_request_ids(memcached_st
*memc
)
80 uint16_t *ids
= (uint16_t*)malloc(sizeof(uint16_t) * memcached_server_count(memc
));
83 for (uint32_t x
= 0; x
< memcached_server_count(memc
); x
++)
85 memcached_server_instance_st instance
=
86 memcached_server_instance_by_position(memc
, x
);
88 ids
[x
]= get_udp_datagram_request_id((struct udp_datagram_header_st
*) ((memcached_server_instance_st
)instance
)->write_buffer
);
94 static test_return_t
post_udp_op_check(memcached_st
*memc
, uint16_t *expected_req_ids
)
97 (void)expected_req_ids
;
99 memcached_server_st
*cur_server
= memcached_server_list(memc
);
100 uint16_t *cur_req_ids
= get_udp_request_ids(memc
);
102 for (size_t x
= 0; x
< memcached_server_count(memc
); x
++)
104 test_true(cur_server
[x
].cursor_active
== 0);
105 test_true(cur_req_ids
[x
] == expected_req_ids
[x
]);
107 free(expected_req_ids
);
115 ** There is a little bit of a hack here, instead of removing
116 ** the servers, I just set num host to 0 and them add then new udp servers
118 static test_return_t
init_udp(memcached_st
*memc
)
120 memcached_version(memc
);
122 memcached_server_instance_st instance
=
123 memcached_server_instance_by_position(memc
, 0);
125 /* For the time being, only support udp test for >= 1.2.6 && < 1.3 */
126 if (instance
->major_version
!= 1 || instance
->minor_version
!= 2
127 || instance
->micro_version
< 6)
130 uint32_t num_hosts
= memcached_server_count(memc
);
131 memcached_server_st servers
[num_hosts
];
132 memcpy(servers
, memcached_server_list(memc
), sizeof(memcached_server_st
) * num_hosts
);
133 for (uint32_t x
= 0; x
< num_hosts
; x
++)
135 memcached_server_instance_st set_instance
=
136 memcached_server_instance_by_position(memc
, x
);
138 memcached_server_free(((memcached_server_write_instance_st
)set_instance
));
141 memc
->number_of_hosts
= 0;
142 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_USE_UDP
, 1);
143 for (uint32_t x
= 0; x
< num_hosts
; x
++)
145 memcached_server_instance_st set_instance
=
146 memcached_server_instance_by_position(memc
, x
);
148 test_true(memcached_server_add_udp(memc
, servers
[x
].hostname
, servers
[x
].port
) == MEMCACHED_SUCCESS
);
149 test_true(set_instance
->write_buffer_offset
== UDP_DATAGRAM_HEADER_LENGTH
);
156 static test_return_t
binary_init_udp(memcached_st
*memc
)
158 test_return_t test_rc
;
159 test_rc
= pre_binary(memc
);
161 if (test_rc
!= TEST_SUCCESS
)
164 return init_udp(memc
);
167 /* Make sure that I cant add a tcp server to a udp client */
168 static test_return_t
add_tcp_server_udp_client_test(memcached_st
*memc
)
172 memcached_server_st server
;
173 memcached_server_instance_st instance
=
174 memcached_server_instance_by_position(memc
, 0);
175 memcached_server_clone(&server
, &memc
->hosts
[0]);
176 test_true(memcached_server_remove(&(memc
->hosts
[0])) == MEMCACHED_SUCCESS
);
177 test_true(memcached_server_add(memc
, server
.hostname
, server
.port
) == MEMCACHED_INVALID_HOST_PROTOCOL
);
182 /* Make sure that I cant add a udp server to a tcp client */
183 static test_return_t
add_udp_server_tcp_client_test(memcached_st
*memc
)
187 memcached_server_st server
;
188 memcached_server_instance_st instance
=
189 memcached_server_instance_by_position(memc
, 0);
190 memcached_server_clone(&server
, &memc
->hosts
[0]);
191 test_true(memcached_server_remove(&(memc
->hosts
[0])) == MEMCACHED_SUCCESS
);
193 memcached_st tcp_client
;
194 memcached_create(&tcp_client
);
195 test_true(memcached_server_add_udp(&tcp_client
, server
.hostname
, server
.port
) == MEMCACHED_INVALID_HOST_PROTOCOL
);
201 static test_return_t
set_udp_behavior_test(memcached_st
*memc
)
204 memcached_quit(memc
);
205 memc
->number_of_hosts
= 0;
206 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, memc
->distribution
);
207 test_true(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_USE_UDP
, 1) == MEMCACHED_SUCCESS
);
208 test_true(memc
->flags
.use_udp
);
209 test_true(memc
->flags
.no_reply
);
211 test_true(memcached_server_count(memc
) == 0);
213 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_USE_UDP
,0);
214 test_true(! (memc
->flags
.use_udp
));
215 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
,0);
216 test_true(! (memc
->flags
.no_reply
));
221 static test_return_t
udp_set_test(memcached_st
*memc
)
223 unsigned int num_iters
= 1025; //request id rolls over at 1024
225 for (size_t x
= 0; x
< num_iters
;x
++)
227 memcached_return_t rc
;
228 const char *key
= "foo";
229 const char *value
= "when we sanitize";
230 uint16_t *expected_ids
= get_udp_request_ids(memc
);
231 unsigned int server_key
= memcached_generate_hash(memc
, key
, strlen(key
));
232 memcached_server_instance_st instance
=
233 memcached_server_instance_by_position(memc
, server_key
);
234 size_t init_offset
= instance
->write_buffer_offset
;
236 rc
= memcached_set(memc
, key
, strlen(key
),
237 value
, strlen(value
),
238 (time_t)0, (uint32_t)0);
239 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
240 /** NB, the check below assumes that if new write_ptr is less than
241 * the original write_ptr that we have flushed. For large payloads, this
242 * maybe an invalid assumption, but for the small payload we have it is OK
244 if (rc
== MEMCACHED_SUCCESS
||
245 instance
->write_buffer_offset
< init_offset
)
246 increment_request_id(&expected_ids
[server_key
]);
248 if (rc
== MEMCACHED_SUCCESS
)
250 test_true(instance
->write_buffer_offset
== UDP_DATAGRAM_HEADER_LENGTH
);
254 test_true(instance
->write_buffer_offset
!= UDP_DATAGRAM_HEADER_LENGTH
);
255 test_true(instance
->write_buffer_offset
<= MAX_UDP_DATAGRAM_LENGTH
);
257 test_true(post_udp_op_check(memc
, expected_ids
) == TEST_SUCCESS
);
262 static test_return_t
udp_buffered_set_test(memcached_st
*memc
)
264 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
265 return udp_set_test(memc
);
268 static test_return_t
udp_set_too_big_test(memcached_st
*memc
)
270 memcached_return_t rc
;
271 const char *key
= "bar";
272 char value
[MAX_UDP_DATAGRAM_LENGTH
];
273 uint16_t *expected_ids
= get_udp_request_ids(memc
);
274 rc
= memcached_set(memc
, key
, strlen(key
),
275 value
, MAX_UDP_DATAGRAM_LENGTH
,
276 (time_t)0, (uint32_t)0);
277 test_true(rc
== MEMCACHED_WRITE_FAILURE
);
279 return post_udp_op_check(memc
,expected_ids
);
282 static test_return_t
udp_delete_test(memcached_st
*memc
)
284 unsigned int num_iters
= 1025; //request id rolls over at 1024
286 for (size_t x
= 0; x
< num_iters
;x
++)
288 memcached_return_t rc
;
289 const char *key
= "foo";
290 uint16_t *expected_ids
=get_udp_request_ids(memc
);
291 unsigned int server_key
= memcached_generate_hash(memc
, key
, strlen(key
));
292 memcached_server_instance_st instance
=
293 memcached_server_instance_by_position(memc
, server_key
);
294 size_t init_offset
= instance
->write_buffer_offset
;
296 rc
= memcached_delete(memc
, key
, strlen(key
), 0);
297 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
299 if (rc
== MEMCACHED_SUCCESS
|| instance
->write_buffer_offset
< init_offset
)
300 increment_request_id(&expected_ids
[server_key
]);
301 if (rc
== MEMCACHED_SUCCESS
)
303 test_true(instance
->write_buffer_offset
== UDP_DATAGRAM_HEADER_LENGTH
);
307 test_true(instance
->write_buffer_offset
!= UDP_DATAGRAM_HEADER_LENGTH
);
308 test_true(instance
->write_buffer_offset
<= MAX_UDP_DATAGRAM_LENGTH
);
310 test_true(post_udp_op_check(memc
,expected_ids
) == TEST_SUCCESS
);
315 static test_return_t
udp_buffered_delete_test(memcached_st
*memc
)
317 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
318 return udp_delete_test(memc
);
321 static test_return_t
udp_verbosity_test(memcached_st
*memc
)
323 memcached_return_t rc
;
324 uint16_t *expected_ids
= get_udp_request_ids(memc
);
326 for (size_t x
= 0; x
< memcached_server_count(memc
); x
++)
328 increment_request_id(&expected_ids
[x
]);
331 rc
= memcached_verbosity(memc
,3);
332 test_true(rc
== MEMCACHED_SUCCESS
);
333 return post_udp_op_check(memc
,expected_ids
);
336 static test_return_t
udp_quit_test(memcached_st
*memc
)
338 uint16_t *expected_ids
= get_udp_request_ids(memc
);
339 memcached_quit(memc
);
340 return post_udp_op_check(memc
, expected_ids
);
343 static test_return_t
udp_flush_test(memcached_st
*memc
)
345 memcached_return_t rc
;
346 uint16_t *expected_ids
= get_udp_request_ids(memc
);
348 for (size_t x
= 0; x
< memcached_server_count(memc
); x
++)
350 increment_request_id(&expected_ids
[x
]);
353 rc
= memcached_flush(memc
,0);
354 test_true(rc
== MEMCACHED_SUCCESS
);
355 return post_udp_op_check(memc
,expected_ids
);
358 static test_return_t
udp_incr_test(memcached_st
*memc
)
360 memcached_return_t rc
;
361 const char *key
= "incr";
362 const char *value
= "1";
363 rc
= memcached_set(memc
, key
, strlen(key
),
364 value
, strlen(value
),
365 (time_t)0, (uint32_t)0);
367 test_true(rc
== MEMCACHED_SUCCESS
);
368 uint16_t *expected_ids
= get_udp_request_ids(memc
);
369 unsigned int server_key
= memcached_generate_hash(memc
, key
, strlen(key
));
370 increment_request_id(&expected_ids
[server_key
]);
372 rc
= memcached_increment(memc
, key
, strlen(key
), 1, &newvalue
);
373 test_true(rc
== MEMCACHED_SUCCESS
);
374 return post_udp_op_check(memc
, expected_ids
);
377 static test_return_t
udp_decr_test(memcached_st
*memc
)
379 memcached_return_t rc
;
380 const char *key
= "decr";
381 const char *value
= "1";
382 rc
= memcached_set(memc
, key
, strlen(key
),
383 value
, strlen(value
),
384 (time_t)0, (uint32_t)0);
386 test_true(rc
== MEMCACHED_SUCCESS
);
387 uint16_t *expected_ids
= get_udp_request_ids(memc
);
388 unsigned int server_key
= memcached_generate_hash(memc
, key
, strlen(key
));
389 increment_request_id(&expected_ids
[server_key
]);
391 rc
= memcached_decrement(memc
, key
, strlen(key
), 1, &newvalue
);
392 test_true(rc
== MEMCACHED_SUCCESS
);
393 return post_udp_op_check(memc
, expected_ids
);
397 static test_return_t
udp_stat_test(memcached_st
*memc
)
399 memcached_stat_st
* rv
= NULL
;
400 memcached_return_t rc
;
402 uint16_t *expected_ids
= get_udp_request_ids(memc
);
403 rv
= memcached_stat(memc
, args
, &rc
);
405 test_true(rc
== MEMCACHED_NOT_SUPPORTED
);
406 return post_udp_op_check(memc
, expected_ids
);
409 static test_return_t
udp_version_test(memcached_st
*memc
)
411 memcached_return_t rc
;
412 uint16_t *expected_ids
= get_udp_request_ids(memc
);
413 rc
= memcached_version(memc
);
414 test_true(rc
== MEMCACHED_NOT_SUPPORTED
);
415 return post_udp_op_check(memc
, expected_ids
);
418 static test_return_t
udp_get_test(memcached_st
*memc
)
420 memcached_return_t rc
;
421 const char *key
= "foo";
423 uint16_t *expected_ids
= get_udp_request_ids(memc
);
424 char *val
= memcached_get(memc
, key
, strlen(key
), &vlen
, (uint32_t)0, &rc
);
425 test_true(rc
== MEMCACHED_NOT_SUPPORTED
);
426 test_true(val
== NULL
);
427 return post_udp_op_check(memc
, expected_ids
);
430 static test_return_t
udp_mixed_io_test(memcached_st
*memc
)
433 test_st mixed_io_ops
[] ={
435 (test_callback_fn
*)udp_set_test
},
436 {"udp_set_too_big_test", 0,
437 (test_callback_fn
*)udp_set_too_big_test
},
438 {"udp_delete_test", 0,
439 (test_callback_fn
*)udp_delete_test
},
440 {"udp_verbosity_test", 0,
441 (test_callback_fn
*)udp_verbosity_test
},
443 (test_callback_fn
*)udp_quit_test
},
444 {"udp_flush_test", 0,
445 (test_callback_fn
*)udp_flush_test
},
447 (test_callback_fn
*)udp_incr_test
},
449 (test_callback_fn
*)udp_decr_test
},
450 {"udp_version_test", 0,
451 (test_callback_fn
*)udp_version_test
}
454 for (size_t x
= 0; x
< 500; x
++)
456 current_op
= mixed_io_ops
[random() % 9];
457 test_true(current_op
.test_fn(memc
) == TEST_SUCCESS
);
462 test_st udp_setup_server_tests
[] ={
463 {"set_udp_behavior_test", 0, (test_callback_fn
*)set_udp_behavior_test
},
464 {"add_tcp_server_udp_client_test", 0, (test_callback_fn
*)add_tcp_server_udp_client_test
},
465 {"add_udp_server_tcp_client_test", 0, (test_callback_fn
*)add_udp_server_tcp_client_test
},
469 test_st upd_io_tests
[] ={
470 {"udp_set_test", 0, (test_callback_fn
*)udp_set_test
},
471 {"udp_buffered_set_test", 0, (test_callback_fn
*)udp_buffered_set_test
},
472 {"udp_set_too_big_test", 0, (test_callback_fn
*)udp_set_too_big_test
},
473 {"udp_delete_test", 0, (test_callback_fn
*)udp_delete_test
},
474 {"udp_buffered_delete_test", 0, (test_callback_fn
*)udp_buffered_delete_test
},
475 {"udp_verbosity_test", 0, (test_callback_fn
*)udp_verbosity_test
},
476 {"udp_quit_test", 0, (test_callback_fn
*)udp_quit_test
},
477 {"udp_flush_test", 0, (test_callback_fn
*)udp_flush_test
},
478 {"udp_incr_test", 0, (test_callback_fn
*)udp_incr_test
},
479 {"udp_decr_test", 0, (test_callback_fn
*)udp_decr_test
},
480 {"udp_stat_test", 0, (test_callback_fn
*)udp_stat_test
},
481 {"udp_version_test", 0, (test_callback_fn
*)udp_version_test
},
482 {"udp_get_test", 0, (test_callback_fn
*)udp_get_test
},
483 {"udp_mixed_io_test", 0, (test_callback_fn
*)udp_mixed_io_test
},
487 collection_st collection
[] ={
488 {"udp_setup", (test_callback_fn
*)init_udp
, 0, udp_setup_server_tests
},
489 {"udp_io", (test_callback_fn
*)init_udp
, 0, upd_io_tests
},
490 {"udp_binary_io", (test_callback_fn
*)binary_init_udp
, 0, upd_io_tests
},
494 #define SERVERS_TO_CREATE 5
496 #define TEST_PORT_BASE MEMCACHED_DEFAULT_PORT +10
497 #include "libmemcached_world.h"
499 void get_world(Framework
*world
)
501 world
->collections
= collection
;
503 world
->_create
= (test_callback_create_fn
*)world_create
;
504 world
->_destroy
= (test_callback_destroy_fn
*)world_destroy
;
506 world
->item
._startup
= (test_callback_fn
*)world_test_startup
;
507 world
->item
._flush
= (test_callback_fn
*)world_flush
;
508 world
->item
.set_pre((test_callback_fn
*)world_pre_run
);
509 world
->item
.set_post((test_callback_fn
*)world_post_run
);
510 world
->_on_error
= (test_callback_error_fn
*)world_on_error
;
512 world
->collection_startup
= (test_callback_fn
*)world_container_startup
;
513 world
->collection_shutdown
= (test_callback_fn
*)world_container_shutdown
;
515 world
->set_runner(&defualt_libmemcached_runner
);