X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=libtest%2Funittest.cc;h=234743f53907a8cb1d897067116b6fc15b31d064;hb=47f45992107361ad58c170bdf78fdc92523fab06;hp=9945e38690451906f56776d4b522a1a62e86e019;hpb=6dab4c45effc85493d9e097d0df3446e202f3e8e;p=m6w6%2Flibmemcached diff --git a/libtest/unittest.cc b/libtest/unittest.cc index 9945e386..234743f5 100644 --- a/libtest/unittest.cc +++ b/libtest/unittest.cc @@ -1,25 +1,39 @@ /* vim:expandtab:shiftwidth=2:tabstop=2:smarttab: - * - * libtest * - * Copyright (C) 2011 Data Differential, http://datadifferential.com/ + * Data Differential YATL (i.e. libtest) library * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 3 of the License, or (at your option) any later version. + * Copyright (C) 2012 Data Differential, http://datadifferential.com/ * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * + * * The names of its contributors may not be used to endorse or + * promote products derived from this software without specific prior + * written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * - * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ - #include #include @@ -63,7 +77,7 @@ static test_return_t GDB_COMMAND_test(void *) static test_return_t test_success_equals_one_test(void *) { - test_skip(HAVE_LIBMEMCACHED, true); + test_skip(HAVE_LIBMEMCACHED, 1); #if defined(HAVE_LIBMEMCACHED) && HAVE_LIBMEMCACHED test_zero(MEMCACHED_SUCCESS); #endif @@ -110,7 +124,7 @@ static test_return_t local_not_test(void *) } // unsetenv() will cause issues with valgrind - _compare(__FILE__, __LINE__, __func__, 0, unsetenv("LIBTEST_LOCAL")); + _compare(__FILE__, __LINE__, __func__, 0, unsetenv("LIBTEST_LOCAL"), true); test_compare(0, unsetenv("LIBTEST_LOCAL")); test_false(test_is_local()); @@ -154,6 +168,12 @@ static test_return_t var_log_exists_test(void *) return TEST_SUCCESS; } +static test_return_t var_drizzle_exists_test(void *) +{ + test_compare(0, access("var/drizzle", R_OK | W_OK | X_OK)); + return TEST_SUCCESS; +} + static test_return_t var_tmp_test(void *) { FILE *file= fopen("var/tmp/junk", "w+"); @@ -180,6 +200,14 @@ static test_return_t var_log_test(void *) return TEST_SUCCESS; } +static test_return_t var_drizzle_test(void *) +{ + FILE *file= fopen("var/drizzle/junk", "w+"); + test_true(file); + fclose(file); + return TEST_SUCCESS; +} + static test_return_t var_tmp_rm_test(void *) { test_true(unlink("var/tmp/junk") == 0); @@ -198,6 +226,12 @@ static test_return_t var_log_rm_test(void *) return TEST_SUCCESS; } +static test_return_t var_drizzle_rm_test(void *) +{ + test_true(unlink("var/drizzle/junk") == 0); + return TEST_SUCCESS; +} + static test_return_t _compare_test_return_t_test(void *) { test_compare(TEST_SUCCESS, TEST_SUCCESS); @@ -225,17 +259,33 @@ static test_return_t _compare_gearman_return_t_test(void *) return TEST_SUCCESS; } +static test_return_t drizzled_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_drizzled_binary()); +#endif + + test_skip(true, has_drizzled_binary()); + + test_true(server_startup(*servers, "drizzled", get_free_port(), 0, NULL)); + + return TEST_SUCCESS; +} + static test_return_t gearmand_cycle_test(void *object) { server_startup_st *servers= (server_startup_st*)object; - test_true(servers); + test_true(servers and servers->validate()); #if defined(HAVE_GEARMAND_BINARY) && HAVE_GEARMAND_BINARY test_true(has_gearmand_binary()); -#else - test_skip(true, has_gearmand_binary()); #endif + test_skip(true, has_gearmand_binary()); + test_true(server_startup(*servers, "gearmand", get_free_port(), 0, NULL)); return TEST_SUCCESS; @@ -253,6 +303,29 @@ static test_return_t memcached_light_cycle_TEST(void *object) return TEST_SUCCESS; } +static test_return_t skip_shim(bool a, bool b) +{ + test_skip(a, b); + return TEST_SUCCESS; +} + +static test_return_t test_skip_true_TEST(void *object) +{ + test_compare(true, true); + test_compare(false, false); + test_compare(TEST_SUCCESS, skip_shim(true, true)); + test_compare(TEST_SUCCESS, skip_shim(false, false)); + + return TEST_SUCCESS; +} + +static test_return_t test_skip_false_TEST(void *object) +{ + test_compare(TEST_SKIPPED, skip_shim(true, false)); + test_compare(TEST_SKIPPED, skip_shim(false, true)); + return TEST_SUCCESS; +} + static test_return_t memcached_cycle_test(void *object) { server_startup_st *servers= (server_startup_st*)object; @@ -293,10 +366,7 @@ static test_return_t memcached_sasl_test(void *object) server_startup_st *servers= (server_startup_st*)object; test_true(servers); - if (getenv("TESTS_ENVIRONMENT")) - { - return TEST_SKIPPED; - } + test_skip(false, bool(getenv("TESTS_ENVIRONMENT"))); if (MEMCACHED_SASL_BINARY) { @@ -324,6 +394,7 @@ 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(); @@ -335,6 +406,7 @@ 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(); @@ -359,19 +431,19 @@ static test_return_t application_true_fubar_BINARY(void *) static test_return_t application_doesnotexist_BINARY(void *) { + + test_skip_valgrind(); Application true_app("doesnotexist"); + true_app.will_fail(); 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)); - // 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 - { - test_compare(Application::INVALID, true_app.wait()); - } + test_compare(Application::INVALID, true_app.wait(false)); +#endif + test_compare(0, true_app.stdout_result().size()); return TEST_SUCCESS; @@ -442,6 +514,17 @@ static test_return_t vchar_t_TEST(void *) return TEST_SUCCESS; } +static test_return_t vchar_t_compare_neg_TEST(void *) +{ + libtest::vchar_t response; + libtest::vchar_t response2; + libtest::make_vector(response, test_literal_param("fubar\n")); + libtest::make_vector(response2, test_literal_param(__func__)); + test_true(response != response2); + + return TEST_SUCCESS; +} + static test_return_t application_echo_fubar_BINARY(void *) { Application true_app("echo"); @@ -450,6 +533,8 @@ static test_return_t application_echo_fubar_BINARY(void *) test_compare(Application::SUCCESS, true_app.run(args)); test_compare(Application::SUCCESS, true_app.wait()); + while (true_app.slurp() == false) {} ; + libtest::vchar_t response; make_vector(response, test_literal_param("fubar\n")); test_compare(response, true_app.stdout_result()); @@ -464,7 +549,8 @@ static test_return_t application_echo_fubar_BINARY2(void *) true_app.add_option("fubar"); test_compare(Application::SUCCESS, true_app.run()); - test_compare(Application::SUCCESS, true_app.wait()); + test_compare(Application::SUCCESS, true_app.wait(false)); + libtest::vchar_t response; make_vector(response, test_literal_param("fubar\n")); test_compare(response, true_app.stdout_result()); @@ -547,6 +633,7 @@ static test_return_t wait_services_BINARY2(void *) 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 )); libtest::Application wait_app("libtest/wait", true); @@ -561,6 +648,12 @@ static test_return_t wait_services_appliction_TEST(void *) static test_return_t gdb_wait_services_appliction_TEST(void *) { + test_skip(true, false); +#if defined(TARGET_OS_OSX) && TARGET_OS_OSX + test_skip(0, TARGET_OS_OSX); +#endif + + test_skip(0, access("/usr/bin/gdb", X_OK )); test_skip(0, access("/etc/services", R_OK )); libtest::Application wait_app("libtest/wait", true); @@ -575,6 +668,13 @@ static test_return_t gdb_wait_services_appliction_TEST(void *) static test_return_t gdb_abort_services_appliction_TEST(void *) { + test_skip(true, false); + test_skip(0, access("/usr/bin/gdb", X_OK )); + +#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(); @@ -582,6 +682,7 @@ static test_return_t gdb_abort_services_appliction_TEST(void *) test_compare(Application::SUCCESS, abort_app.wait()); 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)); @@ -622,11 +723,13 @@ static test_return_t number_of_cpus_TEST(void *) static test_return_t create_tmpfile_TEST(void *) { std::string tmp= create_tmpfile(__func__); + test_compare(-1, access(tmp.c_str(), R_OK)); + test_compare(-1, access(tmp.c_str(), F_OK)); 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(Application::SUCCESS, touch_app.wait(false)); test_compare_hint(0, access(tmp.c_str(), R_OK), strerror(errno)); test_compare_hint(0, unlink(tmp.c_str()), strerror(errno)); @@ -637,7 +740,7 @@ static test_return_t create_tmpfile_TEST(void *) static test_return_t fatal_message_TEST(void *) { test_compare(fatal_calls++, fatal::disabled_counter()); - throw fatal_message("Fatal test"); + fatal_message("Fatal test"); return TEST_SUCCESS; } @@ -658,6 +761,18 @@ static test_return_t check_for_gearman(void *) return TEST_SUCCESS; } +static test_return_t check_for_drizzle(void *) +{ + test_skip(true, HAVE_LIBDRIZZLE); + test_skip(true, has_drizzled_binary()); + return TEST_SUCCESS; +} + + +test_st drizzled_tests[] ={ + {"drizzled startup-shutdown", 0, drizzled_cycle_test }, + {0, 0, 0} +}; test_st gearmand_tests[] ={ #if 0 @@ -684,6 +799,12 @@ test_st memcached_tests[] ={ {0, 0, 0} }; +test_st test_skip_TESTS[] ={ + {"true, true", 0, test_skip_true_TEST }, + {"true, false", 0, test_skip_false_TEST }, + {0, 0, 0} +}; + test_st environment_tests[] ={ {"LIBTOOL_COMMAND", 0, LIBTOOL_COMMAND_test }, {"VALGRIND_COMMAND", 0, VALGRIND_COMMAND_test }, @@ -710,12 +831,15 @@ test_st directories_tests[] ={ {"var/tmp exists", 0, var_tmp_exists_test }, {"var/run exists", 0, var_run_exists_test }, {"var/log exists", 0, var_log_exists_test }, + {"var/drizzle exists", 0, var_drizzle_exists_test }, {"var/tmp", 0, var_tmp_test }, {"var/run", 0, var_run_test }, {"var/log", 0, var_log_test }, + {"var/drizzle", 0, var_drizzle_test }, {"var/tmp rm", 0, var_tmp_rm_test }, {"var/run rm", 0, var_run_rm_test }, {"var/log rm", 0, var_log_rm_test }, + {"var/drizzle rm", 0, var_drizzle_rm_test }, {0, 0, 0} }; @@ -763,6 +887,7 @@ test_st create_tmpfile_TESTS[] ={ test_st application_tests[] ={ {"vchar_t", 0, vchar_t_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 }, @@ -803,14 +928,17 @@ test_st http_tests[] ={ collection_st collection[] ={ {"environment", 0, 0, environment_tests}, {"return values", 0, 0, tests_log}, + {"test_skip()", 0, 0, test_skip_TESTS }, {"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}, {"cmdline", 0, 0, cmdline_tests}, {"application", 0, 0, application_tests}, {"http", check_for_curl, 0, http_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 },