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