1 /* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
2 *
3 * Cycle the Gearmand server
4 *
5 * Copyright (C) 2011 Data Differential, http://datadifferential.com/
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions are
9 * met:
10 *
11 * * Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 *
14 * * Redistributions in binary form must reproduce the above
15 * copyright notice, this list of conditions and the following disclaimer
16 * in the documentation and/or other materials provided with the
17 * distribution.
18 *
19 * * The names of its contributors may not be used to endorse or
20 * promote products derived from this software without specific prior
21 * written permission.
22 *
23 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
24 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
25 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
26 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
27 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
28 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
29 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
30 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
31 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
32 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
33 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
34 *
35 */
36
37
38 /*
39 Test that we are cycling the servers we are creating during testing.
40 */
41
42 #include "gear_config.h"
43
44 #include <libtest/test.hpp>
45
46 #include "libgearman/client.hpp"
47 #include "libgearman/worker.hpp"
48 using namespace org::gearmand;
49
50 #include <fstream>
51
52 using namespace libtest;
53
54 #ifndef __INTEL_COMPILER
55 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
56 #endif
57
58 static std::string executable;
59
postion_TEST(void *)60 static test_return_t postion_TEST(void *)
61 {
62 const char *args[]= { "foo", 0 };
63
64 ASSERT_EQ(EXIT_FAILURE, exec_cmdline(gearmand_binary(), args, true));
65 return TEST_SUCCESS;
66 }
67
partial_TEST(void *)68 static test_return_t partial_TEST(void *)
69 {
70 const char *args[]= { "--log", 0 };
71
72 ASSERT_EQ(EXIT_FAILURE, exec_cmdline(gearmand_binary(), args, true));
73 return TEST_SUCCESS;
74 }
75
check_args_test(void *)76 static test_return_t check_args_test(void *)
77 {
78 const char *args[]= { "--check-args", 0 };
79
80 ASSERT_EQ(EXIT_SUCCESS, exec_cmdline(gearmand_binary(), args, true));
81 return TEST_SUCCESS;
82 }
83
long_backlog_test(void *)84 static test_return_t long_backlog_test(void *)
85 {
86 const char *args[]= { "--check-args", "--backlog=10", 0 };
87
88 ASSERT_EQ(EXIT_SUCCESS, exec_cmdline(gearmand_binary(), args, true));
89 return TEST_SUCCESS;
90 }
91
short_backlog_test(void *)92 static test_return_t short_backlog_test(void *)
93 {
94 const char *args[]= { "--check-args", "-b", "10", 0 };
95
96 ASSERT_EQ(EXIT_SUCCESS, exec_cmdline(gearmand_binary(), args, true));
97 return TEST_SUCCESS;
98 }
99
long_daemon_test(void *)100 static test_return_t long_daemon_test(void *)
101 {
102 const char *args[]= { "--check-args", "--daemon", 0 };
103
104 ASSERT_EQ(EXIT_SUCCESS, exec_cmdline(gearmand_binary(), args, true));
105 return TEST_SUCCESS;
106 }
107
long_coredump_TEST(void *)108 static test_return_t long_coredump_TEST(void *)
109 {
110 const char *args[]= { "--check-args", "--coredump", 0 };
111
112 ASSERT_EQ(EXIT_SUCCESS, exec_cmdline(gearmand_binary(), args, true));
113 return TEST_SUCCESS;
114 }
115
short_daemon_test(void *)116 static test_return_t short_daemon_test(void *)
117 {
118 const char *args[]= { "--check-args", "-d", 0 };
119
120 ASSERT_EQ(EXIT_SUCCESS, exec_cmdline(gearmand_binary(), args, true));
121 return TEST_SUCCESS;
122 }
123
long_file_descriptors_test(void *)124 static test_return_t long_file_descriptors_test(void *)
125 {
126 const char *args[]= { "--check-args", "--file-descriptors=10", 0 };
127
128 ASSERT_EQ(EXIT_SUCCESS, exec_cmdline(gearmand_binary(), args, true));
129 return TEST_SUCCESS;
130 }
131
short_file_descriptors_test(void *)132 static test_return_t short_file_descriptors_test(void *)
133 {
134 const char *args[]= { "--check-args", "-f", "10", 0 };
135
136 ASSERT_EQ(EXIT_SUCCESS, exec_cmdline(gearmand_binary(), args, true));
137 return TEST_SUCCESS;
138 }
139
long_help_test(void *)140 static test_return_t long_help_test(void *)
141 {
142 const char *args[]= { "--check-args", "--help", 0 };
143
144 ASSERT_EQ(EXIT_SUCCESS, exec_cmdline(gearmand_binary(), args, true));
145 return TEST_SUCCESS;
146 }
147
short_help_test(void *)148 static test_return_t short_help_test(void *)
149 {
150 const char *args[]= { "--check-args", "-h", 0 };
151
152 ASSERT_EQ(EXIT_SUCCESS, exec_cmdline(gearmand_binary(), args, true));
153 return TEST_SUCCESS;
154 }
155
long_log_file_test(void *)156 static test_return_t long_log_file_test(void *)
157 {
158 const char *args[]= { "--check-args", "--log-file=\"tmp/foo\"", 0 };
159
160 ASSERT_EQ(EXIT_SUCCESS, exec_cmdline(gearmand_binary(), args, true));
161 return TEST_SUCCESS;
162 }
163
long_log_file_stderr_TEST(void *)164 static test_return_t long_log_file_stderr_TEST(void *)
165 {
166 const char *args[]= { "--check-args", "--log-file=stderr", 0 };
167
168 ASSERT_EQ(EXIT_SUCCESS, exec_cmdline(gearmand_binary(), args, true));
169 return TEST_SUCCESS;
170 }
171
short_log_file_test(void *)172 static test_return_t short_log_file_test(void *)
173 {
174 const char *args[]= { "--check-args", "-l", "\"tmp/foo\"", 0 };
175
176 ASSERT_EQ(EXIT_SUCCESS, exec_cmdline(gearmand_binary(), args, true));
177 return TEST_SUCCESS;
178 }
179
long_listen_test(void *)180 static test_return_t long_listen_test(void *)
181 {
182 const char *args[]= { "--check-args", "--listen=10", 0 };
183
184 ASSERT_EQ(EXIT_SUCCESS, exec_cmdline(gearmand_binary(), args, true));
185 return TEST_SUCCESS;
186 }
187
short_listen_test(void *)188 static test_return_t short_listen_test(void *)
189 {
190 const char *args[]= { "--check-args", "-L", "10", 0 };
191
192 ASSERT_EQ(EXIT_SUCCESS, exec_cmdline(gearmand_binary(), args, true));
193 return TEST_SUCCESS;
194 }
195
long_port_test(void *)196 static test_return_t long_port_test(void *)
197 {
198 const char *args[]= { "--check-args", "--port=10", 0 };
199
200 ASSERT_EQ(EXIT_SUCCESS, exec_cmdline(gearmand_binary(), args, true));
201 return TEST_SUCCESS;
202 }
203
short_port_test(void *)204 static test_return_t short_port_test(void *)
205 {
206 const char *args[]= { "--check-args", "-p", "10", 0 };
207
208 ASSERT_EQ(EXIT_SUCCESS, exec_cmdline(gearmand_binary(), args, true));
209 return TEST_SUCCESS;
210 }
211
long_pid_file_test(void *)212 static test_return_t long_pid_file_test(void *)
213 {
214 const char *args[]= { "--check-args", "--pid-file=\"tmp/gearmand.pid\"", 0 };
215
216 ASSERT_EQ(EXIT_SUCCESS, exec_cmdline(gearmand_binary(), args, true));
217 return TEST_SUCCESS;
218 }
219
short_pid_file_test(void *)220 static test_return_t short_pid_file_test(void *)
221 {
222 const char *args[]= { "--check-args", "-P", "\"tmp/gearmand.pid\"", 0 };
223
224 ASSERT_EQ(EXIT_SUCCESS, exec_cmdline(gearmand_binary(), args, true));
225 return TEST_SUCCESS;
226 }
227
long_round_robin_test(void *)228 static test_return_t long_round_robin_test(void *)
229 {
230 const char *args[]= { "--check-args", "--round-robin", 0 };
231
232 ASSERT_EQ(EXIT_SUCCESS, exec_cmdline(gearmand_binary(), args, true));
233 return TEST_SUCCESS;
234 }
235
short_round_robin_test(void *)236 static test_return_t short_round_robin_test(void *)
237 {
238 const char *args[]= { "--check-args", "-R", 0 };
239
240 ASSERT_EQ(EXIT_SUCCESS, exec_cmdline(gearmand_binary(), args, true));
241 return TEST_SUCCESS;
242 }
243
long_syslog_test(void *)244 static test_return_t long_syslog_test(void *)
245 {
246 const char *args[]= { "--check-args", "--syslog", 0 };
247
248 ASSERT_EQ(EXIT_SUCCESS, exec_cmdline(gearmand_binary(), args, true));
249 return TEST_SUCCESS;
250 }
251
long_threads_test(void *)252 static test_return_t long_threads_test(void *)
253 {
254 const char *args[]= { "--check-args", "--threads=10", 0 };
255
256 ASSERT_EQ(EXIT_SUCCESS, exec_cmdline(gearmand_binary(), args, true));
257 return TEST_SUCCESS;
258 }
259
short_threads_test(void *)260 static test_return_t short_threads_test(void *)
261 {
262 const char *args[]= { "--check-args", "-t", "8", 0 };
263
264 ASSERT_EQ(EXIT_SUCCESS, exec_cmdline(gearmand_binary(), args, true));
265 return TEST_SUCCESS;
266 }
267
long_user_test(void *)268 static test_return_t long_user_test(void *)
269 {
270 const char *args[]= { "--check-args", "--user=nobody", 0 };
271
272 ASSERT_EQ(EXIT_SUCCESS, exec_cmdline(gearmand_binary(), args, true));
273 return TEST_SUCCESS;
274 }
275
short_user_test(void *)276 static test_return_t short_user_test(void *)
277 {
278 const char *args[]= { "--check-args", "-u", "nobody", 0 };
279
280 ASSERT_EQ(EXIT_SUCCESS, exec_cmdline(gearmand_binary(), args, true));
281 return TEST_SUCCESS;
282 }
283
long_version_test(void *)284 static test_return_t long_version_test(void *)
285 {
286 const char *args[]= { "--check-args", "--version", 0 };
287
288 ASSERT_EQ(EXIT_SUCCESS, exec_cmdline(gearmand_binary(), args, true));
289 return TEST_SUCCESS;
290 }
291
short_version_test(void *)292 static test_return_t short_version_test(void *)
293 {
294 const char *args[]= { "--check-args", "-V", 0 };
295
296 ASSERT_EQ(EXIT_SUCCESS, exec_cmdline(gearmand_binary(), args, true));
297 return TEST_SUCCESS;
298 }
299
verbose_bad_option_TEST(void *)300 static test_return_t verbose_bad_option_TEST(void *)
301 {
302 const char *args[]= { "--check-args", "--verbose=BAD", 0 };
303
304 ASSERT_EQ(EXIT_FAILURE, exec_cmdline(gearmand_binary(), args, true));
305 return TEST_SUCCESS;
306 }
307
verbose_DEBUG_TEST(void *)308 static test_return_t verbose_DEBUG_TEST(void *)
309 {
310 const char *args[]= { "--check-args", "--verbose=DEBUG", 0 };
311
312 ASSERT_EQ(EXIT_SUCCESS, exec_cmdline(gearmand_binary(), args, true));
313 return TEST_SUCCESS;
314 }
315
verbose_ERROR_TEST(void *)316 static test_return_t verbose_ERROR_TEST(void *)
317 {
318 const char *args[]= { "--check-args", "--verbose=ERROR", 0 };
319
320 ASSERT_EQ(EXIT_SUCCESS, exec_cmdline(gearmand_binary(), args, true));
321 return TEST_SUCCESS;
322 }
323
verbose_ALERT_TEST(void *)324 static test_return_t verbose_ALERT_TEST(void *)
325 {
326 const char *args[]= { "--check-args", "--verbose=ALERT", 0 };
327
328 ASSERT_EQ(EXIT_SUCCESS, exec_cmdline(gearmand_binary(), args, true));
329 return TEST_SUCCESS;
330 }
331
verbose_INFO_TEST(void *)332 static test_return_t verbose_INFO_TEST(void *)
333 {
334 const char *args[]= { "--check-args", "--verbose=INFO", 0 };
335
336 ASSERT_EQ(EXIT_SUCCESS, exec_cmdline(gearmand_binary(), args, true));
337 return TEST_SUCCESS;
338 }
339
verbose_WARNING_TEST(void *)340 static test_return_t verbose_WARNING_TEST(void *)
341 {
342 const char *args[]= { "--check-args", "--verbose=WARNING", 0 };
343
344 ASSERT_EQ(EXIT_SUCCESS, exec_cmdline(gearmand_binary(), args, true));
345 return TEST_SUCCESS;
346 }
347
verbose_NOTICE_TEST(void *)348 static test_return_t verbose_NOTICE_TEST(void *)
349 {
350 const char *args[]= { "--check-args", "--verbose=NOTICE", 0 };
351
352 ASSERT_EQ(EXIT_SUCCESS, exec_cmdline(gearmand_binary(), args, true));
353 return TEST_SUCCESS;
354 }
355
verbose_FATAL_TEST(void *)356 static test_return_t verbose_FATAL_TEST(void *)
357 {
358 const char *args[]= { "--check-args", "--verbose=FATAL", 0 };
359
360 ASSERT_EQ(EXIT_SUCCESS, exec_cmdline(gearmand_binary(), args, true));
361 return TEST_SUCCESS;
362 }
363
verbose_CRITICAL_TEST(void *)364 static test_return_t verbose_CRITICAL_TEST(void *)
365 {
366 const char *args[]= { "--check-args", "--verbose=CRITICAL", 0 };
367
368 ASSERT_EQ(EXIT_SUCCESS, exec_cmdline(gearmand_binary(), args, true));
369 return TEST_SUCCESS;
370 }
371
verbose_deprecated_TEST(void *)372 static test_return_t verbose_deprecated_TEST(void *)
373 {
374 const char *args[]= { "--check-args", "-vvv", 0 };
375
376 ASSERT_EQ(EXIT_FAILURE, exec_cmdline(gearmand_binary(), args, true));
377 return TEST_SUCCESS;
378 }
379
long_worker_wakeup_test(void *)380 static test_return_t long_worker_wakeup_test(void *)
381 {
382 const char *args[]= { "--check-args", "--worker-wakeup=4", 0 };
383
384 ASSERT_EQ(EXIT_SUCCESS, exec_cmdline(gearmand_binary(), args, true));
385 return TEST_SUCCESS;
386 }
387
short_worker_wakeup_test(void *)388 static test_return_t short_worker_wakeup_test(void *)
389 {
390 const char *args[]= { "--check-args", "-V", 0 };
391
392 ASSERT_EQ(EXIT_SUCCESS, exec_cmdline(gearmand_binary(), args, true));
393 return TEST_SUCCESS;
394 }
395
protocol_test(void *)396 static test_return_t protocol_test(void *)
397 {
398 const char *args[]= { "--check-args", "--protocol=http", 0 };
399
400 ASSERT_EQ(EXIT_SUCCESS, exec_cmdline(gearmand_binary(), args, true));
401 return TEST_SUCCESS;
402 }
403
queue_test(void *)404 static test_return_t queue_test(void *)
405 {
406 const char *args[]= { "--check-args", "--queue-type=builtin", 0 };
407
408 ASSERT_EQ(EXIT_SUCCESS, exec_cmdline(gearmand_binary(), args, true));
409
410 return TEST_SUCCESS;
411 }
412
long_job_retries_test(void *)413 static test_return_t long_job_retries_test(void *)
414 {
415 const char *args[]= { "--check-args", "--job-retries=4", 0 };
416
417 ASSERT_EQ(EXIT_SUCCESS, exec_cmdline(gearmand_binary(), args, true));
418 return TEST_SUCCESS;
419 }
420
job_handle_prefix_TEST(void *)421 static test_return_t job_handle_prefix_TEST(void *)
422 {
423 const char *args[]= { "--check-args", "--job-handle-prefix=my_own_private_handle", 0 };
424
425 ASSERT_EQ(EXIT_SUCCESS, exec_cmdline(gearmand_binary(), args, true));
426 return TEST_SUCCESS;
427 }
428
hashtable_buckets_TEST(void *)429 static test_return_t hashtable_buckets_TEST(void *)
430 {
431 const char *args[]= { "--check-args", "--hashtable-buckets=2000", 0 };
432
433 ASSERT_EQ(EXIT_SUCCESS, exec_cmdline(gearmand_binary(), args, true));
434 return TEST_SUCCESS;
435 }
436
short_job_retries_test(void *)437 static test_return_t short_job_retries_test(void *)
438 {
439 const char *args[]= { "--check-args", "-j", "6", 0 };
440
441 ASSERT_EQ(EXIT_SUCCESS, exec_cmdline(gearmand_binary(), args, true));
442 return TEST_SUCCESS;
443 }
444
http_port_test(void *)445 static test_return_t http_port_test(void *)
446 {
447 const char *args[]= { "--check-args", "--protocol=http", "--http-port=8090", 0 };
448
449 ASSERT_EQ(EXIT_SUCCESS, exec_cmdline(gearmand_binary(), args, true));
450 return TEST_SUCCESS;
451 }
452
config_file_TEST(void *)453 static test_return_t config_file_TEST(void *)
454 {
455 ASSERT_EQ(-1, access("etc/gearmand.conf", R_OK));
456
457 const char *args[]= { "--check-args", "--config-file=etc/gearmand.conf", 0 };
458
459 ASSERT_EQ(EXIT_FAILURE, exec_cmdline(gearmand_binary(), args, true));
460 return TEST_SUCCESS;
461 }
462
config_file_DEFAULT_TEST(void *)463 static test_return_t config_file_DEFAULT_TEST(void *)
464 {
465 const char *args[]= { "--check-args", "--config-file", 0 };
466
467 ASSERT_EQ(EXIT_FAILURE, exec_cmdline(gearmand_binary(), args, true));
468 return TEST_SUCCESS;
469 }
470
config_file_FAIL_TEST(void *)471 static test_return_t config_file_FAIL_TEST(void *)
472 {
473 const char *args[]= { "--check-args", "--config-file=etc/grmandfoo.conf", 0 };
474
475 ASSERT_EQ(EXIT_FAILURE, exec_cmdline(gearmand_binary(), args, true));
476 return TEST_SUCCESS;
477 }
478
config_file_SIMPLE_TEST(void *)479 static test_return_t config_file_SIMPLE_TEST(void *)
480 {
481 in_port_t port= libtest::get_free_port();
482 char port_str[1024];
483 test_true(snprintf(port_str, sizeof(port_str), "%d", int32_t(port)) > 0);
484
485 std::string config_file= "etc/gearmand.conf";
486 {
487 char current_directory_buffer[1024];
488 char *current_directory= getcwd(current_directory_buffer, sizeof(current_directory_buffer));
489
490 std::string config_path;
491
492 config_path+= current_directory;
493 config_path+= "/";
494 config_path+= config_file;
495
496
497 std::fstream file_stream;
498 file_stream.open(config_path.c_str(), std::fstream::out | std::fstream::trunc);
499
500 test_true(file_stream.good());
501
502 file_stream << "--port " << port_str << std::endl;
503
504 test_true(file_stream.good());
505 file_stream.close();
506 }
507 test_zero(access(config_file.c_str(), R_OK));
508
509 char args_buffer[1024];
510 snprintf(args_buffer, sizeof(args_buffer), "--config-file=%s", config_file.c_str());
511 const char *args[]= { "--check-args", args_buffer, 0 };
512
513 ASSERT_EQ(EXIT_SUCCESS, exec_cmdline(gearmand_binary(), args, true));
514 unlink(config_file.c_str());
515
516 return TEST_SUCCESS;
517 }
518
maxqueue_TEST(void *)519 static test_return_t maxqueue_TEST(void *)
520 {
521 return TEST_SKIPPED;
522 #if 0
523 in_port_t port= libtest::get_free_port();
524 Application gearmand(gearmand_binary(), true);
525
526 char buffer[1024];
527 test_true(snprintf(buffer, sizeof(buffer), "%d", int32_t(port)) > 0);
528 gearmand.add_long_option("--port=", buffer);
529
530 ASSERT_EQ(Application::SUCCESS, gearmand.run());
531
532 Worker worker(port);
533 ASSERT_EQ(GEARMAN_SUCCESS, gearman_worker_register(&worker, __func__, 0));
534 ASSERT_EQ(GEARMAN_SUCCESS, gearman_worker_unregister(&worker, __func__));
535 ASSERT_EQ(Application::SUCCESS, gearmand.join());
536
537 return TEST_SUCCESS;
538 #endif
539 }
540
541 test_st bad_option_TESTS[] ={
542 {"position argument", 0, postion_TEST },
543 {"partial argument", 0, partial_TEST },
544 {0, 0, 0}
545 };
546
547 test_st gearmand_option_tests[] ={
548 {"--check-args", 0, check_args_test},
549 {"--backlog=", 0, long_backlog_test},
550 {"-b", 0, short_backlog_test},
551 {"--coredump", 0, long_coredump_TEST},
552 {"--daemon", 0, long_daemon_test},
553 {"-d", 0, short_daemon_test},
554 {"--file-descriptors=", 0, long_file_descriptors_test},
555 {"-f", 0, short_file_descriptors_test},
556 {"--help", 0, long_help_test},
557 {"-h", 0, short_help_test},
558 {"--log-file=", 0, long_log_file_test},
559 {"--log-file=stderr", 0, long_log_file_stderr_TEST},
560 {"-l", 0, short_log_file_test},
561 {"--listen=", 0, long_listen_test},
562 {"-L", 0, short_listen_test},
563 {"--port=", 0, long_port_test},
564 {"-p", 0, short_port_test},
565 {"--pid-file=", 0, long_pid_file_test},
566 {"-P", 0, short_pid_file_test},
567 {"--round-robin", 0, long_round_robin_test},
568 {"-R", 0, short_round_robin_test},
569 {"--syslog=", 0, long_syslog_test},
570 {"--threads=", 0, long_threads_test},
571 {"-T", 0, short_threads_test},
572 {"--user=", 0, long_user_test},
573 {"-u", 0, short_user_test},
574 {"--user=", 0, long_user_test},
575 {"-u", 0, short_user_test},
576 {"-vvv", 0, verbose_deprecated_TEST},
577 {"--verbose=FATAL", 0, verbose_FATAL_TEST},
578 {"--verbose=ALERT", 0, verbose_ALERT_TEST},
579 {"--verbose=CRITICAL", 0, verbose_CRITICAL_TEST},
580 {"--verbose=ERROR", 0, verbose_ERROR_TEST},
581 {"--verbose=WARNING", 0, verbose_WARNING_TEST},
582 {"--verbose=NOTICE", 0, verbose_NOTICE_TEST},
583 {"--verbose=INFO", 0, verbose_INFO_TEST},
584 {"--verbose=DEBUG", 0, verbose_DEBUG_TEST},
585 {"--verbose=BAD", 0, verbose_bad_option_TEST},
586 {"--version", 0, long_version_test},
587 {"-V", 0, short_version_test},
588 {"--worker_wakeup=", 0, long_worker_wakeup_test},
589 {"-w", 0, short_worker_wakeup_test},
590 {"--protocol=", 0, protocol_test},
591 {"--queue-type=", 0, queue_test},
592 {"--job-retries=", 0, long_job_retries_test},
593 {"-hashtable-buckets", 0, hashtable_buckets_TEST},
594 {"--job-handle-prefix=", 0, job_handle_prefix_TEST},
595 {"-j", 0, short_job_retries_test},
596 {"--config-file=etc/gearmand.conf no file present", 0, config_file_TEST },
597 {"--config-file", 0, config_file_DEFAULT_TEST },
598 {"--config-file=etc/grmandfoo.conf", 0, config_file_FAIL_TEST },
599 {"--config-file=etc/gearmand.conf", 0, config_file_SIMPLE_TEST },
600 {0, 0, 0}
601 };
602
603 test_st gearmand_httpd_option_tests[] ={
604 {"--http-port=", 0, http_port_test},
605 {0, 0, 0}
606 };
607
608 test_st maxqueue_TESTS[] ={
609 { "maxqueue=", 0, maxqueue_TEST },
610 {0, 0, 0}
611 };
612
option_SETUP(void *)613 static test_return_t option_SETUP(void*)
614 {
615 unlink("etc/gearmand.conf");
616 return TEST_SUCCESS;
617 }
618
619 collection_st collection[] ={
620 { "bad options", 0, 0, bad_option_TESTS },
621 { "basic options", option_SETUP, 0, gearmand_option_tests },
622 { "httpd options", 0, 0, gearmand_httpd_option_tests },
623 { "maxqueue", 0, 0, maxqueue_TESTS },
624 {0, 0, 0, 0}
625 };
626
get_world(libtest::Framework * world)627 void get_world(libtest::Framework *world)
628 {
629 world->collections(collection);
630 }
631