X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=libtest%2Funittest.cc;h=21dcbc74416bbc3d044ca8e7ef486bbc3be2e907;hb=a18c65b0ee1a4721a4f1298f52f8b3446cf7c600;hp=b2d7df0de6990edfa5e15082ef6984e8fb196b6f;hpb=58c279d58e2a44562f729e93e301dfedf42f530b;p=m6w6%2Flibmemcached diff --git a/libtest/unittest.cc b/libtest/unittest.cc index b2d7df0d..21dcbc74 100644 --- a/libtest/unittest.cc +++ b/libtest/unittest.cc @@ -24,6 +24,14 @@ #include +#if defined(LIBTEST_WITH_LIBMEMCACHED_SUPPORT) && LIBTEST_WITH_LIBMEMCACHED_SUPPORT +#include +#endif + +#if defined(LIBTEST_WITH_LIBGEARMAN_SUPPORT) && LIBTEST_WITH_LIBGEARMAN_SUPPORT +#include +#endif + #include #include @@ -53,6 +61,15 @@ static test_return_t GDB_COMMAND_test(void *) return TEST_SUCCESS; } +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; +} + static test_return_t test_success_test(void *) { return TEST_SUCCESS; @@ -181,20 +198,48 @@ static test_return_t var_log_rm_test(void *) return TEST_SUCCESS; } +static test_return_t _compare_test_return_t_test(void *) +{ + test_compare(TEST_SUCCESS, TEST_SUCCESS); + + return TEST_SUCCESS; +} + +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; +} + +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; +} + 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; - } + const char *argv[1]= { "cycle_gearmand" }; + test_true(server_startup(*servers, "gearmand", get_free_port(), 1, argv)); - return TEST_SKIPPED; + return TEST_SUCCESS; } static test_return_t memcached_cycle_test(void *object) @@ -204,8 +249,9 @@ static test_return_t memcached_cycle_test(void *object) if (MEMCACHED_BINARY and HAVE_LIBMEMCACHED) { + test_true(has_memcached_binary()); const char *argv[1]= { "cycle_memcached" }; - test_true(server_startup(*servers, "memcached", 9998, 1, argv)); + test_true(server_startup(*servers, "memcached", get_free_port(), 1, argv)); return TEST_SUCCESS; } @@ -218,12 +264,16 @@ 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)); - - return TEST_SUCCESS; + if (HAVE_LIBMEMCACHED) + { + test_true(has_memcached_binary()); + const char *argv[1]= { "cycle_memcached" }; + test_true(servers->start_socket_server("memcached", get_free_port(), 1, argv)); + + return TEST_SUCCESS; + } } return TEST_SKIPPED; @@ -239,29 +289,259 @@ 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)); - - return TEST_SUCCESS; + if (HAVE_LIBMEMCACHED) + { + test_true(has_memcached_sasl_binary()); + const char *argv[1]= { "cycle_memcached_sasl" }; + test_true(server_startup(*servers, "memcached-sasl", get_free_port(), 1, argv)); + + 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); + 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(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} }; @@ -274,8 +554,9 @@ test_st environment_tests[] ={ }; test_st tests_log[] ={ - {"TEST_SUCCESS", 0, test_success_test }, - {"TEST_FAILURE", 0, test_failure_test }, + {"TEST_SUCCESS", false, test_success_test }, + {"TEST_FAILURE", false, test_failure_test }, + {"TEST_SUCCESS == 0", false, test_success_equals_one_test }, {0, 0, 0} }; @@ -299,13 +580,64 @@ test_st directories_tests[] ={ {0, 0, 0} }; +test_st comparison_tests[] ={ + {"_compare(test_return_t)", 0, _compare_test_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 }, + {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; +} + +test_st http_tests[] ={ + {"GET", 0, GET_TEST }, + {"POST", 0, POST_TEST }, + {"TRACE", 0, TRACE_TEST }, + {0, 0, 0} +}; + collection_st collection[] ={ {"environment", 0, 0, environment_tests}, {"return values", 0, 0, tests_log}, {"local", 0, 0, local_log}, {"directories", 0, 0, directories_tests}, - {"gearmand", 0, 0, gearmand_tests}, - {"memcached", 0, 0, memcached_tests}, + {"comparison", 0, 0, comparison_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}, {0, 0, 0, 0} };