X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=libtest%2Funittest.cc;h=06914724a30290bdac16e19a398a35705da1f3c5;hb=cda6d9fa2609c76f533f9172e325c707f4ab8d26;hp=cee9b52ec1f5e24ea20e54343a301fcb86c69d13;hpb=4abccff8503dba0aafd6945a1aa028ec4bf3f0d1;p=m6w6%2Flibmemcached diff --git a/libtest/unittest.cc b/libtest/unittest.cc index cee9b52e..06914724 100644 --- a/libtest/unittest.cc +++ b/libtest/unittest.cc @@ -25,7 +25,7 @@ #include #if defined(LIBTEST_WITH_LIBMEMCACHED_SUPPORT) && LIBTEST_WITH_LIBMEMCACHED_SUPPORT -#include +#include #endif #if defined(LIBTEST_WITH_LIBGEARMAN_SUPPORT) && LIBTEST_WITH_LIBGEARMAN_SUPPORT @@ -219,7 +219,7 @@ 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); + test_compare(GEARMAN_SUCCESS, GEARMAN_SUCCESS); #endif return TEST_SUCCESS; @@ -230,15 +230,27 @@ static test_return_t gearmand_cycle_test(void *object) server_startup_st *servers= (server_startup_st*)object; test_true(servers); - if (HAVE_LIBGEARMAN) - { - const char *argv[1]= { "cycle_gearmand" }; - test_true(server_startup(*servers, "gearmand", 9999, 1, argv)); +#if defined(HAVE_GEARMAND_BINARY) && HAVE_GEARMAND_BINARY + test_true(has_gearmand_binary()); +#else + test_skip(true, has_gearmand_binary()); +#endif - return TEST_SUCCESS; - } + test_true(server_startup(*servers, "gearmand", get_free_port(), 0, NULL)); - return TEST_SKIPPED; + return TEST_SUCCESS; +} + +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)); + + return TEST_SUCCESS; } static test_return_t memcached_cycle_test(void *object) @@ -248,8 +260,8 @@ static test_return_t memcached_cycle_test(void *object) if (MEMCACHED_BINARY and HAVE_LIBMEMCACHED) { - const char *argv[1]= { "cycle_memcached" }; - test_true(server_startup(*servers, "memcached", 9998, 1, argv)); + test_true(has_memcached_binary()); + test_true(server_startup(*servers, "memcached", get_free_port(), 0, NULL)); return TEST_SUCCESS; } @@ -262,12 +274,15 @@ static test_return_t memcached_socket_cycle_test(void *object) server_startup_st *servers= (server_startup_st*)object; test_true(servers); - if (MEMCACHED_BINARY and HAVE_LIBMEMCACHED) + if (MEMCACHED_BINARY) { - const char *argv[1]= { "cycle_memcached" }; - test_true(servers->start_socket_server("memcached", 9997, 1, argv)); + if (HAVE_LIBMEMCACHED) + { + test_true(has_memcached_binary()); + test_true(servers->start_socket_server("memcached", get_free_port(), 0, NULL)); - return TEST_SUCCESS; + return TEST_SUCCESS; + } } return TEST_SKIPPED; @@ -283,29 +298,405 @@ static test_return_t memcached_sasl_test(void *object) return TEST_SKIPPED; } - if (MEMCACHED_SASL_BINARY and HAVE_LIBMEMCACHED) + if (MEMCACHED_SASL_BINARY) { - const char *argv[1]= { "cycle_memcached_sasl" }; - test_true(server_startup(*servers, "memcached-sasl", 9996, 1, argv)); + if (HAVE_LIBMEMCACHED) + { + test_true(has_memcached_sasl_binary()); + test_true(server_startup(*servers, "memcached-sasl", get_free_port(), 0, NULL)); - return TEST_SUCCESS; + return TEST_SUCCESS; + } } return TEST_SKIPPED; } +static test_return_t application_true_BINARY(void *) +{ + Application true_app("true"); + + test_compare(Application::SUCCESS, true_app.run()); + test_compare(Application::SUCCESS, true_app.wait()); + + return TEST_SUCCESS; +} + +static test_return_t application_gdb_true_BINARY2(void *) +{ + Application true_app("true"); + true_app.use_gdb(); + + test_compare(Application::SUCCESS, true_app.run()); + test_compare(Application::SUCCESS, true_app.wait()); + + return TEST_SUCCESS; +} + +static test_return_t application_gdb_true_BINARY(void *) +{ + Application true_app("true"); + true_app.use_gdb(); + + const char *args[]= { "--fubar", 0 }; + test_compare(Application::SUCCESS, true_app.run(args)); + test_compare(Application::SUCCESS, true_app.wait()); + + return TEST_SUCCESS; +} + +static test_return_t application_true_fubar_BINARY(void *) +{ + Application true_app("true"); + + const char *args[]= { "--fubar", 0 }; + test_compare(Application::SUCCESS, true_app.run(args)); + test_compare(Application::SUCCESS, true_app.wait()); + test_compare(0, true_app.stdout_result().size()); + + return TEST_SUCCESS; +} + +static test_return_t application_doesnotexist_BINARY(void *) +{ + Application true_app("doesnotexist"); + + const char *args[]= { "--fubar", 0 }; +#if defined(TARGET_OS_OSX) && TARGET_OS_OSX + test_compare(Application::INVALID, true_app.run(args)); +#else + test_compare(Application::SUCCESS, true_app.run(args)); +#endif + // Behavior is different if we are running under valgrind + if (getenv("TESTS_ENVIRONMENT") and strstr(getenv("TESTS_ENVIRONMENT"), "valgrind")) + { + test_compare(Application::FAILURE, true_app.wait()); + } + else + { +#if defined(TARGET_OS_OSX) && TARGET_OS_OSX + test_compare(Application::FAILURE, true_app.wait()); +#else + test_compare(Application::INVALID, true_app.wait()); +#endif + } + test_compare(0, true_app.stdout_result().size()); + + 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_compare(0, 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_compare(0, 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()); + + return TEST_SUCCESS; +} + +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()); + + return TEST_SUCCESS; +} + +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()); + + return TEST_SUCCESS; +} + + +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); + + return TEST_SUCCESS; +} + +static test_return_t application_echo_fubar_BINARY(void *) +{ + Application true_app("echo"); + + const char *args[]= { "fubar", 0 }; + test_compare(Application::SUCCESS, true_app.run(args)); + test_compare(Application::SUCCESS, true_app.wait()); + + libtest::vchar_t response; + make_vector(response, test_literal_param("fubar\n")); + test_compare(response, true_app.stdout_result()); + + return TEST_SUCCESS; +} + +static test_return_t application_echo_fubar_BINARY2(void *) +{ + Application true_app("echo"); + + true_app.add_option("fubar"); + + test_compare(Application::SUCCESS, true_app.run()); + test_compare(Application::SUCCESS, true_app.wait()); + libtest::vchar_t response; + make_vector(response, test_literal_param("fubar\n")); + test_compare(response, true_app.stdout_result()); + + return TEST_SUCCESS; +} + +static test_return_t true_BINARY(void *) +{ + const char *args[]= { 0 }; + test_compare(EXIT_SUCCESS, exec_cmdline("true", args)); + + return TEST_SUCCESS; +} + +static test_return_t true_fubar_BINARY(void *) +{ + const char *args[]= { "--fubar", 0 }; + test_compare(EXIT_SUCCESS, exec_cmdline("true", args)); + + return TEST_SUCCESS; +} + +static test_return_t echo_fubar_BINARY(void *) +{ + const char *args[]= { "fubar", 0 }; + test_compare(EXIT_SUCCESS, exec_cmdline("echo", args)); + + return TEST_SUCCESS; +} + +static test_return_t wait_BINARY(void *) +{ + const char *args[]= { "--quiet", 0 }; + + test_compare(EXIT_FAILURE, exec_cmdline("libtest/wait", args, true)); + + return TEST_SUCCESS; +} + +static test_return_t wait_help_BINARY(void *) +{ + const char *args[]= { "--quiet", "--help", 0 }; + + test_compare(EXIT_SUCCESS, exec_cmdline("libtest/wait", args, true)); + + return TEST_SUCCESS; +} + +static test_return_t wait_version_BINARY(void *) +{ + const char *args[]= { "--quiet", "--version", 0 }; + + test_compare(EXIT_SUCCESS, exec_cmdline("libtest/wait", args, true)); + + return TEST_SUCCESS; +} + +static test_return_t wait_services_BINARY(void *) +{ + test_skip(0, access("/etc/services", R_OK )); + + const char *args[]= { "--quiet", "/etc/services", 0 }; + + test_compare(EXIT_SUCCESS, exec_cmdline("libtest/wait", args, true)); + + return TEST_SUCCESS; +} + +static test_return_t wait_services_BINARY2(void *) +{ + test_skip(0, access("/etc/services", R_OK )); + + const char *args[]= { "/etc/services", 0 }; + + test_compare(EXIT_SUCCESS, exec_cmdline("libtest/wait", args, true)); + + return TEST_SUCCESS; +} + +static test_return_t wait_services_appliction_TEST(void *) +{ + test_skip(0, access("/etc/services", R_OK )); + + libtest::Application wait_app("libtest/wait", true); + wait_app.use_gdb(); + + const char *args[]= { "/etc/services", 0 }; + test_compare(Application::SUCCESS, wait_app.run(args)); + test_compare(Application::SUCCESS, wait_app.wait()); + + return TEST_SUCCESS; +} + +static test_return_t gdb_wait_services_appliction_TEST(void *) +{ +#if defined(TARGET_OS_OSX) && TARGET_OS_OSX + test_skip(0, TARGET_OS_OSX); +#endif + + test_skip(0, access("/etc/services", R_OK )); + + libtest::Application wait_app("libtest/wait", true); + wait_app.use_gdb(); + + const char *args[]= { "/etc/services", 0 }; + test_compare(Application::SUCCESS, wait_app.run(args)); + test_compare(Application::SUCCESS, wait_app.wait()); + + return TEST_SUCCESS; +} + +static test_return_t gdb_abort_services_appliction_TEST(void *) +{ +#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(); + + test_compare(Application::SUCCESS, abort_app.run()); + test_compare(Application::SUCCESS, abort_app.wait()); + + std::string gdb_filename= abort_app.gdb_filename(); + const char *args[]= { "SIGABRT", gdb_filename.c_str(), 0 }; + test_compare(EXIT_SUCCESS, exec_cmdline("grep", args)); + + // Sanity test + args[0]= "THIS_WILL_NOT_BE_FOUND"; + test_compare(EXIT_FAILURE, exec_cmdline("grep", args)); + + return TEST_SUCCESS; +} + +static test_return_t get_free_port_TEST(void *) +{ + in_port_t ret_port; + test_true_hint((ret_port= get_free_port()), ret_port); + test_true(get_free_port() != default_port()); + test_true(get_free_port() != get_free_port()); + + return TEST_SUCCESS; +} + +static uint32_t fatal_calls= 0; + +static test_return_t fatal_TEST(void *) +{ + test_compare(fatal_calls++, fatal::disabled_counter()); + throw libtest::fatal(LIBYATL_DEFAULT_PARAM, "Testing va_args based fatal(): %d", 10); + + return TEST_SUCCESS; +} + +static test_return_t number_of_cpus_TEST(void *) +{ + test_true(number_of_cpus() >= 1); + + return TEST_SUCCESS; +} + +static test_return_t create_tmpfile_TEST(void *) +{ + std::string tmp= create_tmpfile(__func__); + + Application touch_app("touch"); + const char *args[]= { tmp.c_str(), 0 }; + test_compare(Application::SUCCESS, touch_app.run(args)); + test_compare(Application::SUCCESS, touch_app.wait()); + + test_compare_hint(0, access(tmp.c_str(), R_OK), strerror(errno)); + test_compare_hint(0, unlink(tmp.c_str()), strerror(errno)); + + return TEST_SUCCESS; +} + +static test_return_t fatal_message_TEST(void *) +{ + test_compare(fatal_calls++, fatal::disabled_counter()); + throw fatal_message("Fatal test"); + + return TEST_SUCCESS; +} + +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()); + + return TEST_SUCCESS; +} + +static test_return_t check_for_gearman(void *) +{ + test_skip(true, HAVE_LIBGEARMAN); + test_skip(true, has_gearmand_binary()); + return TEST_SUCCESS; +} + + test_st gearmand_tests[] ={ #if 0 {"pause", 0, pause_test }, #endif {"gearmand startup-shutdown", 0, gearmand_cycle_test }, + {"_compare(gearman_return_t)", 0, _compare_gearman_return_t_test }, {0, 0, 0} }; +static test_return_t check_for_libmemcached(void *) +{ + test_skip(true, HAVE_LIBMEMCACHED); + test_skip(true, has_memcached_binary()); + return TEST_SUCCESS; +} + test_st memcached_tests[] ={ {"memcached startup-shutdown", 0, memcached_cycle_test }, + {"memcached-light startup-shutdown", 0, memcached_light_cycle_TEST }, {"memcached(socket file) startup-shutdown", 0, memcached_socket_cycle_test }, {"memcached_sasl() startup-shutdown", 0, memcached_sasl_test }, + {"_compare(memcached_return_t)", 0, _compare_memcached_return_t_test }, {0, 0, 0} }; @@ -346,8 +737,82 @@ test_st directories_tests[] ={ test_st comparison_tests[] ={ {"_compare(test_return_t)", 0, _compare_test_return_t_test }, - {"_compare(memcached_return_t)", 0, _compare_memcached_return_t_test }, - {"_compare(gearman_return_t)", 0, _compare_gearman_return_t_test }, + {0, 0, 0} +}; + +test_st cmdline_tests[] ={ + {"true", 0, true_BINARY }, + {"true --fubar", 0, true_fubar_BINARY }, + {"echo fubar", 0, echo_fubar_BINARY }, + {"wait --quiet", 0, wait_BINARY }, + {"wait --quiet --help", 0, wait_help_BINARY }, + {"wait --quiet --version", 0, wait_version_BINARY }, + {"wait --quiet /etc/services", 0, wait_services_BINARY }, + {"wait /etc/services", 0, wait_services_BINARY2 }, + {"wait /etc/services", 0, wait_services_appliction_TEST }, + {"gdb wait /etc/services", 0, gdb_wait_services_appliction_TEST }, + {"gdb abort", 0, gdb_abort_services_appliction_TEST }, + {0, 0, 0} +}; + +test_st get_free_port_TESTS[] ={ + {"get_free_port()", 0, get_free_port_TEST }, + {"default_port()", 0, default_port_TEST }, + {0, 0, 0} +}; + +test_st fatal_message_TESTS[] ={ + {"libtest::fatal", 0, fatal_TEST }, + {"fatal_message()", 0, fatal_message_TEST }, + {0, 0, 0} +}; + +test_st number_of_cpus_TESTS[] ={ + {"libtest::number_of_cpus()", 0, number_of_cpus_TEST }, + {0, 0, 0} +}; + +test_st create_tmpfile_TESTS[] ={ + {"libtest::create_tmpfile()", 0, create_tmpfile_TEST }, + {0, 0, 0} +}; + +test_st application_tests[] ={ + {"vchar_t", 0, vchar_t_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} +}; + +static test_return_t check_for_curl(void *) +{ + test_skip(true, HAVE_LIBCURL); + return TEST_SUCCESS; +} + +static test_return_t disable_fatal_exception(void *) +{ + fatal::disable(); + return TEST_SUCCESS; +} + +static test_return_t enable_fatal_exception(void *) +{ + fatal::disable(); + return TEST_SUCCESS; +} + +test_st http_tests[] ={ + {"GET", 0, GET_TEST }, + {"POST", 0, POST_TEST }, + {"TRACE", 0, TRACE_TEST }, {0, 0, 0} }; @@ -357,8 +822,15 @@ collection_st collection[] ={ {"local", 0, 0, local_log}, {"directories", 0, 0, directories_tests}, {"comparison", 0, 0, comparison_tests}, - {"gearmand", 0, 0, gearmand_tests}, - {"memcached", 0, 0, memcached_tests}, + {"gearmand", check_for_gearman, 0, gearmand_tests}, + {"memcached", check_for_libmemcached, 0, memcached_tests}, + {"cmdline", 0, 0, cmdline_tests}, + {"application", 0, 0, application_tests}, + {"http", check_for_curl, 0, http_tests}, + {"get_free_port()", 0, 0, get_free_port_TESTS }, + {"fatal", disable_fatal_exception, enable_fatal_exception, fatal_message_TESTS }, + {"number_of_cpus()", 0, 0, number_of_cpus_TESTS }, + {"create_tmpfile()", 0, 0, create_tmpfile_TESTS }, {0, 0, 0, 0} };