X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;ds=sidebyside;f=libtest%2Funittest.cc;h=33309a7c1fc216f18a37411901efde3b67d68654;hb=8cc058d16abc8b75b675173c6c416c5ac7a30849;hp=93192a255b17d7ba82dbd560458dc4d96f404436;hpb=0ccec3ba6ce515f61e5d0b3c0a07220646c85e40;p=m6w6%2Flibmemcached diff --git a/libtest/unittest.cc b/libtest/unittest.cc index 93192a25..33309a7c 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 @@ -64,7 +64,9 @@ static test_return_t GDB_COMMAND_test(void *) static test_return_t test_success_equals_one_test(void *) { test_skip(HAVE_LIBMEMCACHED, true); +#if defined(HAVE_LIBMEMCACHED) && HAVE_LIBMEMCACHED test_zero(MEMCACHED_SUCCESS); +#endif return TEST_SUCCESS; } @@ -206,7 +208,9 @@ 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); +#endif return TEST_SUCCESS; } @@ -214,6 +218,9 @@ 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); +#endif return TEST_SUCCESS; } @@ -223,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) @@ -241,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; } @@ -255,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; @@ -276,29 +298,296 @@ 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_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_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 application_wait_services_BINARY2(void *) +{ + test_skip(0, access("/etc/services", R_OK )); + + libtest::Application("libtest/wait", true); + const char *args[]= { "/etc/services", 0 }; + + test_compare(EXIT_SUCCESS, exec_cmdline("libtest/wait", args, true)); + + 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 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} }; @@ -339,8 +628,71 @@ 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 }, + {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 application_tests[] ={ + {"vchar_t", 0, vchar_t_TEST }, + {"true", 0, application_true_BINARY }, + {"true --fubar", 0, application_true_fubar_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} }; @@ -350,8 +702,14 @@ 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 }, {0, 0, 0, 0} };