From: Michael Wallner Date: Tue, 13 Oct 2020 09:56:03 +0000 (+0200) Subject: testing: parser X-Git-Tag: 1.1.0-beta1~236^2~6 X-Git-Url: https://git.m6w6.name/?a=commitdiff_plain;h=2dd79b61ec7944b82ec6b576cc081603ec526049;p=awesomized%2Flibmemcached testing: parser --- diff --git a/test/fixtures/parser.hpp b/test/fixtures/parser.hpp new file mode 100644 index 00000000..2c72302d --- /dev/null +++ b/test/fixtures/parser.hpp @@ -0,0 +1,200 @@ +#pragma once + +#include +#include +#include + +using namespace std; + +struct c_string { + const char *c_str; + size_t size; + + c_string(const char *s, size_t l) noexcept + : c_str{s} + , size{l} + {} + bool operator ==(const c_string &cs) const noexcept { + return !strcmp(c_str, cs.c_str); + } + bool operator ==(const char *p) const noexcept { + return !strcmp(c_str, p); + } +}; + +static c_string null_c_string{nullptr, 0}; + +struct test_case { + using setting_key_t = variant; + using setting_t = pair; + using result_t = variant; + c_string option; + result_t result; + + test_case(c_string o, c_string r) noexcept + : option{o} + , result{r} + {} + test_case(const char *os, size_t ol, const char *rs, size_t rl) noexcept + : option{os, ol} + , result{c_string{rs, rl}} + {} + test_case(const char *os, size_t ol, memcached_behavior_t b, uint64_t v) noexcept + : option{os, ol} + , result{setting_t{b, v}} + {} + test_case(const char *os, size_t ol, memcached_flag_t f, uint64_t v) noexcept + : option{os, ol} + , result{setting_t{f, v}} + {} +}; + +#define test_count(tca) (sizeof(tca)/sizeof(tca[0])) + +struct test_group { + using check_func = function; + const char *name; + check_func check; + test_case *tests; + size_t ntests; + + test_group(const char *name_, check_func check_, test_case *tests_, size_t ntests_) noexcept + : name{name_} + , check{move(check_)} + , tests{tests_} + , ntests{ntests_} + {} +}; + +static test_case host_string_tests[] = { + {S("--server=localhost"), S("localhost")}, + {S("--server=10.0.2.1"), S("10.0.2.1")}, + {S("--server=example.com"), S("example.com")}, + {S("--server=localhost:30"), S("localhost")}, + {S("--server=10.0.2.1:20"), S("10.0.2.1")}, + {S("--server=example.com:1024"), S("example.com")}, + {S("--server=10.0.2.1:30/?40"), S("10.0.2.1")}, + {S("--server=example.com:1024/?30"), S("example.com")}, + {S("--server=10.0.2.1/?20"), S("10.0.2.1")}, + {S("--server=example.com/?10"), S("example.com")}, +}; + +static test_group test_host_strings{ + "host strings", + [](memcached_st *memc, const test_case::result_t &result) { + auto instance = memcached_server_instance_by_position(memc, 0); + REQUIRE(instance); + REQUIRE(get(result) == memcached_server_name(instance)); + }, + host_string_tests, + test_count(host_string_tests) +}; + +static test_case bad_host_string_tests[] = { + {{S("-servers=localhost:11221,localhost:11222,localhost:11223,localhost:11224,localhost:11225")}, null_c_string}, + {{S("-- servers=a.example.com:81,localhost:82,b.example.com")}, null_c_string}, + {{S("--servers=localhost:+80")}, null_c_string}, + // all of the following should not fail IMO + {{S("--servers=localhost.com.")}, null_c_string}, + {{S("--server=localhost.com.")}, null_c_string}, + {{S("--server=localhost.com.:80")}, null_c_string}, +}; + +static test_group test_bad_host_strings{ + "bad host strings", + [](memcached_st *memc, const test_case::result_t &) { + REQUIRE_FALSE(memc); + }, + bad_host_string_tests, + test_count(bad_host_string_tests) +}; + +static test_case behavior_tests[] = { + {S("--CONNECT-TIMEOUT=456"), MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT, 456}, + {S("--IO-BYTES-WATERMARK=456"), MEMCACHED_BEHAVIOR_IO_BYTES_WATERMARK, 456}, + {S("--IO-KEY-PREFETCH=456"), MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH, 456}, + {S("--IO-MSG-WATERMARK=456"), MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK, 456}, + {S("--NUMBER-OF-REPLICAS=456"), MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, 456}, + {S("--POLL-TIMEOUT=456"), MEMCACHED_BEHAVIOR_POLL_TIMEOUT, 456}, + {S("--RCV-TIMEOUT=456"), MEMCACHED_BEHAVIOR_RCV_TIMEOUT, 456}, + {S("--REMOVE-FAILED-SERVERS=3"), MEMCACHED_BEHAVIOR_REMOVE_FAILED_SERVERS, 1}, + {S("--RETRY-TIMEOUT=456"), MEMCACHED_BEHAVIOR_RETRY_TIMEOUT, 456}, + {S("--SND-TIMEOUT=456"), MEMCACHED_BEHAVIOR_SND_TIMEOUT, 456}, + {S("--SOCKET-RECV-SIZE=456"), MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE, 456}, + {S("--SOCKET-SEND-SIZE=456"), MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE, 456}, + {S("--BINARY-PROTOCOL"), MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1}, + {S("--BUFFER-REQUESTS"), MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 1}, + {S("--NOREPLY"), MEMCACHED_BEHAVIOR_NOREPLY, 1}, + {S("--RANDOMIZE-REPLICA-READ"), MEMCACHED_BEHAVIOR_RANDOMIZE_REPLICA_READ, 1}, + {S("--SORT-HOSTS"), MEMCACHED_BEHAVIOR_SORT_HOSTS, 1}, + {S("--SUPPORT-CAS"), MEMCACHED_BEHAVIOR_SUPPORT_CAS, 1}, + {S("--TCP-NODELAY"), MEMCACHED_BEHAVIOR_TCP_NODELAY, 1}, + {S("--TCP-KEEPALIVE"), MEMCACHED_BEHAVIOR_TCP_KEEPALIVE, 1}, + {S("--TCP-KEEPIDLE"), MEMCACHED_BEHAVIOR_TCP_KEEPIDLE, 1}, + {S("--USE-UDP"), MEMCACHED_BEHAVIOR_USE_UDP, 1}, + {S("--VERIFY-KEY"), MEMCACHED_BEHAVIOR_VERIFY_KEY, 1}, + {S("--DISTRIBUTION=consistent"), MEMCACHED_BEHAVIOR_DISTRIBUTION, MEMCACHED_DISTRIBUTION_CONSISTENT}, + {S("--DISTRIBUTION=consistent,CRC"), MEMCACHED_BEHAVIOR_DISTRIBUTION, MEMCACHED_DISTRIBUTION_CONSISTENT}, + {S("--DISTRIBUTION=consistent,MD5"), MEMCACHED_BEHAVIOR_DISTRIBUTION, MEMCACHED_DISTRIBUTION_CONSISTENT}, + {S("--DISTRIBUTION=consistent,JENKINS"), MEMCACHED_BEHAVIOR_KETAMA_HASH, MEMCACHED_HASH_JENKINS}, + {S("--DISTRIBUTION=random"), MEMCACHED_BEHAVIOR_DISTRIBUTION, MEMCACHED_DISTRIBUTION_RANDOM}, + {S("--DISTRIBUTION=modula"), MEMCACHED_BEHAVIOR_DISTRIBUTION, MEMCACHED_DISTRIBUTION_MODULA}, + {S("--HASH=CRC"), MEMCACHED_BEHAVIOR_HASH, MEMCACHED_HASH_CRC}, + {S("--HASH=FNV1A_32"), MEMCACHED_BEHAVIOR_HASH, MEMCACHED_HASH_FNV1A_32}, + {S("--HASH=FNV1_32"), MEMCACHED_BEHAVIOR_HASH, MEMCACHED_HASH_FNV1_32}, + {S("--HASH=JENKINS"), MEMCACHED_BEHAVIOR_HASH, MEMCACHED_HASH_JENKINS}, + {S("--HASH=MD5"), MEMCACHED_BEHAVIOR_HASH, MEMCACHED_HASH_MD5}, + +}; + +static test_group test_behaviors{ + "behaviors", + [](memcached_st *memc, const test_case::result_t &result) { + auto setting = get(result); + REQUIRE(memc); + REQUIRE(setting.second == + memcached_behavior_get(memc, get(setting.first))); + }, + behavior_tests, + test_count(behavior_tests) +}; + +static test_case flag_tests[] = { + {S("--FETCH-VERSION"), MEMCACHED_FLAG_IS_FETCHING_VERSION, 1}, + {S("--HASH-WITH-NAMESPACE"), MEMCACHED_FLAG_HASH_WITH_NAMESPACE, 1}, +}; + +static test_group test_flags{ + "flags", + [](memcached_st *memc, const test_case::result_t &result) { + auto setting = get(result); + REQUIRE(memc); + REQUIRE(setting.second == memcached_flag(*memc, get(setting.first))); + }, + flag_tests, + test_count(flag_tests) +}; + +static test_case namespace_tests[] = { + {S("--NAMESPACE=foo"), S("foo")}, + {S("--NAMESPACE=\"foo\""), S("foo")}, + {S("--NAMESPACE=\"The quick brown fox jumps over the lazy dog\""), S("The quick brown fox jumps over the lazy dog")}, +}; + +static test_group test_namespace{ + "namespace", + [](memcached_st *memc, const test_case::result_t &result) { + auto ns = get(result); + REQUIRE(memc); + REQUIRE(ns == memcached_get_namespace(*memc)); + }, + namespace_tests, + test_count(namespace_tests) +}; + +static test_group tests[] = { + test_host_strings, + test_bad_host_strings, + test_behaviors, + test_flags, +}; diff --git a/test/lib/env.hpp b/test/lib/env.hpp index 814e2a15..105fef5d 100644 --- a/test/lib/env.hpp +++ b/test/lib/env.hpp @@ -1,3 +1,5 @@ +#pragma once + #include "mem_config.h" #include diff --git a/test/tests/memcached/parser.cpp b/test/tests/memcached/parser.cpp index ca7fa400..20fbed41 100644 --- a/test/tests/memcached/parser.cpp +++ b/test/tests/memcached/parser.cpp @@ -1,6 +1,9 @@ #include "test/lib/common.hpp" #include "test/lib/env.hpp" +#include "libmemcached/common.h" +#include "test/fixtures/parser.hpp" + TEST_CASE("memcached_parser") { SECTION("fail: null string") { REQUIRE_FALSE(memcached(nullptr, 123)); @@ -31,4 +34,18 @@ TEST_CASE("memcached_parser") { REQUIRE_FALSE(memcached(nullptr, 0)); } } + + SECTION("fixtures") { + for (const auto &test : tests) { + DYNAMIC_SECTION(test.name) { + for (size_t i = 0; i < test.ntests; ++i) { + auto &tc = test.tests[i]; + DYNAMIC_SECTION(tc.option.c_str) { + MemcachedPtr memc(memcached(tc.option.c_str, tc.option.size)); + test.check(*memc, tc.result); + } + } + } + } + } } diff --git a/tests/libmemcached-1.0/parser.cc b/tests/libmemcached-1.0/parser.cc deleted file mode 100644 index b5204a83..00000000 --- a/tests/libmemcached-1.0/parser.cc +++ /dev/null @@ -1,782 +0,0 @@ -/* vim:expandtab:shiftwidth=2:tabstop=2:smarttab: - * - * Libmemcached Client and Server - * - * Copyright (C) 2011 Data Differential, http://datadifferential.com/ - * All rights reserved. - * - * 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. - * - */ - -#include "mem_config.h" -#include "libtest/test.hpp" - -using namespace libtest; - -#include -#include -#include - -#include "libmemcached-1.0/memcached.h" -#include "libmemcachedutil-1.0/util.h" - -#include "tests/libmemcached-1.0/parser.h" -#include "tests/print.h" -#include "libmemcached/instance.hpp" - -enum scanner_type_t -{ - NIL, - UNSIGNED, - SIGNED, - ARRAY -}; - - -struct scanner_string_st { - const char *c_str; - size_t size; -}; - -static inline scanner_string_st scanner_string(const char *arg, size_t arg_size) -{ - scanner_string_st local= { arg, arg_size }; - return local; -} - -#define make_scanner_string(X) scanner_string((X), static_cast(sizeof(X) - 1)) - -static struct scanner_string_st scanner_string_null= { 0, 0}; - -struct scanner_variable_t { - enum scanner_type_t type; - struct scanner_string_st option; - struct scanner_string_st result; - test_return_t (*check_func)(memcached_st *memc, const scanner_string_st &hostname); -}; - -// Check and make sure the first host is what we expect it to be -static test_return_t __check_host(memcached_st *memc, const scanner_string_st &hostname) -{ - const memcached_instance_st * instance= - memcached_server_instance_by_position(memc, 0); - - test_true(instance); - - const char *first_hostname = memcached_server_name(instance); - test_true(first_hostname); - test_strcmp(first_hostname, hostname.c_str); - - return TEST_SUCCESS; -} - -// Check and make sure the prefix_key is what we expect it to be -static test_return_t __check_namespace(memcached_st *, const scanner_string_st &) -{ -#if 0 - const char *_namespace = memcached_get_namespace(memc); - test_true(_namespace); - test_strcmp(_namespace, arg.c_str); -#endif - - return TEST_SUCCESS; -} - -static test_return_t __check_IO_MSG_WATERMARK(memcached_st *memc, const scanner_string_st &value) -{ - uint64_t value_number; - - value_number= atoll(value.c_str); - - test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK) == value_number); - return TEST_SUCCESS; -} - -static test_return_t __check_REMOVE_FAILED_SERVERS(memcached_st *memc, const scanner_string_st &) -{ - test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_REMOVE_FAILED_SERVERS)); - return TEST_SUCCESS; -} - -static test_return_t __check_NOREPLY(memcached_st *memc, const scanner_string_st &) -{ - test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NOREPLY)); - return TEST_SUCCESS; -} - -static test_return_t __check_VERIFY_KEY(memcached_st *memc, const scanner_string_st &) -{ - test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_VERIFY_KEY)); - return TEST_SUCCESS; -} - -static test_return_t __check_distribution_RANDOM(memcached_st *memc, const scanner_string_st &) -{ - test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION) == MEMCACHED_DISTRIBUTION_RANDOM); - return TEST_SUCCESS; -} - -scanner_variable_t test_server_strings[]= { - { ARRAY, make_scanner_string("--server=localhost"), make_scanner_string("localhost"), __check_host }, - { ARRAY, make_scanner_string("--server=10.0.2.1"), make_scanner_string("10.0.2.1"), __check_host }, - { ARRAY, make_scanner_string("--server=example.com"), make_scanner_string("example.com"), __check_host }, - { ARRAY, make_scanner_string("--server=localhost:30"), make_scanner_string("localhost"), __check_host }, - { ARRAY, make_scanner_string("--server=10.0.2.1:20"), make_scanner_string("10.0.2.1"), __check_host }, - { ARRAY, make_scanner_string("--server=example.com:1024"), make_scanner_string("example.com"), __check_host }, - { NIL, scanner_string_null, scanner_string_null, NULL } -}; - -scanner_variable_t test_server_strings_with_weights[]= { - { ARRAY, make_scanner_string("--server=10.0.2.1:30/?40"), make_scanner_string("10.0.2.1"), __check_host }, - { ARRAY, make_scanner_string("--server=example.com:1024/?30"), make_scanner_string("example.com"), __check_host }, - { ARRAY, make_scanner_string("--server=10.0.2.1/?20"), make_scanner_string("10.0.2.1"), __check_host }, - { ARRAY, make_scanner_string("--server=example.com/?10"), make_scanner_string("example.com"), __check_host }, - { NIL, scanner_string_null, scanner_string_null, NULL } -}; - -scanner_variable_t bad_test_strings[]= { - { ARRAY, make_scanner_string("-servers=localhost:11221,localhost:11222,localhost:11223,localhost:11224,localhost:11225"), scanner_string_null, NULL }, - { ARRAY, make_scanner_string("-- servers=a.example.com:81,localhost:82,b.example.com"), scanner_string_null, NULL }, - { ARRAY, make_scanner_string("--servers=localhost:+80"), scanner_string_null, NULL}, - { ARRAY, make_scanner_string("--servers=localhost.com."), scanner_string_null, NULL}, - { ARRAY, make_scanner_string("--server=localhost.com."), scanner_string_null, NULL}, - { ARRAY, make_scanner_string("--server=localhost.com.:80"), scanner_string_null, NULL}, - { NIL, scanner_string_null, scanner_string_null, NULL} -}; - -scanner_variable_t test_number_options[]= { - { ARRAY, make_scanner_string("--CONNECT-TIMEOUT=456"), scanner_string_null, NULL }, - { ARRAY, make_scanner_string("--IO-BYTES-WATERMARK=456"), scanner_string_null, NULL }, - { ARRAY, make_scanner_string("--IO-KEY-PREFETCH=456"), scanner_string_null, NULL }, - { ARRAY, make_scanner_string("--IO-MSG-WATERMARK=456"), make_scanner_string("456"), __check_IO_MSG_WATERMARK }, - { ARRAY, make_scanner_string("--NUMBER-OF-REPLICAS=456"), scanner_string_null, NULL }, - { ARRAY, make_scanner_string("--POLL-TIMEOUT=456"), scanner_string_null, NULL }, - { ARRAY, make_scanner_string("--RCV-TIMEOUT=456"), scanner_string_null, NULL }, - { ARRAY, make_scanner_string("--REMOVE-FAILED-SERVERS=3"), scanner_string_null, __check_REMOVE_FAILED_SERVERS }, - { ARRAY, make_scanner_string("--RETRY-TIMEOUT=456"), scanner_string_null, NULL }, - { ARRAY, make_scanner_string("--SND-TIMEOUT=456"), scanner_string_null, NULL }, - { ARRAY, make_scanner_string("--SOCKET-RECV-SIZE=456"), scanner_string_null, NULL }, - { ARRAY, make_scanner_string("--SOCKET-SEND-SIZE=456"), scanner_string_null, NULL }, - { NIL, scanner_string_null, scanner_string_null, NULL} -}; - -scanner_variable_t test_boolean_options[]= { - { ARRAY, make_scanner_string("--FETCH-VERSION"), scanner_string_null, NULL }, - { ARRAY, make_scanner_string("--BINARY-PROTOCOL"), scanner_string_null, NULL }, - { ARRAY, make_scanner_string("--BUFFER-REQUESTS"), scanner_string_null, NULL }, - { ARRAY, make_scanner_string("--HASH-WITH-NAMESPACE"), scanner_string_null, NULL }, - { ARRAY, make_scanner_string("--NOREPLY"), scanner_string_null, __check_NOREPLY }, - { ARRAY, make_scanner_string("--RANDOMIZE-REPLICA-READ"), scanner_string_null, NULL }, - { ARRAY, make_scanner_string("--SORT-HOSTS"), scanner_string_null, NULL }, - { ARRAY, make_scanner_string("--SUPPORT-CAS"), scanner_string_null, NULL }, - { ARRAY, make_scanner_string("--TCP-NODELAY"), scanner_string_null, NULL }, - { ARRAY, make_scanner_string("--TCP-KEEPALIVE"), scanner_string_null, NULL }, - { ARRAY, make_scanner_string("--TCP-KEEPIDLE"), scanner_string_null, NULL }, - { ARRAY, make_scanner_string("--USE-UDP"), scanner_string_null, NULL }, - { ARRAY, make_scanner_string("--VERIFY-KEY"), scanner_string_null, __check_VERIFY_KEY }, - { NIL, scanner_string_null, scanner_string_null, NULL} -}; - -scanner_variable_t namespace_strings[]= { - { ARRAY, make_scanner_string("--NAMESPACE=foo"), make_scanner_string("foo"), __check_namespace }, - { ARRAY, make_scanner_string("--NAMESPACE=\"foo\""), make_scanner_string("foo"), __check_namespace }, - { ARRAY, make_scanner_string("--NAMESPACE=\"This_is_a_very_long_key\""), make_scanner_string("This_is_a_very_long_key"), __check_namespace }, - { NIL, scanner_string_null, scanner_string_null, NULL} -}; - -scanner_variable_t distribution_strings[]= { - { ARRAY, make_scanner_string("--DISTRIBUTION=consistent"), scanner_string_null, NULL }, - { ARRAY, make_scanner_string("--DISTRIBUTION=consistent,CRC"), scanner_string_null, NULL }, - { ARRAY, make_scanner_string("--DISTRIBUTION=consistent,MD5"), scanner_string_null, NULL }, - { ARRAY, make_scanner_string("--DISTRIBUTION=random"), scanner_string_null, __check_distribution_RANDOM }, - { ARRAY, make_scanner_string("--DISTRIBUTION=modula"), scanner_string_null, NULL }, - { NIL, scanner_string_null, scanner_string_null, NULL} -}; - -scanner_variable_t hash_strings[]= { - { ARRAY, make_scanner_string("--HASH=CRC"), scanner_string_null, NULL }, - { ARRAY, make_scanner_string("--HASH=FNV1A_32"), scanner_string_null, NULL }, - { ARRAY, make_scanner_string("--HASH=FNV1_32"), scanner_string_null, NULL }, -#if 0 - { ARRAY, make_scanner_string("--HASH=JENKINS"), scanner_string_null, NULL }, -#endif - { ARRAY, make_scanner_string("--HASH=MD5"), scanner_string_null, NULL }, - { NIL, scanner_string_null, scanner_string_null, NULL} -}; - - -static test_return_t _test_option(scanner_variable_t *scanner, bool test_true_opt= true) -{ - for (scanner_variable_t *ptr= scanner; ptr->type != NIL; ptr++) - { - memcached_st *memc= memcached(ptr->option.c_str, ptr->option.size); - - // The case that it should have parsed, but it didn't. We will inspect for - // an error with libmemcached_check_configuration() - if (memc == NULL and test_true_opt) - { - char buffer[2048]; - bool success= libmemcached_check_configuration(ptr->option.c_str, ptr->option.size, buffer, sizeof(buffer)); - - std::string temp(buffer); - temp+= " with option string:"; - temp+= ptr->option.c_str; - test_true_got(success, temp.c_str()); - Error << "Failed for " << temp; - - return TEST_FAILURE; // The line above should fail since memc should be null - } - - if (test_true_opt) - { - if (ptr->check_func) - { - test_return_t test_rc= (*ptr->check_func)(memc, ptr->result); - if (test_rc != TEST_SUCCESS) - { - memcached_free(memc); - return test_rc; - } - } - - memcached_free(memc); - } - else - { - test_false_with(memc, ptr->option.c_str); - } - } - - return TEST_SUCCESS; -} - -test_return_t server_test(memcached_st *) -{ - return _test_option(test_server_strings); -} - -test_return_t server_with_weight_test(memcached_st *) -{ - return _test_option(test_server_strings_with_weights); -} - -test_return_t servers_bad_test(memcached_st *) -{ - test_return_t rc; - if ((rc= _test_option(bad_test_strings, false)) != TEST_SUCCESS) - { - return rc; - } - - return TEST_SUCCESS; -} - -test_return_t parser_number_options_test(memcached_st*) -{ - return _test_option(test_number_options); -} - -test_return_t parser_boolean_options_test(memcached_st*) -{ - return _test_option(test_boolean_options); -} - -test_return_t behavior_parser_test(memcached_st*) -{ - return TEST_SUCCESS; -} - -test_return_t parser_hash_test(memcached_st*) -{ - return _test_option(hash_strings); -} - -test_return_t parser_distribution_test(memcached_st*) -{ - return _test_option(distribution_strings); -} - -test_return_t parser_key_prefix_test(memcached_st*) -{ - return _test_option(distribution_strings); -} - -test_return_t test_namespace_keyword(memcached_st*) -{ - return _test_option(namespace_strings); -} - -#define SUPPORT_EXAMPLE_CNF "support/example.cnf" - -test_return_t memcached_create_with_options_with_filename(memcached_st*) -{ - test_skip(0, access(SUPPORT_EXAMPLE_CNF, R_OK)); - - memcached_st *memc_ptr= memcached(test_literal_param("--CONFIGURE-FILE=\"support/example.cnf\"")); - test_true_got(memc_ptr, "memcached() failed"); - memcached_free(memc_ptr); - - return TEST_SUCCESS; -} - -test_return_t libmemcached_check_configuration_with_filename_test(memcached_st*) -{ - test_skip(0, access(SUPPORT_EXAMPLE_CNF, R_OK)); - - char buffer[BUFSIZ]; - - test_compare_hint(MEMCACHED_SUCCESS, - libmemcached_check_configuration(test_literal_param("--CONFIGURE-FILE=\"support/example.cnf\""), buffer, sizeof(buffer)), - buffer); - - test_compare_hint(MEMCACHED_PARSE_ERROR, - libmemcached_check_configuration(test_literal_param("--CONFIGURE-FILE=support/example.cnf"), buffer, sizeof(buffer)), - buffer); - - test_compare_hint(MEMCACHED_ERRNO, - libmemcached_check_configuration(test_literal_param("--CONFIGURE-FILE=\"bad-path/example.cnf\""), buffer, sizeof(buffer)), - buffer) ; - - return TEST_SUCCESS; -} - -test_return_t libmemcached_check_configuration_test(memcached_st*) -{ - char buffer[BUFSIZ]; - test_compare(MEMCACHED_SUCCESS, - libmemcached_check_configuration(test_literal_param("--server=localhost"), buffer, sizeof(buffer))); - - test_compare_hint(MEMCACHED_PARSE_ERROR, - libmemcached_check_configuration(test_literal_param("--dude=localhost"), buffer, sizeof(buffer)), - buffer); - - return TEST_SUCCESS; -} - -test_return_t memcached_create_with_options_test(memcached_st*) -{ - { - memcached_st *memc_ptr; - memc_ptr= memcached(test_literal_param("--server=localhost")); - test_true_got(memc_ptr, memcached_last_error_message(memc_ptr)); - memcached_free(memc_ptr); - } - - { - memcached_st *memc_ptr= memcached(test_literal_param("--dude=localhost")); - test_false_with(memc_ptr, memcached_last_error_message(memc_ptr)); - } - - return TEST_SUCCESS; -} - -test_return_t test_include_keyword(memcached_st*) -{ - test_skip(0, access(SUPPORT_EXAMPLE_CNF, R_OK)); - - char buffer[BUFSIZ]; - test_compare(MEMCACHED_SUCCESS, - libmemcached_check_configuration(test_literal_param("INCLUDE \"support/example.cnf\""), buffer, sizeof(buffer))); - - return TEST_SUCCESS; -} - -test_return_t test_end_keyword(memcached_st*) -{ - char buffer[BUFSIZ]; - test_compare(MEMCACHED_SUCCESS, - libmemcached_check_configuration(test_literal_param("--server=localhost END bad keywords"), buffer, sizeof(buffer))); - - return TEST_SUCCESS; -} - -test_return_t test_reset_keyword(memcached_st*) -{ - char buffer[BUFSIZ]; - test_compare(MEMCACHED_SUCCESS, - libmemcached_check_configuration(test_literal_param("--server=localhost reset --server=bad.com"), buffer, sizeof(buffer))); - - return TEST_SUCCESS; -} - -test_return_t test_error_keyword(memcached_st*) -{ - char buffer[BUFSIZ]; - memcached_return_t rc; - rc= libmemcached_check_configuration(test_literal_param("--server=localhost ERROR --server=bad.com"), buffer, sizeof(buffer)); - test_true_got(rc != MEMCACHED_SUCCESS, buffer); - - return TEST_SUCCESS; -} - -#define RANDOM_STRINGS 1000 -test_return_t random_statement_build_test(memcached_st*) -{ - std::vector option_list; - - for (scanner_variable_t *ptr= test_server_strings; ptr->type != NIL; ptr++) - option_list.push_back(&ptr->option); - - for (scanner_variable_t *ptr= test_number_options; ptr->type != NIL; ptr++) - option_list.push_back(&ptr->option); - - for (scanner_variable_t *ptr= test_boolean_options; ptr->type != NIL; ptr++) - option_list.push_back(&ptr->option); - - for (scanner_variable_t *ptr= namespace_strings; ptr->type != NIL; ptr++) - option_list.push_back(&ptr->option); - - for (scanner_variable_t *ptr= distribution_strings; ptr->type != NIL; ptr++) - option_list.push_back(&ptr->option); - - for (scanner_variable_t *ptr= hash_strings; ptr->type != NIL; ptr++) - option_list.push_back(&ptr->option); - - std::vector used_list; - used_list.resize(option_list.size()); - - struct used_options_st { - bool has_hash; - bool has_namespace; - bool has_distribution; - bool has_buffer_requests; - bool has_udp; - bool has_binary; - bool has_verify_key; - - used_options_st() : - has_hash(false), - has_namespace(false), - has_distribution(false), - has_buffer_requests(false), - has_udp(false), - has_binary(false), - has_verify_key(false) - { - } - } used_options; - - for (uint32_t x= 0; x < RANDOM_STRINGS; x++) - { - std::string random_options; - - uint32_t number_of= random() % uint32_t(option_list.size()); - for (uint32_t options= 0; options < number_of; options++) - { - size_t option_list_position= random() % option_list.size(); - - if (used_list[option_list_position]) - { - continue; - } - used_list[option_list_position]= true; - - std::string random_string= option_list[option_list_position]->c_str; - - if (random_string.compare(0, test_literal_compare_param("--HASH")) == 0) - { - if (used_options.has_hash) - { - continue; - } - - if (used_options.has_distribution) - { - continue; - } - used_options.has_hash= true; - } - - if (random_string.compare(0, test_literal_compare_param("--NAMESPACE")) == 0) - { - if (used_options.has_namespace) - { - continue; - } - used_options.has_namespace= true; - } - - if (random_string.compare(0, test_literal_compare_param("--USE-UDP")) == 0) - { - if (used_options.has_udp) - { - continue; - } - used_options.has_udp= true; - - if (used_options.has_buffer_requests) - { - continue; - } - } - - if (random_string.compare(0, test_literal_compare_param("--BUFFER-REQUESTS")) == 0) - { - if (used_options.has_buffer_requests) - { - continue; - } - used_options.has_buffer_requests= true; - - if (used_options.has_udp) - { - continue; - } - } - - if (random_string.compare(0, test_literal_compare_param("--BINARY-PROTOCOL")) == 0) - { - if (used_options.has_binary) - { - continue; - } - used_options.has_binary= true; - - if (used_options.has_verify_key) - { - continue; - } - } - - if (random_string.compare(0, test_literal_compare_param("--VERIFY-KEY")) == 0) - { - if (used_options.has_verify_key) - { - continue; - } - used_options.has_verify_key= true; - - if (used_options.has_binary) - { - continue; - } - } - - if (random_string.compare(0, test_literal_compare_param("--DISTRIBUTION")) == 0) - { - if (used_options.has_distribution) - { - continue; - } - - if (used_options.has_hash) - { - continue; - } - used_options.has_distribution= true; - } - - random_options+= random_string; - random_options+= " "; - } - - if (random_options.size() <= 1) - { - continue; - } - - random_options.resize(random_options.size() -1); - - char buffer[BUFSIZ]; - memcached_return_t rc= libmemcached_check_configuration(random_options.c_str(), random_options.size(), buffer, sizeof(buffer)); - if (memcached_failed(rc)) - { - Error << "libmemcached_check_configuration(" << random_options << ") : " << buffer; - return TEST_FAILURE; - } - } - - return TEST_SUCCESS; -} - -static memcached_return_t dump_server_information(const memcached_st *, - const memcached_instance_st * instance, - void *) -{ - if (strcmp(memcached_server_name(instance), "localhost")) - { - fatal_assert(not memcached_server_name(instance)); - return MEMCACHED_FAILURE; - } - - if (memcached_server_port(instance) < 8888 or memcached_server_port(instance) > 8892) - { - fatal_assert(not memcached_server_port(instance)); - return MEMCACHED_FAILURE; - } - - if (instance->weight > 5 or instance->weight < 2) - { - fatal_assert(not instance->weight); - return MEMCACHED_FAILURE; - } - - return MEMCACHED_SUCCESS; -} - -test_return_t test_hostname_port_weight(memcached_st *) -{ - const char *server_string= "--server=localhost:8888/?2 --server=localhost:8889/?3 --server=localhost:8890/?4 --server=localhost:8891/?5 --server=localhost:8892/?3"; - char buffer[BUFSIZ]; - - test_compare_got(MEMCACHED_SUCCESS, - libmemcached_check_configuration(server_string, strlen(server_string), buffer, sizeof(buffer)), buffer); - - memcached_st *memc= memcached(server_string, strlen(server_string)); - test_true(memc); - - memcached_server_fn callbacks[]= { dump_server_information }; - test_true(memcached_success(memcached_server_cursor(memc, callbacks, NULL, 1))); - - memcached_free(memc); - - return TEST_SUCCESS; -} - -struct socket_weight_t { - const char *socket; - size_t weight; - const char* type; -}; - -static memcached_return_t dump_socket_information(const memcached_st *, - const memcached_instance_st * instance, - void *context) -{ - socket_weight_t *check= (socket_weight_t *)context; - - if (strcmp(memcached_server_type(instance), check->type) == 0) - { - if (strcmp(memcached_server_name(instance), check->socket) == 0) - { - if (instance->weight == check->weight) - { - return MEMCACHED_SUCCESS; - } - else - { - Error << instance->weight << " != " << check->weight; - } - } - else - { - Error << "'" << memcached_server_name(instance) << "'" << " != " << "'" << check->socket << "'"; - } - } - else - { - Error << "'" << memcached_server_type(instance) << "'" << " != " << "'" << check->type << "'"; - } - - return MEMCACHED_FAILURE; -} - -test_return_t test_parse_socket(memcached_st *) -{ - char buffer[BUFSIZ]; - - memcached_server_fn callbacks[]= { dump_socket_information }; - { - test_compare_got(MEMCACHED_SUCCESS, - libmemcached_check_configuration(test_literal_param("--socket=\"/tmp/foo\""), buffer, sizeof(buffer)), - buffer); - - memcached_st *memc= memcached(test_literal_param("--socket=\"/tmp/foo\"")); - test_true(memc); - socket_weight_t check= { "/tmp/foo", 1, "SOCKET"}; - test_compare(MEMCACHED_SUCCESS, - memcached_server_cursor(memc, callbacks, &check, 1)); - memcached_free(memc); - } - - { - test_compare_got(MEMCACHED_SUCCESS, - libmemcached_check_configuration(test_literal_param("--socket=\"/tmp/foo\"/?23"), buffer, sizeof(buffer)), - buffer); - - memcached_st *memc= memcached(test_literal_param("--socket=\"/tmp/foo\"/?23")); - test_true(memc); - socket_weight_t check= { "/tmp/foo", 23, "SOCKET"}; - test_compare(MEMCACHED_SUCCESS, - memcached_server_cursor(memc, callbacks, &check, 1)); - memcached_free(memc); - } - - return TEST_SUCCESS; -} - -/* - By setting the timeout value to zero, we force poll() to return immediatly. -*/ -test_return_t regression_bug_71231153_connect(memcached_st *) -{ - { // Test the connect-timeout, on a bad host we should get MEMCACHED_CONNECTION_FAILURE - memcached_st *memc= memcached(test_literal_param("--SERVER=10.0.2.252 --CONNECT-TIMEOUT=0")); - test_true(memc); - test_zero(memc->connect_timeout); - test_compare(MEMCACHED_DEFAULT_TIMEOUT, memc->poll_timeout); - - memcached_return_t rc; - size_t value_len; - char *value= memcached_get(memc, test_literal_param("test"), &value_len, NULL, &rc); - test_false(value); - test_zero(value_len); - test_compare_got(MEMCACHED_TIMEOUT, rc, memcached_last_error_message(memc)); - - memcached_free(memc); - } - - return TEST_SUCCESS; -} - -test_return_t regression_bug_71231153_poll(memcached_st *) -{ - { // Test the poll timeout, on a bad host we should get MEMCACHED_CONNECTION_FAILURE - memcached_st *memc= memcached(test_literal_param("--SERVER=10.0.2.252 --POLL-TIMEOUT=0")); - test_true(memc); - test_compare(MEMCACHED_DEFAULT_CONNECT_TIMEOUT, memc->connect_timeout); - test_zero(memc->poll_timeout); - - memcached_return_t rc; - size_t value_len; - char *value= memcached_get(memc, test_literal_param("test"), &value_len, NULL, &rc); - test_false(value); - test_zero(value_len); -#ifdef __APPLE__ - test_compare_got(MEMCACHED_CONNECTION_FAILURE, rc, memcached_last_error_message(memc)); -#else - test_compare_got(MEMCACHED_TIMEOUT, rc, memcached_last_error_message(memc)); -#endif - - memcached_free(memc); - } - - return TEST_SUCCESS; -} diff --git a/tests/libmemcached-1.0/parser.h b/tests/libmemcached-1.0/parser.h deleted file mode 100644 index a58bba21..00000000 --- a/tests/libmemcached-1.0/parser.h +++ /dev/null @@ -1,118 +0,0 @@ -/* vim:expandtab:shiftwidth=2:tabstop=2:smarttab: - * - * Libmemcached - * - * Copyright (C) 2011 Data Differential, http://datadifferential.com/ - * All rights reserved. - * - * 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. - * - */ - -#pragma once - -#ifdef __cplusplus -extern "C" { -#endif - -test_return_t memcached_NULL_string_TEST(memcached_st*); -test_return_t memcached_zero_string_length_TEST(memcached_st*); - -LIBTEST_LOCAL -test_return_t server_test(memcached_st *memc); - -LIBTEST_LOCAL -test_return_t servers_bad_test(memcached_st *memc); - -LIBTEST_LOCAL -test_return_t behavior_parser_test(memcached_st*); - -LIBTEST_LOCAL -test_return_t parser_number_options_test(memcached_st*); - -LIBTEST_LOCAL -test_return_t parser_distribution_test(memcached_st*); - -LIBTEST_LOCAL -test_return_t parser_hash_test(memcached_st*); - -LIBTEST_LOCAL -test_return_t parser_boolean_options_test(memcached_st*); - -LIBTEST_LOCAL -test_return_t parser_key_prefix_test(memcached_st*); - -LIBTEST_LOCAL - test_return_t libmemcached_check_configuration_test(memcached_st*); - -LIBTEST_LOCAL - test_return_t memcached_create_with_options_test(memcached_st*); - -LIBTEST_LOCAL - test_return_t memcached_create_with_options_with_filename(memcached_st*); - -LIBTEST_LOCAL - test_return_t libmemcached_check_configuration_with_filename_test(memcached_st*); - -LIBTEST_LOCAL - test_return_t random_statement_build_test(memcached_st*); - -LIBTEST_LOCAL -test_return_t test_include_keyword(memcached_st*); - -LIBTEST_LOCAL -test_return_t test_end_keyword(memcached_st*); - -LIBTEST_LOCAL -test_return_t test_reset_keyword(memcached_st*); - -LIBTEST_LOCAL -test_return_t test_error_keyword(memcached_st*); - -LIBTEST_LOCAL -test_return_t server_with_weight_test(memcached_st *); - -LIBTEST_LOCAL -test_return_t test_hostname_port_weight(memcached_st *); - -LIBTEST_LOCAL -test_return_t regression_bug_71231153_connect(memcached_st *); - -LIBTEST_LOCAL -test_return_t regression_bug_71231153_poll(memcached_st *); - -LIBTEST_LOCAL -test_return_t test_parse_socket(memcached_st *); - -LIBTEST_LOCAL -test_return_t test_namespace_keyword(memcached_st*); - -#ifdef __cplusplus -} -#endif