X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=example%2Ft%2Fmemcached_light.cc;h=9158b1425de8dd34c95d164e66015c7eaa58ed3b;hb=536d248a75fb329a48f06157d2bd8cea2f06f903;hp=ae99651868c1756743b50e688ab54536de29c4e1;hpb=ad5d3efae1a492151ab2b08d370d86d27931c3a9;p=m6w6%2Flibmemcached diff --git a/example/t/memcached_light.cc b/example/t/memcached_light.cc index ae996518..9158b142 100644 --- a/example/t/memcached_light.cc +++ b/example/t/memcached_light.cc @@ -1,8 +1,8 @@ /* vim:expandtab:shiftwidth=2:tabstop=2:smarttab: * - * Test memslap + * Test memcat * - * Copyright (C) 2012 Data Differential, http://datadifferential.com/ + * Copyright (C) 2011 Data Differential, http://datadifferential.com/ * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are @@ -44,91 +44,205 @@ #include #include +#include "tests/libmemcached-1.0/memcached_get.h" + using namespace libtest; #ifndef __INTEL_COMPILER #pragma GCC diagnostic ignored "-Wstrict-aliasing" #endif -static std::string executable; +static std::string executable("example/memcached_light"); static test_return_t help_TEST(void *) { - const char *memcached_light_args[]= { "--help", 0 }; - Application memcached_light_app(executable, true); + const char *args[]= { "--help", 0 }; - test_compare(Application::SUCCESS, memcached_light_app.run(memcached_light_args)); - test_compare(Application::SUCCESS, memcached_light_app.wait()); + test_compare(EXIT_SUCCESS, exec_cmdline(executable, args, true)); return TEST_SUCCESS; } -static test_return_t basic_TEST(void *) +static test_return_t verbose_TEST(void *) { - test_skip(false, true); + const char *args[]= { "--help", "--verbose", 0 }; - char port_buffer[1024]; - snprintf(port_buffer, sizeof(port_buffer), "--port=%d", int(libtest::default_port())); - const char *memcached_light_args[]= { port_buffer, 0 }; - Application memcached_light_app(executable, true); + test_compare(EXIT_SUCCESS, exec_cmdline(executable, args, true)); - test_compare(Application::SUCCESS, memcached_light_app.run(memcached_light_args)); + return TEST_SUCCESS; +} - char instance_buffer[1024]; - int instance_buffer_length= snprintf(instance_buffer, sizeof(instance_buffer), "--BINARY --server=localhost:%d", int(libtest::default_port())); - memcached_st *memc= memcached(instance_buffer, instance_buffer_length); +static test_return_t daemon_TEST(void *) +{ + const char *args[]= { "--help", "--daemon", 0 }; -#if 0 - for (size_t x= 0; x < 24; x++) - { - char id_buffer[1024]; - int length= snprintf(id_buffer, sizeof(id_buffer), "%u", uint32_t(x)); - test_compare_hint(MEMCACHED_NOTFOUND, memcached_delete(memc, id_buffer, length, 0), - id_buffer); - } -#endif + test_compare(EXIT_SUCCESS, exec_cmdline(executable, args, true)); + + return TEST_SUCCESS; +} - // We fail since we are just outright killing it. - test_compare(Application::FAILURE, memcached_light_app.wait()); +static test_return_t protocol_TEST(void *) +{ + const char *args[]= { "--help", "--protocol", 0 }; - memcached_free(memc); + test_compare(EXIT_SUCCESS, exec_cmdline(executable, args, true)); + + return TEST_SUCCESS; +} + +static test_return_t version_TEST(void *) +{ + const char *args[]= { "--help", "--version", 0 }; + + test_compare(EXIT_SUCCESS, exec_cmdline(executable, args, true)); return TEST_SUCCESS; } -test_st help_TESTS[] ={ +static test_return_t port_TEST(void *) +{ + const char *args[]= { "--help", "--port=9090", 0 }; + + test_compare(EXIT_SUCCESS, exec_cmdline(executable, args, true)); + + return TEST_SUCCESS; +} + +static test_return_t pid_file_TEST(void *) +{ + const char *args[]= { "--help", "--pid-file=/tmp/foo.pid", 0 }; + + test_compare(EXIT_SUCCESS, exec_cmdline(executable, args, true)); + + return TEST_SUCCESS; +} + +static test_return_t log_file_TEST(void *) +{ + const char *args[]= { "--help", "--log-file=/tmp/foo.log", 0 }; + + test_compare(EXIT_SUCCESS, exec_cmdline(executable, args, true)); + + return TEST_SUCCESS; +} + +static test_return_t max_connections_file_TEST(void *) +{ + const char *args[]= { "--help", "--max-connections=/tmp/foo.max_connections", 0 }; + + test_compare(EXIT_SUCCESS, exec_cmdline(executable, args, true)); + + return TEST_SUCCESS; +} + +typedef test_return_t (*libmemcached_test_callback_fn)(memcached_st *); + +static test_return_t _runner_default(libmemcached_test_callback_fn func, void *object) +{ + if (func) + { + test_true(object); + test_return_t ret; + try { + ret= func((memcached_st*)object); + } + catch (std::exception& e) + { + libtest::Error << e.what(); + return TEST_FAILURE; + } + + return ret; + } + + return TEST_SUCCESS; +} + +class MemcachedLightRunner : public libtest::Runner { +public: + test_return_t run(test_callback_fn* func, void *object) + { + return _runner_default(libmemcached_test_callback_fn(func), object); + } +}; + +test_st cmdline_option_TESTS[] ={ {"--help", true, help_TEST }, + {"--verbose", true, verbose_TEST }, + {"--daemon", true, daemon_TEST }, + {"--protocol", true, protocol_TEST }, + {"--version", true, version_TEST }, + {"--port", true, port_TEST }, + {"--pid-file", true, pid_file_TEST }, + {"--log-file", true, log_file_TEST }, + {"--max-connections", true, max_connections_file_TEST }, {0, 0, 0} }; +/* Clean the server before beginning testing */ test_st basic_TESTS[] ={ - {"--port", true, basic_TEST }, +#if 0 + {"memcached_get()", true, (test_callback_fn*)get_test }, + {"memcached_get() test 2", false, (test_callback_fn*)get_test2 }, + {"memcached_get() test 3", false, (test_callback_fn*)get_test3 }, + {"memcached_get() test 4", false, (test_callback_fn*)get_test4 }, + {"memcached_get() test 5", false, (test_callback_fn*)get_test5 }, +#endif {0, 0, 0} }; collection_st collection[] ={ - {"--help", 0, 0, help_TESTS }, - {"basics", 0, 0, basic_TESTS }, + {"command line options", 0, 0, cmdline_option_TESTS }, + {"basic", 0, 0, basic_TESTS }, {0, 0, 0, 0} }; static void *world_create(server_startup_st& servers, test_return_t& error) { - if (HAVE_MEMCACHED_BINARY == 0) + if (access(executable.c_str(), X_OK) != 0) + { + error= TEST_SKIPPED; + return NULL; + } + + if (HAVE_MEMCACHED_LIGHT_BINARY == 0) { error= TEST_SKIPPED; return NULL; } - return &servers; + if (server_startup(servers, "memcached-light", libtest::default_port(), 0, NULL) == 0) + { + error= TEST_FAILURE; + return NULL; + } + + + char buffer[1024]; + int length= snprintf(buffer, sizeof(buffer), "--server=localhost:%d", int(libtest::default_port())); + fatal_assert(length > 0); + + memcached_st *memc= memcached(buffer, length); + + fatal_assert(memc); + + return (void*)memc; +} + +static bool world_destroy(void *object) +{ + memcached_st *memc= (memcached_st*)object; + memcached_free(memc); + + return TEST_SUCCESS; } void get_world(Framework *world) { - executable= "./example/memcached_light"; - world->collections= collection; - world->_create= world_create; + world->create(world_create); + world->destroy(world_destroy); + world->collections(collection); + world->set_runner(new MemcachedLightRunner); } -