Merge lp:~tangent-org/libmemcached/1.0-build/ Build: jenkins-Libmemcached-187
[m6w6/libmemcached] / libtest / unittest.cc
1 /* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
2 *
3 * Data Differential YATL (i.e. libtest) library
4 *
5 * Copyright (C) 2012 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 #include "libtest/yatlcon.h"
38
39 #include <libtest/yatl.h>
40
41 #if defined(HAVE_LIBMEMCACHED_1_0_TYPES_RETURN_H) && HAVE_LIBMEMCACHED_1_0_TYPES_RETURN_H
42 # include <libmemcached-1.0/types/return.h>
43 #endif
44
45 #if defined(HAVE_LIBGEARMAN_1_0_RETURN_H) && HAVE_LIBGEARMAN_1_0_RETURN_H
46 # include <libgearman-1.0/return.h>
47 #endif
48
49 #include <cstdlib>
50 #include <unistd.h>
51
52 using namespace libtest;
53
54 static std::string testing_service;
55
56 // Used to track setups where we see if failure is happening
57 static uint32_t fatal_calls= 0;
58
59 static test_return_t getenv_TEST(void *)
60 {
61 #if 0
62 for (char **ptr= environ; *ptr; ptr++)
63 {
64 Error << *ptr;
65 }
66 #endif
67
68 return TEST_SUCCESS;
69 }
70
71 static test_return_t LIBTOOL_COMMAND_test(void *)
72 {
73 test_true(getenv("LIBTOOL_COMMAND"));
74 return TEST_SUCCESS;
75 }
76
77 static test_return_t VALGRIND_COMMAND_test(void *)
78 {
79 test_true(getenv("VALGRIND_COMMAND"));
80 return TEST_SUCCESS;
81 }
82
83 static test_return_t HELGRIND_COMMAND_test(void *)
84 {
85 test_true(getenv("HELGRIND_COMMAND"));
86 return TEST_SUCCESS;
87 }
88
89 static test_return_t GDB_COMMAND_test(void *)
90 {
91 test_true(getenv("GDB_COMMAND"));
92 return TEST_SUCCESS;
93 }
94
95 static test_return_t test_success_equals_one_test(void *)
96 {
97 test_skip(HAVE_LIBMEMCACHED, 1);
98 #if defined(HAVE_LIBMEMCACHED_1_0_TYPES_RETURN_H) && HAVE_LIBMEMCACHED_1_0_TYPES_RETURN_H
99 test_zero(MEMCACHED_SUCCESS);
100 #endif
101 return TEST_SUCCESS;
102 }
103
104 static test_return_t test_success_test(void *)
105 {
106 return TEST_SUCCESS;
107 }
108
109 static test_return_t test_throw_success_TEST(void *)
110 {
111 try {
112 _SUCCESS;
113 }
114 catch (libtest::__success)
115 {
116 return TEST_SUCCESS;
117 }
118 catch (...)
119 {
120 return TEST_FAILURE;
121 }
122
123 return TEST_FAILURE;
124 }
125
126 static test_return_t test_throw_skip_macro_TEST(void *)
127 {
128 try {
129 SKIP_IF(true);
130 }
131 catch (libtest::__skipped e)
132 {
133 return TEST_SUCCESS;
134 }
135 catch (...)
136 {
137 FAIL("SLIP_IF() failed to throw libtest::_skipped");
138 }
139
140 FAIL("SLIP_IF() failed to throw");
141
142 return TEST_FAILURE;
143 }
144
145 static test_return_t test_throw_skip_TEST(void *)
146 {
147 try {
148 throw libtest::__skipped(LIBYATL_DEFAULT_PARAM, "basic test");
149 }
150 catch (libtest::__skipped e)
151 {
152 return TEST_SUCCESS;
153 }
154 catch (...)
155 {
156 FAIL("SLIP_IF() failed to throw libtest::_skipped");
157 }
158
159 FAIL("SLIP_IF() failed to throw");
160
161 return TEST_FAILURE;
162 }
163
164 static test_return_t test_throw_fail_TEST(void *)
165 {
166 try {
167 FAIL("test message!");
168 }
169 catch (const libtest::__failure& e)
170 {
171 std::string compare_message("test message!");
172 test_zero(compare_message.compare(e.what()));
173 return TEST_SUCCESS;
174 }
175 catch (...)
176 {
177 return TEST_FAILURE;
178 }
179
180 return TEST_FAILURE;
181 }
182 #pragma GCC diagnostic ignored "-Wstack-protector"
183
184 static test_return_t ASSERT_FALSE__TEST(void *)
185 {
186 try {
187 ASSERT_FALSE_(true, __func__);
188 }
189 catch (const libtest::__failure& e)
190 {
191 ASSERT_STREQ(e.what(), "Assertion '!true' [ ASSERT_FALSE__TEST ]");
192 return TEST_SUCCESS;
193 }
194 catch (...)
195 {
196 return TEST_FAILURE;
197 }
198
199 return TEST_FAILURE;
200 }
201
202 static test_return_t ASSERT_FALSE_TEST(void *)
203 {
204 try {
205 FAIL(__func__);
206 }
207 catch (const libtest::__failure& e)
208 {
209 ASSERT_STREQ(e.what(), __func__);
210 return TEST_SUCCESS;
211 }
212 catch (...)
213 {
214 return TEST_FAILURE;
215 }
216
217 return TEST_FAILURE;
218 }
219
220 static test_return_t test_failure_test(void *)
221 {
222 return TEST_SKIPPED; // Only run this when debugging
223
224 ASSERT_EQ(1, 2);
225 return TEST_SUCCESS;
226 }
227
228 static test_return_t local_test(void *)
229 {
230 if (getenv("LIBTEST_LOCAL"))
231 {
232 test_true(test_is_local());
233 }
234 else
235 {
236 test_false(test_is_local());
237 }
238
239 return TEST_SUCCESS;
240 }
241
242 static test_return_t local_not_test(void *)
243 {
244 return TEST_SKIPPED;
245
246 std::string temp;
247
248 const char *ptr;
249 if ((ptr= getenv("LIBTEST_LOCAL")) == NULL)
250 {
251 temp.append(ptr);
252 }
253
254 // unsetenv() will cause issues with valgrind
255 _compare(__FILE__, __LINE__, __func__, 0, unsetenv("LIBTEST_LOCAL"), true);
256 ASSERT_EQ(0, unsetenv("LIBTEST_LOCAL"));
257 test_false(test_is_local());
258
259 ASSERT_EQ(0, setenv("LIBTEST_LOCAL", "1", 1));
260 test_true(test_is_local());
261
262 if (temp.empty())
263 {
264 ASSERT_EQ(0, unsetenv("LIBTEST_LOCAL"));
265 }
266 else
267 {
268 char *old_string= strdup(temp.c_str());
269 ASSERT_EQ(0, setenv("LIBTEST_LOCAL", old_string, 1));
270 }
271
272 return TEST_SUCCESS;
273 }
274
275 static test_return_t var_exists_test(void *)
276 {
277 ASSERT_EQ(0, access("var", R_OK | W_OK | X_OK));
278 return TEST_SUCCESS;
279 }
280
281 static test_return_t var_tmp_exists_test(void *)
282 {
283 ASSERT_EQ(0, access("var/tmp", R_OK | W_OK | X_OK));
284 return TEST_SUCCESS;
285 }
286
287 static test_return_t var_run_exists_test(void *)
288 {
289 ASSERT_EQ(0, access("var/run", R_OK | W_OK | X_OK));
290 return TEST_SUCCESS;
291 }
292
293 static test_return_t var_log_exists_test(void *)
294 {
295 ASSERT_EQ(0, access("var/log", R_OK | W_OK | X_OK));
296 return TEST_SUCCESS;
297 }
298
299 static test_return_t var_drizzle_exists_test(void *)
300 {
301 ASSERT_EQ(0, access("var/drizzle", R_OK | W_OK | X_OK));
302 return TEST_SUCCESS;
303 }
304
305 static test_return_t var_tmp_test(void *)
306 {
307 FILE *file= fopen("var/tmp/junk", "w+");
308 test_true(file);
309 fclose(file);
310 return TEST_SUCCESS;
311 }
312
313 static test_return_t var_run_test(void *)
314 {
315 FILE *file= fopen("var/run/junk", "w+");
316 test_true(file);
317 fclose(file);
318 return TEST_SUCCESS;
319 }
320
321 static test_return_t var_log_test(void *)
322 {
323 FILE *file= fopen("var/log/junk", "w+");
324 test_true(file);
325 fclose(file);
326 return TEST_SUCCESS;
327 }
328
329 static test_return_t var_drizzle_test(void *)
330 {
331 FILE *file= fopen("var/drizzle/junk", "w+");
332 test_true(file);
333 fclose(file);
334 return TEST_SUCCESS;
335 }
336
337 static test_return_t var_tmp_rm_test(void *)
338 {
339 test_true(unlink("var/tmp/junk") == 0);
340 return TEST_SUCCESS;
341 }
342
343 static test_return_t var_run_rm_test(void *)
344 {
345 test_true(unlink("var/run/junk") == 0);
346 return TEST_SUCCESS;
347 }
348
349 static test_return_t var_log_rm_test(void *)
350 {
351 test_true(unlink("var/log/junk") == 0);
352 return TEST_SUCCESS;
353 }
354
355 static test_return_t var_drizzle_rm_test(void *)
356 {
357 test_true(unlink("var/drizzle/junk") == 0);
358 return TEST_SUCCESS;
359 }
360
361 static test_return_t _compare_test_return_t_test(void *)
362 {
363 ASSERT_EQ(TEST_SUCCESS, TEST_SUCCESS);
364
365 return TEST_SUCCESS;
366 }
367
368 static test_return_t _compare_memcached_return_t_test(void *)
369 {
370 test_skip(HAVE_LIBMEMCACHED, true);
371 #if defined(HAVE_LIBMEMCACHED_1_0_TYPES_RETURN_H) && HAVE_LIBMEMCACHED_1_0_TYPES_RETURN_H
372 ASSERT_EQ(MEMCACHED_SUCCESS, MEMCACHED_SUCCESS);
373 #endif
374
375 return TEST_SUCCESS;
376 }
377
378 static test_return_t _compare_gearman_return_t_test(void *)
379 {
380 test_skip(HAVE_LIBGEARMAN, true);
381 #if defined(HAVE_LIBGEARMAN_1_0_RETURN_H) && HAVE_LIBGEARMAN_1_0_RETURN_H
382 ASSERT_EQ(GEARMAN_SUCCESS, GEARMAN_SUCCESS);
383 #endif
384
385 return TEST_SUCCESS;
386 }
387
388 static test_return_t drizzled_cycle_test(void *object)
389 {
390 server_startup_st *servers= (server_startup_st*)object;
391 test_true(servers and servers->validate());
392
393 #if defined(HAVE_GEARMAND_BINARY) && HAVE_GEARMAND_BINARY
394 test_true(has_drizzled());
395 #endif
396
397 test_skip(true, has_drizzled());
398
399 test_skip(true, server_startup(*servers, "drizzled", get_free_port(), 0, NULL, false));
400
401 return TEST_SUCCESS;
402 }
403
404 static test_return_t gearmand_cycle_test(void *object)
405 {
406 server_startup_st *servers= (server_startup_st*)object;
407 test_true(servers and servers->validate());
408
409 test_skip(true, has_gearmand());
410 test_skip(true, server_startup(*servers, "gearmand", get_free_port(), 0, NULL, false));
411 servers->clear();
412
413 return TEST_SUCCESS;
414 }
415
416 static test_return_t skip_shim(bool a, bool b)
417 {
418 test_skip(a, b);
419 return TEST_SUCCESS;
420 }
421
422 static test_return_t test_skip_true_TEST(void*)
423 {
424 ASSERT_EQ(true, true);
425 ASSERT_EQ(false, false);
426 ASSERT_EQ(TEST_SUCCESS, skip_shim(true, true));
427 ASSERT_EQ(TEST_SUCCESS, skip_shim(false, false));
428
429 return TEST_SUCCESS;
430 }
431
432 static test_return_t test_skip_false_TEST(void*)
433 {
434 ASSERT_EQ(TEST_SKIPPED, skip_shim(true, false));
435 ASSERT_EQ(TEST_SKIPPED, skip_shim(false, true));
436 return TEST_SUCCESS;
437 }
438
439 static test_return_t server_startup_fail_TEST(void *object)
440 {
441 server_startup_st *servers= (server_startup_st*)object;
442 test_true(servers);
443
444 fatal::disable();
445 ASSERT_EQ(servers->start_server(testing_service, LIBTEST_FAIL_PORT, 0, NULL, false), true);
446 fatal::enable();
447
448 return TEST_SUCCESS;
449 }
450
451 static test_return_t server_startup_TEST(void *object)
452 {
453 server_startup_st *servers= (server_startup_st*)object;
454 test_true(servers);
455
456 ASSERT_EQ(servers->start_server(testing_service, get_free_port(), 0, NULL, false), true);
457
458 test_true(servers->last());
459 pid_t last_pid= servers->last()->pid();
460
461 ASSERT_EQ(servers->last()->pid(), last_pid);
462 test_true(last_pid > 1);
463 ASSERT_EQ(kill(last_pid, 0), 0);
464
465 test_true(servers->shutdown());
466 #if 0
467 ASSERT_EQ(servers->last()->pid(), -1);
468 ASSERT_EQ(kill(last_pid, 0), -1);
469 #endif
470
471 return TEST_SUCCESS;
472 }
473
474 static test_return_t socket_server_startup_TEST(void *object)
475 {
476 server_startup_st *servers= (server_startup_st*)object;
477 test_true(servers);
478
479 test_true(servers->start_socket_server(testing_service, get_free_port(), 0, NULL, false));
480
481 return TEST_SUCCESS;
482 }
483
484 #if 0
485 static test_return_t memcached_sasl_test(void *object)
486 {
487 server_startup_st *servers= (server_startup_st*)object;
488 test_true(servers);
489
490 test_skip(false, bool(getenv("TESTS_ENVIRONMENT")));
491
492 if (MEMCACHED_SASL_BINARY)
493 {
494 if (HAVE_LIBMEMCACHED)
495 {
496 test_true(has_memcached_sasl());
497 test_true(server_startup(*servers, "memcached-sasl", get_free_port(), 0, NULL, false));
498
499 return TEST_SUCCESS;
500 }
501 }
502
503 return TEST_SKIPPED;
504 }
505 #endif
506
507 static test_return_t application_true_BINARY(void *)
508 {
509 test_skip(0, access("/usr/bin/true", X_OK ));
510 Application true_app("/usr/bin/true");
511
512 ASSERT_EQ(Application::SUCCESS, true_app.run());
513 ASSERT_EQ(Application::SUCCESS, true_app.join());
514
515 return TEST_SUCCESS;
516 }
517
518 static test_return_t application_gdb_true_BINARY2(void *)
519 {
520 test_skip(0, access("/usr/bin/gdb", X_OK ));
521 test_skip(0, access("/usr/bin/true", X_OK ));
522
523 Application true_app("/usr/bin/true");
524 true_app.use_gdb(true);
525
526 ASSERT_EQ(Application::SUCCESS, true_app.run());
527 ASSERT_EQ(Application::SUCCESS, true_app.join());
528
529 return TEST_SUCCESS;
530 }
531
532 static test_return_t application_gdb_true_BINARY(void *)
533 {
534 test_skip(0, access("/usr/bin/gdb", X_OK ));
535 test_skip(0, access("/usr/bin/true", X_OK ));
536
537 Application true_app("/usr/bin/true");
538 true_app.use_gdb(true);
539
540 const char *args[]= { "--fubar", 0 };
541 ASSERT_EQ(Application::SUCCESS, true_app.run(args));
542 ASSERT_EQ(Application::SUCCESS, true_app.join());
543
544 return TEST_SUCCESS;
545 }
546
547 static test_return_t application_true_fubar_BINARY(void *)
548 {
549 test_skip(0, access("/usr/bin/true", X_OK ));
550 Application true_app("/usr/bin/true");
551
552 const char *args[]= { "--fubar", 0 };
553 ASSERT_EQ(Application::SUCCESS, true_app.run(args));
554 ASSERT_EQ(Application::SUCCESS, true_app.join());
555 test_zero(true_app.stdout_result().size());
556
557 return TEST_SUCCESS;
558 }
559
560 static test_return_t application_doesnotexist_BINARY(void *)
561 {
562
563 test_skip_valgrind();
564 Application true_app("doesnotexist");
565 true_app.will_fail();
566
567 const char *args[]= { "--fubar", 0 };
568 #if defined(TARGET_OS_OSX) && TARGET_OS_OSX
569 ASSERT_EQ(Application::INVALID_POSIX_SPAWN, true_app.run(args));
570 #elif defined(TARGET_OS_FREEBSD) && TARGET_OS_FREEBSD
571 ASSERT_EQ(Application::INVALID_POSIX_SPAWN, true_app.run(args));
572 #else
573 ASSERT_EQ(Application::SUCCESS, true_app.run(args));
574 ASSERT_EQ(Application::INVALID_POSIX_SPAWN, true_app.join());
575 #endif
576
577 test_zero(true_app.stdout_result().size());
578
579 return TEST_SUCCESS;
580 }
581
582 static test_return_t GET_TEST(void *)
583 {
584 libtest::http::GET get("http://foo.example.com/");
585
586 ASSERT_EQ(false, get.execute());
587
588 return TEST_SUCCESS;
589 }
590
591 static test_return_t POST_TEST(void *)
592 {
593 libtest::vchar_t body;
594 libtest::http::POST post("http://foo.example.com/", body);
595
596 ASSERT_EQ(false, post.execute());
597
598 return TEST_SUCCESS;
599 }
600
601 static test_return_t TRACE_TEST(void *)
602 {
603 libtest::vchar_t body;
604 libtest::http::TRACE trace("http://foo.example.com/", body);
605
606 ASSERT_EQ(false, trace.execute());
607
608 return TEST_SUCCESS;
609 }
610
611
612 static test_return_t vchar_t_TEST(void *)
613 {
614 libtest::vchar_t response;
615 libtest::make_vector(response, test_literal_param("fubar\n"));
616 ASSERT_EQ(response, response);
617
618 return TEST_SUCCESS;
619 }
620
621 static test_return_t vchar_t_make_append_TEST(void *)
622 {
623 libtest::vchar_t hostname;
624 libtest::vchar::make(hostname, 23);
625 libtest::vchar::append(hostname, ".com");
626 ASSERT_EQ(28, hostname.size());
627 ASSERT_EQ(0, hostname[27]);
628
629 return TEST_SUCCESS;
630 }
631
632 static test_return_t vchar_t_compare_neg_TEST(void *)
633 {
634 libtest::vchar_t response;
635 libtest::vchar_t response2;
636 libtest::make_vector(response, test_literal_param("fubar\n"));
637 libtest::make_vector(response2, test_literal_param(__func__));
638 test_true(response != response2);
639
640 return TEST_SUCCESS;
641 }
642
643 static test_return_t application_echo_fubar_BINARY(void *)
644 {
645 if (0)
646 {
647 test_skip(0, access("/bin/echo", X_OK ));
648 Application true_app("/bin/echo");
649
650 const char *args[]= { "fubar", 0 };
651 ASSERT_EQ(Application::SUCCESS, true_app.run(args));
652
653 while (true_app.slurp() == false) {} ;
654
655 libtest::vchar_t response;
656 make_vector(response, test_literal_param("fubar\n"));
657 ASSERT_EQ(response, true_app.stdout_result());
658 }
659
660 return TEST_SUCCESS;
661 }
662
663 static test_return_t application_echo_fubar_BINARY2(void *)
664 {
665 if (0)
666 {
667 test_skip(0, access("/bin/echo", X_OK ));
668 Application true_app("/bin/echo");
669
670 true_app.add_option("fubar");
671
672 ASSERT_EQ(Application::SUCCESS, true_app.run());
673 ASSERT_EQ(Application::SUCCESS, true_app.join());
674
675 libtest::vchar_t response;
676 make_vector(response, test_literal_param("fubar\n"));
677 ASSERT_EQ(response, true_app.stdout_result());
678 }
679
680 return TEST_SUCCESS;
681 }
682
683 static test_return_t echo_fubar_BINARY(void *)
684 {
685 const char *args[]= { "fubar", 0 };
686 ASSERT_EQ(EXIT_SUCCESS, exec_cmdline("/bin/echo", args));
687
688 return TEST_SUCCESS;
689 }
690
691 static test_return_t core_count_BINARY(void *)
692 {
693 const char *args[]= { 0 };
694
695 ASSERT_EQ(EXIT_SUCCESS, exec_cmdline("libtest/core-count", args, true));
696
697 return TEST_SUCCESS;
698 }
699
700 static test_return_t wait_BINARY(void *)
701 {
702 const char *args[]= { "--quiet", 0 };
703
704 ASSERT_EQ(EXIT_FAILURE, exec_cmdline("libtest/wait", args, true));
705
706 return TEST_SUCCESS;
707 }
708
709 static test_return_t wait_help_BINARY(void *)
710 {
711 const char *args[]= { "--quiet", "--help", 0 };
712
713 ASSERT_EQ(EXIT_SUCCESS, exec_cmdline("libtest/wait", args, true));
714
715 return TEST_SUCCESS;
716 }
717
718 static test_return_t wait_version_BINARY(void *)
719 {
720 const char *args[]= { "--quiet", "--version", 0 };
721
722 ASSERT_EQ(EXIT_SUCCESS, exec_cmdline("libtest/wait", args, true));
723
724 return TEST_SUCCESS;
725 }
726
727 static test_return_t wait_services_BINARY(void *)
728 {
729 test_skip(0, access("/etc/services", R_OK ));
730
731 const char *args[]= { "--quiet", "/etc/services", 0 };
732
733 ASSERT_EQ(EXIT_SUCCESS, exec_cmdline("libtest/wait", args, true));
734
735 return TEST_SUCCESS;
736 }
737
738 static test_return_t wait_services_BINARY2(void *)
739 {
740 test_skip(0, access("/etc/services", R_OK ));
741
742 const char *args[]= { "/etc/services", 0 };
743
744 ASSERT_EQ(EXIT_SUCCESS, exec_cmdline("libtest/wait", args, true));
745
746 return TEST_SUCCESS;
747 }
748
749 static test_return_t wait_services_appliction_TEST(void *)
750 {
751 test_skip(0, access("/etc/services", R_OK ));
752 test_skip(0, access("/usr/bin/gdb", X_OK ));
753 test_skip(0, access("libtest/wait", X_OK ));
754
755 libtest::Application wait_app("libtest/wait", true);
756 wait_app.use_gdb(true);
757
758 const char *args[]= { "/etc/services", 0 };
759 ASSERT_EQ(Application::SUCCESS, wait_app.run(args));
760 ASSERT_EQ(Application::SUCCESS, wait_app.join());
761
762 return TEST_SUCCESS;
763 }
764
765 static test_return_t gdb_wait_services_appliction_TEST(void *)
766 {
767 test_skip(true, false);
768 #if defined(TARGET_OS_OSX) && TARGET_OS_OSX
769 test_skip(0, TARGET_OS_OSX);
770 #endif
771
772 test_skip(0, access("/etc/services", R_OK ));
773 test_skip(0, access("/usr/bin/gdb", X_OK ));
774 test_skip(0, access("libtest/wait", X_OK ));
775
776 libtest::Application wait_app("libtest/wait", true);
777 wait_app.use_gdb(true);
778
779 const char *args[]= { "/etc/services", 0 };
780 ASSERT_EQ(Application::SUCCESS, wait_app.run(args));
781 ASSERT_EQ(Application::SUCCESS, wait_app.join());
782
783 return TEST_SUCCESS;
784 }
785
786 static test_return_t gdb_abort_services_appliction_TEST(void *)
787 {
788 test_skip(0, access("/usr/bin/gdb", X_OK ));
789 test_skip(0, access("libtest/abort", X_OK ));
790 test_skip(true, false);
791
792 #if defined(TARGET_OS_OSX) && TARGET_OS_OSX
793 test_skip(0, TARGET_OS_OSX);
794 #endif
795
796 libtest::Application abort_app("libtest/abort", true);
797 abort_app.use_gdb(true);
798
799 ASSERT_EQ(Application::SUCCESS, abort_app.run());
800 ASSERT_EQ(Application::SUCCESS, abort_app.join());
801
802 std::string gdb_filename= abort_app.gdb_filename();
803 test_skip(0, access(gdb_filename.c_str(), R_OK ));
804 const char *args[]= { "SIGABRT", gdb_filename.c_str(), 0 };
805 ASSERT_EQ(EXIT_SUCCESS, exec_cmdline("grep", args));
806
807 // Sanity test
808 args[0]= "THIS_WILL_NOT_BE_FOUND";
809 ASSERT_EQ(EXIT_FAILURE, exec_cmdline("grep", args));
810
811 return TEST_SUCCESS;
812 }
813
814 static test_return_t get_free_port_TEST(void *)
815 {
816 in_port_t ret_port;
817 test_true((ret_port= get_free_port()));
818 test_true(get_free_port() != default_port());
819 test_true(get_free_port() != get_free_port());
820
821 return TEST_SUCCESS;
822 }
823
824 static test_return_t fatal_TEST(void *)
825 {
826 ASSERT_EQ(fatal_calls++, fatal::disabled_counter());
827 throw libtest::fatal(LIBYATL_DEFAULT_PARAM, "Testing va_args based fatal(): %d", 10);
828
829 return TEST_SUCCESS;
830 }
831
832 static test_return_t number_of_cpus_TEST(void *)
833 {
834 test_true(number_of_cpus() >= 1);
835
836 return TEST_SUCCESS;
837 }
838
839 static test_return_t check_dns_TEST(void *)
840 {
841 test_warn(libtest::check_dns(), "Broken DNS server/no DNS server found");
842
843 return TEST_SUCCESS;
844 }
845
846 static test_return_t Timer_TEST(void *)
847 {
848 int64_t minutes= random() % 50;
849 minutes++;
850
851 Timer check;
852
853 check.reset();
854 check.offset(minutes, 2, 200);
855
856 ASSERT_EQ(check.minutes(), minutes);
857
858 return TEST_SUCCESS;
859 }
860
861 static test_return_t lookup_true_TEST(void *)
862 {
863 test_warn(libtest::lookup("exist.gearman.info"), "dns is not currently working");
864 return TEST_SUCCESS;
865 }
866
867 static test_return_t lookup_false_TEST(void *)
868 {
869 if (libtest::lookup("does_not_exist.gearman.info"))
870 {
871 Error << "Broken DNS server detected";
872 return TEST_SKIPPED;
873 }
874
875 return TEST_SUCCESS;
876 }
877
878 static test_return_t create_tmpfile_TEST(void *)
879 {
880 test_skip(0, access("/usr/bin/touch", X_OK ));
881 std::string tmp= create_tmpfile(__func__);
882 ASSERT_EQ(-1, access(tmp.c_str(), R_OK));
883 ASSERT_EQ(-1, access(tmp.c_str(), F_OK));
884
885 Application touch_app("/usr/bin/touch");
886 const char *args[]= { tmp.c_str(), 0 };
887 ASSERT_EQ(Application::SUCCESS, touch_app.run(args));
888 ASSERT_EQ(Application::SUCCESS, touch_app.join());
889
890 ASSERT_EQ(0, access(tmp.c_str(), R_OK));
891 ASSERT_EQ(0, unlink(tmp.c_str()));
892
893 return TEST_SUCCESS;
894 }
895
896 static test_return_t fatal_message_TEST(void *)
897 {
898 ASSERT_EQ(fatal_calls++, fatal::disabled_counter());
899 fatal_message("Fatal test");
900
901 return TEST_SUCCESS;
902 }
903
904 static test_return_t default_port_TEST(void *)
905 {
906 in_port_t ret_port= default_port();
907 ASSERT_EQ(ret_port, libtest::default_port());
908 ASSERT_EQ(ret_port, libtest::default_port());
909
910 return TEST_SUCCESS;
911 }
912
913 static test_return_t check_for_gearman(void *)
914 {
915 test_skip(true, HAVE_LIBGEARMAN);
916 test_skip(true, has_gearmand());
917 #if defined(HAVE_GEARMAND_BINARY) && HAVE_GEARMAND_BINARY
918 if (GEARMAND_BINARY)
919 {
920 if (strcmp(GEARMAND_BINARY, "./gearmand/gearmand"))
921 {
922 test_zero(access(GEARMAND_BINARY, X_OK ));
923 }
924 }
925 else
926 {
927 return TEST_SKIPPED;
928 }
929 #endif
930
931 testing_service= "gearmand";
932
933 return TEST_SUCCESS;
934 }
935
936 static test_return_t check_for_drizzle(void *)
937 {
938 test_skip(true, HAVE_LIBDRIZZLE);
939 test_skip(true, has_drizzled());
940
941 testing_service= "drizzled";
942
943 return TEST_SUCCESS;
944 }
945
946
947 test_st drizzled_tests[] ={
948 {"drizzled startup-shutdown", 0, drizzled_cycle_test },
949 {0, 0, 0}
950 };
951
952 test_st gearmand_tests[] ={
953 #if 0
954 {"pause", 0, pause_test },
955 #endif
956 {"gearmand startup-shutdown", 0, gearmand_cycle_test },
957 {"_compare(gearman_return_t)", 0, _compare_gearman_return_t_test },
958 {"server_startup(fail)", 0, server_startup_fail_TEST },
959 {0, 0, 0}
960 };
961
962 static test_return_t clear_servers(void* object)
963 {
964 server_startup_st *servers= (server_startup_st*)object;
965 test_true(servers);
966 servers->clear();
967
968 testing_service.clear();
969
970 return TEST_SUCCESS;
971 }
972
973 static test_return_t check_for_memcached(void* object)
974 {
975 test_skip(true, has_memcached());
976
977 server_startup_st *servers= (server_startup_st*)object;
978 test_true(servers);
979 servers->clear();
980
981 testing_service= "memcached";
982
983 return TEST_SUCCESS;
984 }
985
986 test_st memcached_TESTS[] ={
987 {"memcached startup-shutdown", 0, server_startup_TEST },
988 {"memcached(socket file) startup-shutdown", 0, socket_server_startup_TEST },
989 {"_compare(memcached_return_t)", 0, _compare_memcached_return_t_test },
990 {"server_startup(fail)", 0, server_startup_fail_TEST },
991 {0, 0, 0}
992 };
993
994 test_st test_skip_TESTS[] ={
995 {"true, true", 0, test_skip_true_TEST },
996 {"true, false", 0, test_skip_false_TEST },
997 {0, 0, 0}
998 };
999
1000 test_st environment_tests[] ={
1001 {"getenv()", 0, getenv_TEST },
1002 {"LIBTOOL_COMMAND", 0, LIBTOOL_COMMAND_test },
1003 {"VALGRIND_COMMAND", 0, VALGRIND_COMMAND_test },
1004 {"HELGRIND_COMMAND", 0, HELGRIND_COMMAND_test },
1005 {"GDB_COMMAND", 0, GDB_COMMAND_test },
1006 {0, 0, 0}
1007 };
1008
1009 test_st tests_log[] ={
1010 {"TEST_SUCCESS", false, test_success_test },
1011 {"TEST_FAILURE", false, test_failure_test },
1012 {"TEST_SUCCESS == 0", false, test_success_equals_one_test },
1013 {"SUCCESS", false, test_throw_success_TEST },
1014 {"libtest::__skipped", false, test_throw_skip_TEST },
1015 {"SKIP_IF", false, test_throw_skip_macro_TEST },
1016 {"FAIL", false, test_throw_fail_TEST },
1017 {"ASSERT_FALSE_", false, ASSERT_FALSE__TEST },
1018 {"ASSERT_FALSE", false, ASSERT_FALSE_TEST },
1019 {0, 0, 0}
1020 };
1021
1022 test_st local_log[] ={
1023 {"test_is_local()", 0, local_test },
1024 {"test_is_local(NOT)", 0, local_not_test },
1025 {0, 0, 0}
1026 };
1027
1028 test_st directories_tests[] ={
1029 {"var exists", 0, var_exists_test },
1030 {"var/tmp exists", 0, var_tmp_exists_test },
1031 {"var/run exists", 0, var_run_exists_test },
1032 {"var/log exists", 0, var_log_exists_test },
1033 {"var/drizzle exists", 0, var_drizzle_exists_test },
1034 {"var/tmp", 0, var_tmp_test },
1035 {"var/run", 0, var_run_test },
1036 {"var/log", 0, var_log_test },
1037 {"var/drizzle", 0, var_drizzle_test },
1038 {"var/tmp rm", 0, var_tmp_rm_test },
1039 {"var/run rm", 0, var_run_rm_test },
1040 {"var/log rm", 0, var_log_rm_test },
1041 {"var/drizzle rm", 0, var_drizzle_rm_test },
1042 {0, 0, 0}
1043 };
1044
1045 test_st comparison_tests[] ={
1046 {"_compare(test_return_t)", 0, _compare_test_return_t_test },
1047 {0, 0, 0}
1048 };
1049
1050 test_st cmdline_tests[] ={
1051 {"echo fubar", 0, echo_fubar_BINARY },
1052 {"core-count", 0, core_count_BINARY },
1053 {"wait --quiet", 0, wait_BINARY },
1054 {"wait --quiet --help", 0, wait_help_BINARY },
1055 {"wait --quiet --version", 0, wait_version_BINARY },
1056 {"wait --quiet /etc/services", 0, wait_services_BINARY },
1057 {"wait /etc/services", 0, wait_services_BINARY2 },
1058 {"wait /etc/services", 0, wait_services_appliction_TEST },
1059 {"gdb wait /etc/services", 0, gdb_wait_services_appliction_TEST },
1060 {"gdb abort", 0, gdb_abort_services_appliction_TEST },
1061 {0, 0, 0}
1062 };
1063
1064 test_st get_free_port_TESTS[] ={
1065 {"get_free_port()", 0, get_free_port_TEST },
1066 {"default_port()", 0, default_port_TEST },
1067 {0, 0, 0}
1068 };
1069
1070 test_st fatal_message_TESTS[] ={
1071 {"libtest::fatal", 0, fatal_TEST },
1072 {"fatal_message()", 0, fatal_message_TEST },
1073 {0, 0, 0}
1074 };
1075
1076 test_st number_of_cpus_TESTS[] ={
1077 {"libtest::number_of_cpus()", 0, number_of_cpus_TEST },
1078 {0, 0, 0}
1079 };
1080
1081 test_st create_tmpfile_TESTS[] ={
1082 {"libtest::create_tmpfile()", 0, create_tmpfile_TEST },
1083 {0, 0, 0}
1084 };
1085
1086 test_st timer_TESTS[] ={
1087 {"libtest::Timer", 0, Timer_TEST },
1088 {0, 0, 0}
1089 };
1090
1091 test_st dns_TESTS[] ={
1092 {"libtest::lookup(true)", 0, lookup_true_TEST },
1093 {"libtest::lookup(false)", 0, lookup_false_TEST },
1094 {"libtest::check_dns()", 0, check_dns_TEST },
1095 {0, 0, 0}
1096 };
1097
1098 test_st application_tests[] ={
1099 {"vchar_t", 0, vchar_t_TEST },
1100 {"vchar_t make() append()", 0, vchar_t_make_append_TEST },
1101 {"vchar_t compare()", 0, vchar_t_compare_neg_TEST },
1102 {"true", 0, application_true_BINARY },
1103 {"gbd true --fubar", 0, application_gdb_true_BINARY },
1104 {"gbd true", 0, application_gdb_true_BINARY2 },
1105 {"true --fubar", 0, application_true_fubar_BINARY },
1106 {"doesnotexist --fubar", 0, application_doesnotexist_BINARY },
1107 {"echo fubar", 0, application_echo_fubar_BINARY },
1108 {"echo fubar (as option)", 0, application_echo_fubar_BINARY2 },
1109 {0, 0, 0}
1110 };
1111
1112 static test_return_t check_for_curl(void *)
1113 {
1114 test_skip(true, HAVE_LIBCURL);
1115 return TEST_SUCCESS;
1116 }
1117
1118 static test_return_t disable_fatal_exception(void *)
1119 {
1120 fatal_calls= 0;
1121 fatal::disable();
1122 return TEST_SUCCESS;
1123 }
1124
1125 static test_return_t enable_fatal_exception(void *)
1126 {
1127 fatal::enable();
1128 return TEST_SUCCESS;
1129 }
1130
1131 test_st http_tests[] ={
1132 {"GET", 0, GET_TEST },
1133 {"POST", 0, POST_TEST },
1134 {"TRACE", 0, TRACE_TEST },
1135 {0, 0, 0}
1136 };
1137
1138 collection_st collection[] ={
1139 {"environment", 0, 0, environment_tests},
1140 {"return values", 0, 0, tests_log},
1141 {"test_skip()", 0, 0, test_skip_TESTS },
1142 {"local", 0, 0, local_log},
1143 {"directories", 0, 0, directories_tests},
1144 {"comparison", 0, 0, comparison_tests},
1145 {"gearmand", check_for_gearman, clear_servers, gearmand_tests},
1146 {"memcached", check_for_memcached, clear_servers, memcached_TESTS },
1147 {"drizzled", check_for_drizzle, clear_servers, drizzled_tests},
1148 {"cmdline", 0, 0, cmdline_tests},
1149 {"application", 0, 0, application_tests},
1150 {"http", check_for_curl, 0, http_tests},
1151 {"http", check_for_curl, 0, http_tests},
1152 {"get_free_port()", 0, 0, get_free_port_TESTS },
1153 {"fatal", disable_fatal_exception, enable_fatal_exception, fatal_message_TESTS },
1154 {"number_of_cpus()", 0, 0, number_of_cpus_TESTS },
1155 {"create_tmpfile()", 0, 0, create_tmpfile_TESTS },
1156 {"dns", 0, 0, dns_TESTS },
1157 {"libtest::Timer", 0, 0, timer_TESTS },
1158 {0, 0, 0, 0}
1159 };
1160
1161 static void *world_create(server_startup_st& servers, test_return_t&)
1162 {
1163 return &servers;
1164 }
1165
1166 void get_world(libtest::Framework *world)
1167 {
1168 world->collections(collection);
1169 world->create(world_create);
1170 }