X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=libtest%2Funittest.cc;h=8cc8a65ff99d08823ca15d33c26a0bfa55ed4422;hb=feefbfb339a8c31c9a54d938180b153fe60d269b;hp=6b3efe95cbce9d0beff090769c13ad7c01813444;hpb=f47caf2833675cce0b62a6e4ffd6764c1490a8b4;p=awesomized%2Flibmemcached diff --git a/libtest/unittest.cc b/libtest/unittest.cc index 6b3efe95..8cc8a65f 100644 --- a/libtest/unittest.cc +++ b/libtest/unittest.cc @@ -34,16 +34,16 @@ * */ -#include +#include "libtest/yatlcon.h" -#include +#include -#if defined(LIBTEST_WITH_LIBMEMCACHED_SUPPORT) && LIBTEST_WITH_LIBMEMCACHED_SUPPORT -#include +#if defined(HAVE_LIBMEMCACHED_1_0_TYPES_RETURN_H) && HAVE_LIBMEMCACHED_1_0_TYPES_RETURN_H +# include #endif -#if defined(LIBTEST_WITH_LIBGEARMAN_SUPPORT) && LIBTEST_WITH_LIBGEARMAN_SUPPORT -#include +#if defined(HAVE_LIBGEARMAN_1_0_RETURN_H) && HAVE_LIBGEARMAN_1_0_RETURN_H +# include #endif #include @@ -53,6 +53,21 @@ using namespace libtest; static std::string testing_service; +// Used to track setups where we see if failure is happening +static uint32_t fatal_calls= 0; + +static test_return_t getenv_TEST(void *) +{ +#if 0 + for (char **ptr= environ; *ptr; ptr++) + { + Error << *ptr; + } +#endif + + return TEST_SUCCESS; +} + static test_return_t LIBTOOL_COMMAND_test(void *) { test_true(getenv("LIBTOOL_COMMAND")); @@ -80,7 +95,7 @@ static test_return_t GDB_COMMAND_test(void *) static test_return_t test_success_equals_one_test(void *) { test_skip(HAVE_LIBMEMCACHED, 1); -#if defined(HAVE_LIBMEMCACHED) && HAVE_LIBMEMCACHED +#if defined(HAVE_LIBMEMCACHED_1_0_TYPES_RETURN_H) && HAVE_LIBMEMCACHED_1_0_TYPES_RETURN_H test_zero(MEMCACHED_SUCCESS); #endif return TEST_SUCCESS; @@ -91,11 +106,122 @@ static test_return_t test_success_test(void *) return TEST_SUCCESS; } +static test_return_t test_throw_success_TEST(void *) +{ + try { + _SUCCESS; + } + catch (libtest::__success) + { + return TEST_SUCCESS; + } + catch (...) + { + return TEST_FAILURE; + } + + return TEST_FAILURE; +} + +static test_return_t test_throw_skip_macro_TEST(void *) +{ + try { + SKIP_IF(true); + } + catch (libtest::__skipped e) + { + return TEST_SUCCESS; + } + catch (...) + { + FAIL("SLIP_IF() failed to throw libtest::_skipped"); + } + + FAIL("SLIP_IF() failed to throw"); + + return TEST_FAILURE; +} + +static test_return_t test_throw_skip_TEST(void *) +{ + try { + throw libtest::__skipped(LIBYATL_DEFAULT_PARAM, "basic test"); + } + catch (libtest::__skipped e) + { + return TEST_SUCCESS; + } + catch (...) + { + FAIL("SLIP_IF() failed to throw libtest::_skipped"); + } + + FAIL("SLIP_IF() failed to throw"); + + return TEST_FAILURE; +} + +static test_return_t test_throw_fail_TEST(void *) +{ + try { + FAIL("test message!"); + } + catch (const libtest::__failure& e) + { + std::string compare_message("test message!"); + test_zero(compare_message.compare(e.what())); + return TEST_SUCCESS; + } + catch (...) + { + return TEST_FAILURE; + } + + return TEST_FAILURE; +} +#pragma GCC diagnostic ignored "-Wstack-protector" + +static test_return_t ASSERT_FALSE__TEST(void *) +{ + try { + ASSERT_FALSE_(true, __func__); + } + catch (const libtest::__failure& e) + { + ASSERT_STREQ(e.what(), "Assertion '!true' [ ASSERT_FALSE__TEST ]"); + return TEST_SUCCESS; + } + catch (...) + { + return TEST_FAILURE; + } + + return TEST_FAILURE; +} + +static test_return_t ASSERT_FALSE_TEST(void *) +{ + try { + FAIL(__func__); + } + catch (const libtest::__failure& e) + { + ASSERT_STREQ(e.what(), __func__); + return TEST_SUCCESS; + } + catch (...) + { + return TEST_FAILURE; + } + + return TEST_FAILURE; +} + static test_return_t test_failure_test(void *) { return TEST_SKIPPED; // Only run this when debugging - test_compare(1, 2); + ASSERT_EQ(1, 2); return TEST_SUCCESS; } @@ -127,20 +253,20 @@ static test_return_t local_not_test(void *) // unsetenv() will cause issues with valgrind _compare(__FILE__, __LINE__, __func__, 0, unsetenv("LIBTEST_LOCAL"), true); - test_compare(0, unsetenv("LIBTEST_LOCAL")); + ASSERT_EQ(0, unsetenv("LIBTEST_LOCAL")); test_false(test_is_local()); - test_compare(0, setenv("LIBTEST_LOCAL", "1", 1)); + ASSERT_EQ(0, setenv("LIBTEST_LOCAL", "1", 1)); test_true(test_is_local()); if (temp.empty()) { - test_compare(0, unsetenv("LIBTEST_LOCAL")); + ASSERT_EQ(0, unsetenv("LIBTEST_LOCAL")); } else { char *old_string= strdup(temp.c_str()); - test_compare(0, setenv("LIBTEST_LOCAL", old_string, 1)); + ASSERT_EQ(0, setenv("LIBTEST_LOCAL", old_string, 1)); } return TEST_SUCCESS; @@ -148,31 +274,31 @@ static test_return_t local_not_test(void *) static test_return_t var_exists_test(void *) { - test_compare(0, access("var", R_OK | W_OK | X_OK)); + ASSERT_EQ(0, access("var", R_OK | W_OK | X_OK)); return TEST_SUCCESS; } static test_return_t var_tmp_exists_test(void *) { - test_compare(0, access("var/tmp", R_OK | W_OK | X_OK)); + ASSERT_EQ(0, access("var/tmp", R_OK | W_OK | X_OK)); return TEST_SUCCESS; } static test_return_t var_run_exists_test(void *) { - test_compare(0, access("var/run", R_OK | W_OK | X_OK)); + ASSERT_EQ(0, access("var/run", R_OK | W_OK | X_OK)); return TEST_SUCCESS; } static test_return_t var_log_exists_test(void *) { - test_compare(0, access("var/log", R_OK | W_OK | X_OK)); + ASSERT_EQ(0, access("var/log", R_OK | W_OK | X_OK)); return TEST_SUCCESS; } static test_return_t var_drizzle_exists_test(void *) { - test_compare(0, access("var/drizzle", R_OK | W_OK | X_OK)); + ASSERT_EQ(0, access("var/drizzle", R_OK | W_OK | X_OK)); return TEST_SUCCESS; } @@ -234,7 +360,7 @@ static test_return_t var_drizzle_rm_test(void *) static test_return_t _compare_test_return_t_test(void *) { - test_compare(TEST_SUCCESS, TEST_SUCCESS); + ASSERT_EQ(TEST_SUCCESS, TEST_SUCCESS); return TEST_SUCCESS; } @@ -242,8 +368,8 @@ static test_return_t _compare_test_return_t_test(void *) static test_return_t _compare_memcached_return_t_test(void *) { test_skip(HAVE_LIBMEMCACHED, true); -#if defined(HAVE_LIBMEMCACHED) && HAVE_LIBMEMCACHED - test_compare(MEMCACHED_SUCCESS, MEMCACHED_SUCCESS); +#if defined(HAVE_LIBMEMCACHED_1_0_TYPES_RETURN_H) && HAVE_LIBMEMCACHED_1_0_TYPES_RETURN_H + ASSERT_EQ(MEMCACHED_SUCCESS, MEMCACHED_SUCCESS); #endif return TEST_SUCCESS; @@ -252,8 +378,8 @@ static test_return_t _compare_memcached_return_t_test(void *) static test_return_t _compare_gearman_return_t_test(void *) { test_skip(HAVE_LIBGEARMAN, true); -#if defined(HAVE_LIBGEARMAN) && HAVE_LIBGEARMAN - test_compare(GEARMAN_SUCCESS, GEARMAN_SUCCESS); +#if defined(HAVE_LIBGEARMAN_1_0_RETURN_H) && HAVE_LIBGEARMAN_1_0_RETURN_H + ASSERT_EQ(GEARMAN_SUCCESS, GEARMAN_SUCCESS); #endif return TEST_SUCCESS; @@ -270,7 +396,7 @@ static test_return_t drizzled_cycle_test(void *object) test_skip(true, has_drizzled()); - test_skip(true, server_startup(*servers, "drizzled", get_free_port(), 0, NULL)); + test_skip(true, server_startup(*servers, "drizzled", get_free_port(), 0, NULL, false)); return TEST_SUCCESS; } @@ -280,30 +406,12 @@ static test_return_t gearmand_cycle_test(void *object) server_startup_st *servers= (server_startup_st*)object; test_true(servers and servers->validate()); -#if defined(HAVE_GEARMAND_BINARY) && HAVE_GEARMAND_BINARY - test_true(has_gearmand()); -#endif - test_skip(true, has_gearmand()); - - test_skip(true, server_startup(*servers, "gearmand", get_free_port(), 0, NULL)); - - return TEST_SUCCESS; -} - -#if 0 -static test_return_t memcached_light_cycle_TEST(void *object) -{ - server_startup_st *servers= (server_startup_st*)object; - test_true(servers); - - test_skip(true, bool(HAVE_MEMCACHED_LIGHT_BINARY)); - - test_true(server_startup(*servers, "memcached-light", get_free_port(), 0, NULL)); + test_skip(true, server_startup(*servers, "gearmand", get_free_port(), 0, NULL, false)); + servers->clear(); return TEST_SUCCESS; } -#endif static test_return_t skip_shim(bool a, bool b) { @@ -313,18 +421,18 @@ static test_return_t skip_shim(bool a, bool b) static test_return_t test_skip_true_TEST(void*) { - test_compare(true, true); - test_compare(false, false); - test_compare(TEST_SUCCESS, skip_shim(true, true)); - test_compare(TEST_SUCCESS, skip_shim(false, false)); + ASSERT_EQ(true, true); + ASSERT_EQ(false, false); + ASSERT_EQ(TEST_SUCCESS, skip_shim(true, true)); + ASSERT_EQ(TEST_SUCCESS, skip_shim(false, false)); return TEST_SUCCESS; } static test_return_t test_skip_false_TEST(void*) { - test_compare(TEST_SKIPPED, skip_shim(true, false)); - test_compare(TEST_SKIPPED, skip_shim(false, true)); + ASSERT_EQ(TEST_SKIPPED, skip_shim(true, false)); + ASSERT_EQ(TEST_SKIPPED, skip_shim(false, true)); return TEST_SUCCESS; } @@ -333,7 +441,9 @@ static test_return_t server_startup_fail_TEST(void *object) server_startup_st *servers= (server_startup_st*)object; test_true(servers); - test_compare(servers->start_server(testing_service, LIBTEST_FAIL_PORT, 0, NULL, true), false); + fatal::disable(); + ASSERT_EQ(servers->start_server(testing_service, LIBTEST_FAIL_PORT, 0, NULL, false), true); + fatal::enable(); return TEST_SUCCESS; } @@ -343,19 +453,19 @@ static test_return_t server_startup_TEST(void *object) server_startup_st *servers= (server_startup_st*)object; test_true(servers); - test_true(servers->start_server(testing_service, get_free_port(), 0, NULL, true)); + ASSERT_EQ(servers->start_server(testing_service, get_free_port(), 0, NULL, false), true); test_true(servers->last()); pid_t last_pid= servers->last()->pid(); - test_compare(servers->last()->pid(), last_pid); + ASSERT_EQ(servers->last()->pid(), last_pid); test_true(last_pid > 1); - test_compare(kill(last_pid, 0), 0); + ASSERT_EQ(kill(last_pid, 0), 0); test_true(servers->shutdown()); #if 0 - test_compare(servers->last()->pid(), -1); - test_compare(kill(last_pid, 0), -1); + ASSERT_EQ(servers->last()->pid(), -1); + ASSERT_EQ(kill(last_pid, 0), -1); #endif return TEST_SUCCESS; @@ -366,7 +476,7 @@ static test_return_t socket_server_startup_TEST(void *object) server_startup_st *servers= (server_startup_st*)object; test_true(servers); - test_true(servers->start_socket_server(testing_service, get_free_port(), 0, NULL, true)); + test_true(servers->start_socket_server(testing_service, get_free_port(), 0, NULL, false)); return TEST_SUCCESS; } @@ -384,7 +494,7 @@ static test_return_t memcached_sasl_test(void *object) if (HAVE_LIBMEMCACHED) { test_true(has_memcached_sasl()); - test_true(server_startup(*servers, "memcached-sasl", get_free_port(), 0, NULL)); + test_true(server_startup(*servers, "memcached-sasl", get_free_port(), 0, NULL, false)); return TEST_SUCCESS; } @@ -396,10 +506,11 @@ static test_return_t memcached_sasl_test(void *object) static test_return_t application_true_BINARY(void *) { - Application true_app("true"); + test_skip(0, access("/usr/bin/true", X_OK )); + Application true_app("/usr/bin/true"); - test_compare(Application::SUCCESS, true_app.run()); - test_compare(Application::SUCCESS, true_app.wait()); + ASSERT_EQ(Application::SUCCESS, true_app.run()); + ASSERT_EQ(Application::SUCCESS, true_app.join()); return TEST_SUCCESS; } @@ -407,11 +518,13 @@ static test_return_t application_true_BINARY(void *) static test_return_t application_gdb_true_BINARY2(void *) { test_skip(0, access("/usr/bin/gdb", X_OK )); - Application true_app("true"); - true_app.use_gdb(); + test_skip(0, access("/usr/bin/true", X_OK )); + + Application true_app("/usr/bin/true"); + true_app.use_gdb(true); - test_compare(Application::SUCCESS, true_app.run()); - test_compare(Application::SUCCESS, true_app.wait()); + ASSERT_EQ(Application::SUCCESS, true_app.run()); + ASSERT_EQ(Application::SUCCESS, true_app.join()); return TEST_SUCCESS; } @@ -419,23 +532,26 @@ static test_return_t application_gdb_true_BINARY2(void *) static test_return_t application_gdb_true_BINARY(void *) { test_skip(0, access("/usr/bin/gdb", X_OK )); - Application true_app("true"); - true_app.use_gdb(); + test_skip(0, access("/usr/bin/true", X_OK )); + + Application true_app("/usr/bin/true"); + true_app.use_gdb(true); const char *args[]= { "--fubar", 0 }; - test_compare(Application::SUCCESS, true_app.run(args)); - test_compare(Application::SUCCESS, true_app.wait()); + ASSERT_EQ(Application::SUCCESS, true_app.run(args)); + ASSERT_EQ(Application::SUCCESS, true_app.join()); return TEST_SUCCESS; } static test_return_t application_true_fubar_BINARY(void *) { - Application true_app("true"); + test_skip(0, access("/usr/bin/true", X_OK )); + Application true_app("/usr/bin/true"); const char *args[]= { "--fubar", 0 }; - test_compare(Application::SUCCESS, true_app.run(args)); - test_compare(Application::SUCCESS, true_app.wait()); + ASSERT_EQ(Application::SUCCESS, true_app.run(args)); + ASSERT_EQ(Application::SUCCESS, true_app.join()); test_zero(true_app.stdout_result().size()); return TEST_SUCCESS; @@ -450,10 +566,12 @@ static test_return_t application_doesnotexist_BINARY(void *) const char *args[]= { "--fubar", 0 }; #if defined(TARGET_OS_OSX) && TARGET_OS_OSX - test_compare(Application::INVALID, true_app.run(args)); + ASSERT_EQ(Application::INVALID_POSIX_SPAWN, true_app.run(args)); +#elif defined(TARGET_OS_FREEBSD) && TARGET_OS_FREEBSD + ASSERT_EQ(Application::INVALID_POSIX_SPAWN, true_app.run(args)); #else - test_compare(Application::SUCCESS, true_app.run(args)); - test_compare(Application::INVALID, true_app.wait(false)); + ASSERT_EQ(Application::SUCCESS, true_app.run(args)); + ASSERT_EQ(Application::INVALID_POSIX_SPAWN, true_app.join()); #endif test_zero(true_app.stdout_result().size()); @@ -461,37 +579,11 @@ static test_return_t application_doesnotexist_BINARY(void *) return TEST_SUCCESS; } -static test_return_t application_true_fubar_eq_doh_BINARY(void *) -{ - Application true_app("true"); - - const char *args[]= { "--fubar=doh", 0 }; - test_compare(Application::SUCCESS, true_app.run(args)); - test_compare(Application::SUCCESS, true_app.wait()); - test_zero(true_app.stdout_result().size()); - - return TEST_SUCCESS; -} - -static test_return_t application_true_fubar_eq_doh_option_BINARY(void *) -{ - Application true_app("true"); - - true_app.add_option("--fubar=", "doh"); - - test_compare(Application::SUCCESS, true_app.run()); - test_compare(Application::SUCCESS, true_app.wait()); - test_zero(true_app.stdout_result().size()); - - return TEST_SUCCESS; -} - - static test_return_t GET_TEST(void *) { libtest::http::GET get("http://foo.example.com/"); - test_compare(false, get.execute()); + ASSERT_EQ(false, get.execute()); return TEST_SUCCESS; } @@ -501,7 +593,7 @@ static test_return_t POST_TEST(void *) libtest::vchar_t body; libtest::http::POST post("http://foo.example.com/", body); - test_compare(false, post.execute()); + ASSERT_EQ(false, post.execute()); return TEST_SUCCESS; } @@ -511,7 +603,7 @@ static test_return_t TRACE_TEST(void *) libtest::vchar_t body; libtest::http::TRACE trace("http://foo.example.com/", body); - test_compare(false, trace.execute()); + ASSERT_EQ(false, trace.execute()); return TEST_SUCCESS; } @@ -521,7 +613,18 @@ static test_return_t vchar_t_TEST(void *) { libtest::vchar_t response; libtest::make_vector(response, test_literal_param("fubar\n")); - test_compare(response, response); + ASSERT_EQ(response, response); + + return TEST_SUCCESS; +} + +static test_return_t vchar_t_make_append_TEST(void *) +{ + libtest::vchar_t hostname; + libtest::vchar::make(hostname, 23); + libtest::vchar::append(hostname, ".com"); + ASSERT_EQ(28, hostname.size()); + ASSERT_EQ(0, hostname[27]); return TEST_SUCCESS; } @@ -539,57 +642,57 @@ static test_return_t vchar_t_compare_neg_TEST(void *) static test_return_t application_echo_fubar_BINARY(void *) { - Application true_app("echo"); + if (0) + { + test_skip(0, access("/bin/echo", X_OK )); + Application true_app("/bin/echo"); - const char *args[]= { "fubar", 0 }; - test_compare(Application::SUCCESS, true_app.run(args)); - test_compare(Application::SUCCESS, true_app.wait()); + const char *args[]= { "fubar", 0 }; + ASSERT_EQ(Application::SUCCESS, true_app.run(args)); - while (true_app.slurp() == false) {} ; + while (true_app.slurp() == false) {} ; - libtest::vchar_t response; - make_vector(response, test_literal_param("fubar\n")); - test_compare(response, true_app.stdout_result()); + libtest::vchar_t response; + make_vector(response, test_literal_param("fubar\n")); + ASSERT_EQ(response, true_app.stdout_result()); + } return TEST_SUCCESS; } static test_return_t application_echo_fubar_BINARY2(void *) { - Application true_app("echo"); + if (0) + { + test_skip(0, access("/bin/echo", X_OK )); + Application true_app("/bin/echo"); - true_app.add_option("fubar"); + true_app.add_option("fubar"); - test_compare(Application::SUCCESS, true_app.run()); - test_compare(Application::SUCCESS, true_app.join()); + ASSERT_EQ(Application::SUCCESS, true_app.run()); + ASSERT_EQ(Application::SUCCESS, true_app.join()); - libtest::vchar_t response; - make_vector(response, test_literal_param("fubar\n")); - test_compare(response, true_app.stdout_result()); + libtest::vchar_t response; + make_vector(response, test_literal_param("fubar\n")); + ASSERT_EQ(response, true_app.stdout_result()); + } return TEST_SUCCESS; } -static test_return_t true_BINARY(void *) +static test_return_t echo_fubar_BINARY(void *) { - const char *args[]= { 0 }; - test_compare(EXIT_SUCCESS, exec_cmdline("true", args)); + const char *args[]= { "fubar", 0 }; + ASSERT_EQ(EXIT_SUCCESS, exec_cmdline("/bin/echo", args)); return TEST_SUCCESS; } -static test_return_t true_fubar_BINARY(void *) +static test_return_t core_count_BINARY(void *) { - const char *args[]= { "--fubar", 0 }; - test_compare(EXIT_SUCCESS, exec_cmdline("true", args)); - - return TEST_SUCCESS; -} + const char *args[]= { 0 }; -static test_return_t echo_fubar_BINARY(void *) -{ - const char *args[]= { "fubar", 0 }; - test_compare(EXIT_SUCCESS, exec_cmdline("echo", args)); + ASSERT_EQ(EXIT_SUCCESS, exec_cmdline("libtest/core-count", args, true)); return TEST_SUCCESS; } @@ -598,7 +701,7 @@ static test_return_t wait_BINARY(void *) { const char *args[]= { "--quiet", 0 }; - test_compare(EXIT_FAILURE, exec_cmdline("libtest/wait", args, true)); + ASSERT_EQ(EXIT_FAILURE, exec_cmdline("libtest/wait", args, true)); return TEST_SUCCESS; } @@ -607,7 +710,7 @@ static test_return_t wait_help_BINARY(void *) { const char *args[]= { "--quiet", "--help", 0 }; - test_compare(EXIT_SUCCESS, exec_cmdline("libtest/wait", args, true)); + ASSERT_EQ(EXIT_SUCCESS, exec_cmdline("libtest/wait", args, true)); return TEST_SUCCESS; } @@ -616,7 +719,7 @@ static test_return_t wait_version_BINARY(void *) { const char *args[]= { "--quiet", "--version", 0 }; - test_compare(EXIT_SUCCESS, exec_cmdline("libtest/wait", args, true)); + ASSERT_EQ(EXIT_SUCCESS, exec_cmdline("libtest/wait", args, true)); return TEST_SUCCESS; } @@ -627,7 +730,7 @@ static test_return_t wait_services_BINARY(void *) const char *args[]= { "--quiet", "/etc/services", 0 }; - test_compare(EXIT_SUCCESS, exec_cmdline("libtest/wait", args, true)); + ASSERT_EQ(EXIT_SUCCESS, exec_cmdline("libtest/wait", args, true)); return TEST_SUCCESS; } @@ -638,22 +741,23 @@ static test_return_t wait_services_BINARY2(void *) const char *args[]= { "/etc/services", 0 }; - test_compare(EXIT_SUCCESS, exec_cmdline("libtest/wait", args, true)); + ASSERT_EQ(EXIT_SUCCESS, exec_cmdline("libtest/wait", args, true)); return TEST_SUCCESS; } static test_return_t wait_services_appliction_TEST(void *) { - test_skip(0, access("/usr/bin/gdb", X_OK )); test_skip(0, access("/etc/services", R_OK )); + test_skip(0, access("/usr/bin/gdb", X_OK )); + test_skip(0, access("libtest/wait", X_OK )); libtest::Application wait_app("libtest/wait", true); - wait_app.use_gdb(); + wait_app.use_gdb(true); const char *args[]= { "/etc/services", 0 }; - test_compare(Application::SUCCESS, wait_app.run(args)); - test_compare(Application::SUCCESS, wait_app.wait()); + ASSERT_EQ(Application::SUCCESS, wait_app.run(args)); + ASSERT_EQ(Application::SUCCESS, wait_app.join()); return TEST_SUCCESS; } @@ -665,42 +769,44 @@ static test_return_t gdb_wait_services_appliction_TEST(void *) test_skip(0, TARGET_OS_OSX); #endif - test_skip(0, access("/usr/bin/gdb", X_OK )); test_skip(0, access("/etc/services", R_OK )); + test_skip(0, access("/usr/bin/gdb", X_OK )); + test_skip(0, access("libtest/wait", X_OK )); libtest::Application wait_app("libtest/wait", true); - wait_app.use_gdb(); + wait_app.use_gdb(true); const char *args[]= { "/etc/services", 0 }; - test_compare(Application::SUCCESS, wait_app.run(args)); - test_compare(Application::SUCCESS, wait_app.wait()); + ASSERT_EQ(Application::SUCCESS, wait_app.run(args)); + ASSERT_EQ(Application::SUCCESS, wait_app.join()); return TEST_SUCCESS; } static test_return_t gdb_abort_services_appliction_TEST(void *) { - test_skip(true, false); test_skip(0, access("/usr/bin/gdb", X_OK )); + test_skip(0, access("libtest/abort", X_OK )); + test_skip(true, false); #if defined(TARGET_OS_OSX) && TARGET_OS_OSX test_skip(0, TARGET_OS_OSX); #endif libtest::Application abort_app("libtest/abort", true); - abort_app.use_gdb(); + abort_app.use_gdb(true); - test_compare(Application::SUCCESS, abort_app.run()); - test_compare(Application::SUCCESS, abort_app.wait()); + ASSERT_EQ(Application::SUCCESS, abort_app.run()); + ASSERT_EQ(Application::SUCCESS, abort_app.join()); std::string gdb_filename= abort_app.gdb_filename(); test_skip(0, access(gdb_filename.c_str(), R_OK )); const char *args[]= { "SIGABRT", gdb_filename.c_str(), 0 }; - test_compare(EXIT_SUCCESS, exec_cmdline("grep", args)); + ASSERT_EQ(EXIT_SUCCESS, exec_cmdline("grep", args)); // Sanity test args[0]= "THIS_WILL_NOT_BE_FOUND"; - test_compare(EXIT_FAILURE, exec_cmdline("grep", args)); + ASSERT_EQ(EXIT_FAILURE, exec_cmdline("grep", args)); return TEST_SUCCESS; } @@ -715,11 +821,9 @@ static test_return_t get_free_port_TEST(void *) return TEST_SUCCESS; } -static uint32_t fatal_calls= 0; - static test_return_t fatal_TEST(void *) { - test_compare(fatal_calls++, fatal::disabled_counter()); + ASSERT_EQ(fatal_calls++, fatal::disabled_counter()); throw libtest::fatal(LIBYATL_DEFAULT_PARAM, "Testing va_args based fatal(): %d", 10); return TEST_SUCCESS; @@ -749,7 +853,7 @@ static test_return_t Timer_TEST(void *) check.reset(); check.offset(minutes, 2, 200); - test_compare(check.minutes(), minutes); + ASSERT_EQ(check.minutes(), minutes); return TEST_SUCCESS; } @@ -762,35 +866,33 @@ static test_return_t lookup_true_TEST(void *) static test_return_t lookup_false_TEST(void *) { - if (libtest::lookup("does_not_exist.gearman.info")) - { - Error << "Broken DNS server detected"; - return TEST_SKIPPED; - } + SKIP_IF_(libtest::lookup("does_not_exist.gearman.info"), + "Broken DNS server detected"); return TEST_SUCCESS; } static test_return_t create_tmpfile_TEST(void *) { + test_skip(0, access("/usr/bin/touch", X_OK )); std::string tmp= create_tmpfile(__func__); - test_compare(-1, access(tmp.c_str(), R_OK)); - test_compare(-1, access(tmp.c_str(), F_OK)); + ASSERT_EQ(-1, access(tmp.c_str(), R_OK)); + ASSERT_EQ(-1, access(tmp.c_str(), F_OK)); - Application touch_app("touch"); + Application touch_app("/usr/bin/touch"); const char *args[]= { tmp.c_str(), 0 }; - test_compare(Application::SUCCESS, touch_app.run(args)); - test_compare(Application::SUCCESS, touch_app.join()); + ASSERT_EQ(Application::SUCCESS, touch_app.run(args)); + ASSERT_EQ(Application::SUCCESS, touch_app.join()); - test_compare(0, access(tmp.c_str(), R_OK)); - test_compare(0, unlink(tmp.c_str())); + ASSERT_EQ(0, access(tmp.c_str(), R_OK)); + ASSERT_EQ(0, unlink(tmp.c_str())); return TEST_SUCCESS; } static test_return_t fatal_message_TEST(void *) { - test_compare(fatal_calls++, fatal::disabled_counter()); + ASSERT_EQ(fatal_calls++, fatal::disabled_counter()); fatal_message("Fatal test"); return TEST_SUCCESS; @@ -799,8 +901,8 @@ static test_return_t fatal_message_TEST(void *) static test_return_t default_port_TEST(void *) { in_port_t ret_port= default_port(); - test_compare(ret_port, libtest::default_port()); - test_compare(ret_port, libtest::default_port()); + ASSERT_EQ(ret_port, libtest::default_port()); + ASSERT_EQ(ret_port, libtest::default_port()); return TEST_SUCCESS; } @@ -809,6 +911,19 @@ static test_return_t check_for_gearman(void *) { test_skip(true, HAVE_LIBGEARMAN); test_skip(true, has_gearmand()); +#if defined(HAVE_GEARMAND_BINARY) && HAVE_GEARMAND_BINARY + if (GEARMAND_BINARY) + { + if (strcmp(GEARMAND_BINARY, "./gearmand/gearmand")) + { + test_zero(access(GEARMAND_BINARY, X_OK )); + } + } + else + { + return TEST_SKIPPED; + } +#endif testing_service= "gearmand"; @@ -841,9 +956,19 @@ test_st gearmand_tests[] ={ {0, 0, 0} }; -static test_return_t check_for_libmemcached(void* object) +static test_return_t clear_servers(void* object) +{ + server_startup_st *servers= (server_startup_st*)object; + test_true(servers); + servers->clear(); + + testing_service.clear(); + + return TEST_SUCCESS; +} + +static test_return_t check_for_memcached(void* object) { - test_skip(true, HAVE_LIBMEMCACHED); test_skip(true, has_memcached()); server_startup_st *servers= (server_startup_st*)object; @@ -870,6 +995,7 @@ test_st test_skip_TESTS[] ={ }; test_st environment_tests[] ={ + {"getenv()", 0, getenv_TEST }, {"LIBTOOL_COMMAND", 0, LIBTOOL_COMMAND_test }, {"VALGRIND_COMMAND", 0, VALGRIND_COMMAND_test }, {"HELGRIND_COMMAND", 0, HELGRIND_COMMAND_test }, @@ -881,6 +1007,12 @@ test_st tests_log[] ={ {"TEST_SUCCESS", false, test_success_test }, {"TEST_FAILURE", false, test_failure_test }, {"TEST_SUCCESS == 0", false, test_success_equals_one_test }, + {"SUCCESS", false, test_throw_success_TEST }, + {"libtest::__skipped", false, test_throw_skip_TEST }, + {"SKIP_IF", false, test_throw_skip_macro_TEST }, + {"FAIL", false, test_throw_fail_TEST }, + {"ASSERT_FALSE_", false, ASSERT_FALSE__TEST }, + {"ASSERT_FALSE", false, ASSERT_FALSE_TEST }, {0, 0, 0} }; @@ -913,9 +1045,8 @@ test_st comparison_tests[] ={ }; test_st cmdline_tests[] ={ - {"true", 0, true_BINARY }, - {"true --fubar", 0, true_fubar_BINARY }, {"echo fubar", 0, echo_fubar_BINARY }, + {"core-count", 0, core_count_BINARY }, {"wait --quiet", 0, wait_BINARY }, {"wait --quiet --help", 0, wait_help_BINARY }, {"wait --quiet --version", 0, wait_version_BINARY }, @@ -963,14 +1094,13 @@ test_st dns_TESTS[] ={ test_st application_tests[] ={ {"vchar_t", 0, vchar_t_TEST }, + {"vchar_t make() append()", 0, vchar_t_make_append_TEST }, {"vchar_t compare()", 0, vchar_t_compare_neg_TEST }, {"true", 0, application_true_BINARY }, {"gbd true --fubar", 0, application_gdb_true_BINARY }, {"gbd true", 0, application_gdb_true_BINARY2 }, {"true --fubar", 0, application_true_fubar_BINARY }, {"doesnotexist --fubar", 0, application_doesnotexist_BINARY }, - {"true --fubar=doh", 0, application_true_fubar_eq_doh_BINARY }, - {"true --fubar=doh add_option()", 0, application_true_fubar_eq_doh_option_BINARY }, {"echo fubar", 0, application_echo_fubar_BINARY }, {"echo fubar (as option)", 0, application_echo_fubar_BINARY2 }, {0, 0, 0} @@ -984,13 +1114,14 @@ static test_return_t check_for_curl(void *) static test_return_t disable_fatal_exception(void *) { + fatal_calls= 0; fatal::disable(); return TEST_SUCCESS; } static test_return_t enable_fatal_exception(void *) { - fatal::disable(); + fatal::enable(); return TEST_SUCCESS; } @@ -1008,9 +1139,9 @@ collection_st collection[] ={ {"local", 0, 0, local_log}, {"directories", 0, 0, directories_tests}, {"comparison", 0, 0, comparison_tests}, - {"gearmand", check_for_gearman, 0, gearmand_tests}, - {"memcached", check_for_libmemcached, 0, memcached_TESTS }, - {"drizzled", check_for_drizzle, 0, drizzled_tests}, + {"gearmand", check_for_gearman, clear_servers, gearmand_tests}, + {"memcached", check_for_memcached, clear_servers, memcached_TESTS }, + {"drizzled", check_for_drizzle, clear_servers, drizzled_tests}, {"cmdline", 0, 0, cmdline_tests}, {"application", 0, 0, application_tests}, {"http", check_for_curl, 0, http_tests},