From 558a5c5d4fd3f75e6e51540d333132fde0ff616e Mon Sep 17 00:00:00 2001 From: Michael Wallner Date: Tue, 13 Oct 2020 14:05:27 +0200 Subject: [PATCH] testing: cleanup --- include/libmemcached-1.0/t/c_sasl_test.c | 61 --- include/libmemcached-1.0/t/c_test.c | 61 --- include/libmemcached-1.0/t/cc_test.cc | 62 --- tests/libmemcached-1.0/atomsmasher.cc | 284 ------------- tests/libmemcached-1.0/pool.cc | 497 ----------------------- tests/libmemcached-1.0/print.cc | 82 ---- tests/libmemcached-1.0/replication.cc | 446 -------------------- tests/libmemcached-1.0/touch.cc | 152 ------- 8 files changed, 1645 deletions(-) delete mode 100644 include/libmemcached-1.0/t/c_sasl_test.c delete mode 100644 include/libmemcached-1.0/t/c_test.c delete mode 100644 include/libmemcached-1.0/t/cc_test.cc delete mode 100644 tests/libmemcached-1.0/atomsmasher.cc delete mode 100644 tests/libmemcached-1.0/pool.cc delete mode 100644 tests/libmemcached-1.0/print.cc delete mode 100644 tests/libmemcached-1.0/replication.cc delete mode 100644 tests/libmemcached-1.0/touch.cc diff --git a/include/libmemcached-1.0/t/c_sasl_test.c b/include/libmemcached-1.0/t/c_sasl_test.c deleted file mode 100644 index 0f52afff..00000000 --- a/include/libmemcached-1.0/t/c_sasl_test.c +++ /dev/null @@ -1,61 +0,0 @@ -/* vim:expandtab:shiftwidth=2:tabstop=2:smarttab: - * - * Libmemcached C sasl test app - * - * 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 - * 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. - * - */ - -/* - * @file @brief C dummy test, aka testing C linking, etc - */ - -#include - -#ifdef HAVE_SASL_SASL_H -#include -#endif - -#include "libmemcached-1.0/memcached.h" - -int main(void) -{ - memcached_st *memc= memcached_create(NULL); - - if (memc == NULL) - { - return EXIT_FAILURE; - } - memcached_free(memc); - - return EXIT_SUCCESS; -} - diff --git a/include/libmemcached-1.0/t/c_test.c b/include/libmemcached-1.0/t/c_test.c deleted file mode 100644 index af25f1d0..00000000 --- a/include/libmemcached-1.0/t/c_test.c +++ /dev/null @@ -1,61 +0,0 @@ -/* vim:expandtab:shiftwidth=2:tabstop=2:smarttab: - * - * Libmemcached C test app - * - * 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 - * 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. - * - */ - -/* - * @file @brief C dummy test, aka testing C linking, etc - */ - -#include - -#include "libmemcached-1.0/memcached.h" - -int main(void) -{ - (void)memcached_success(MEMCACHED_SUCCESS); - (void)memcached_failed(MEMCACHED_SUCCESS); - (void)memcached_continue(MEMCACHED_SUCCESS); - - memcached_st *memc= memcached_create(NULL); - - if (memc == NULL) - { - return EXIT_FAILURE; - } - memcached_free(memc); - - return EXIT_SUCCESS; -} - diff --git a/include/libmemcached-1.0/t/cc_test.cc b/include/libmemcached-1.0/t/cc_test.cc deleted file mode 100644 index c098e402..00000000 --- a/include/libmemcached-1.0/t/cc_test.cc +++ /dev/null @@ -1,62 +0,0 @@ -/* vim:expandtab:shiftwidth=2:tabstop=2:smarttab: - * - * Libmemcached C++ test app - * - * 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 - * 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. - * - */ - -/* - * @file @brief C dummy test, aka testing C linking, etc - */ - -#include - -#include "libmemcached-1.0/memcached.h" - -int main(void) -{ - (void)memcached_success(MEMCACHED_SUCCESS); - (void)memcached_failed(MEMCACHED_SUCCESS); - (void)memcached_continue(MEMCACHED_SUCCESS); - - memcached_st *memc= memcached_create(NULL); - - if (memc == NULL) - { - return EXIT_FAILURE; - } - - memcached_free(memc); - - return EXIT_SUCCESS; -} - diff --git a/tests/libmemcached-1.0/atomsmasher.cc b/tests/libmemcached-1.0/atomsmasher.cc deleted file mode 100644 index 169f503f..00000000 --- a/tests/libmemcached-1.0/atomsmasher.cc +++ /dev/null @@ -1,284 +0,0 @@ -/* LibMemcached - * Copyright (C) 2006-2009 Brian Aker - * All rights reserved. - * - * Use and distribution licensed under the BSD license. See - * the COPYING file in the parent directory for full text. - * - * Summary: - * - */ - -/* - Sample test application. -*/ -#include "mem_config.h" - -#include "libtest/test.hpp" - -#include "libmemcached-1.0/memcached.h" - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include "libtest/server.h" - -#include "tests/debug.h" - -#include "tests/libmemcached-1.0/generate.h" - -using namespace libtest; - -/* Number of items generated for tests */ -#define GLOBAL_COUNT 100000 - -/* Number of times to run the test loop */ -#define TEST_COUNTER 500000 - -static pairs_st *global_pairs; -static char *global_keys[GLOBAL_COUNT]; -static size_t global_keys_length[GLOBAL_COUNT]; - -static test_return_t cleanup_pairs_TEST(memcached_st *) -{ - pairs_free(global_pairs); - - return TEST_SUCCESS; -} - -static test_return_t generate_pairs_TEST(memcached_st *) -{ - global_pairs= pairs_generate(GLOBAL_COUNT, 400); - - for (ptrdiff_t x= 0; x < GLOBAL_COUNT; x++) - { - global_keys[x]= global_pairs[x].key; - global_keys_length[x]= global_pairs[x].key_length; - } - - return TEST_SUCCESS; -} - -static test_return_t drizzle_TEST(memcached_st *memc) -{ -infinite: - for (ptrdiff_t x= 0; x < TEST_COUNTER; x++) - { - memcached_return_t rc; - - uint32_t test_bit= (uint32_t)(random() % GLOBAL_COUNT); - uint8_t which= (uint8_t)(random() % 2); - - if (which == 0) - { - size_t return_value_length; - uint32_t flags; - char* return_value= memcached_get(memc, global_keys[test_bit], global_keys_length[test_bit], - &return_value_length, &flags, &rc); - if (rc == MEMCACHED_SUCCESS && return_value) - { - free(return_value); - } - else if (rc == MEMCACHED_NOTFOUND) - { - continue; - } - else - { - test_compare(MEMCACHED_SUCCESS, rc); - } - } - else - { - rc= memcached_set(memc, global_pairs[test_bit].key, - global_pairs[test_bit].key_length, - global_pairs[test_bit].value, - global_pairs[test_bit].value_length, - 0, 0); - if (rc != MEMCACHED_SUCCESS && rc != MEMCACHED_BUFFERED) - { - test_compare(MEMCACHED_SUCCESS, rc); - } - } - } - - if (getenv("MEMCACHED_ATOM_BURIN_IN")) - { - goto infinite; - } - - return TEST_SUCCESS; -} - -static test_return_t pre_nonblock(memcached_st *memc) -{ - test_skip(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 0)); - - return TEST_SUCCESS; -} - -/* - Set the value, then quit to make sure it is flushed. - Come back in and test that add fails. -*/ -static test_return_t add_test(memcached_st *memc) -{ - const char *key= "foo"; - const char *value= "when we sanitize"; - - memcached_return_t rc= memcached_set(memc, key, strlen(key), - value, strlen(value), - time_t(0), uint32_t(0)); - test_true_got(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED, memcached_strerror(NULL, rc)); - memcached_quit(memc); - rc= memcached_add(memc, key, strlen(key), - value, strlen(value), - (time_t)0, (uint32_t)0); - - if (rc == MEMCACHED_CONNECTION_FAILURE) - { - print_servers(memc); - } - - /* Too many broken OS'es have broken loopback in async, so we can't be sure of the result */ - if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK)) - { - test_true(rc == MEMCACHED_NOTSTORED or rc == MEMCACHED_STORED); - } - else - { - test_compare_got(MEMCACHED_NOTSTORED, rc, memcached_strerror(NULL, rc)); - } - - return TEST_SUCCESS; -} - -/* - * repeating add_tests many times - * may show a problem in timing - */ -static test_return_t many_adds(memcached_st *memc) -{ - test_true(memc); - for (ptrdiff_t x= 0; x < TEST_COUNTER; x++) - { - test_compare_got(TEST_SUCCESS, add_test(memc), x); - } - return TEST_SUCCESS; -} - -test_st smash_tests[] ={ - {"generate_pairs", true, (test_callback_fn*)generate_pairs_TEST }, - {"drizzle", true, (test_callback_fn*)drizzle_TEST }, - {"cleanup", true, (test_callback_fn*)cleanup_pairs_TEST }, - {"many_adds", true, (test_callback_fn*)many_adds }, - {0, 0, 0} -}; - -#define BENCHMARK_TEST_LOOP 20000 - -struct benchmark_state_st -{ - bool create_init; - bool clone_init; - memcached_st *create; - memcached_st *clone; -} benchmark_state; - -static test_return_t memcached_create_benchmark(memcached_st *) -{ - benchmark_state.create_init= true; - - for (ptrdiff_t x= 0; x < BENCHMARK_TEST_LOOP; x++) - { - memcached_st *ptr= memcached_create(&benchmark_state.create[x]); - - test_true(ptr); - } - - return TEST_SUCCESS; -} - -static test_return_t memcached_clone_benchmark(memcached_st *memc) -{ - benchmark_state.clone_init= true; - - for (ptrdiff_t x= 0; x < BENCHMARK_TEST_LOOP; x++) - { - memcached_st *ptr= memcached_clone(&benchmark_state.clone[x], memc); - - test_true(ptr); - } - - return TEST_SUCCESS; -} - -static test_return_t pre_allocate(memcached_st *) -{ - memset(&benchmark_state, 0, sizeof(benchmark_state)); - - benchmark_state.create= (memcached_st *)calloc(BENCHMARK_TEST_LOOP, sizeof(memcached_st)); - test_true(benchmark_state.create); - benchmark_state.clone= (memcached_st *)calloc(BENCHMARK_TEST_LOOP, sizeof(memcached_st)); - test_true(benchmark_state.clone); - - return TEST_SUCCESS; -} - -static test_return_t post_allocate(memcached_st *) -{ - for (ptrdiff_t x= 0; x < BENCHMARK_TEST_LOOP; x++) - { - if (benchmark_state.create_init) - { - memcached_free(&benchmark_state.create[x]); - } - - if (benchmark_state.clone_init) - { - memcached_free(&benchmark_state.clone[x]); - } - } - - free(benchmark_state.create); - free(benchmark_state.clone); - - return TEST_SUCCESS; -} - - -test_st micro_tests[] ={ - {"memcached_create", 1, (test_callback_fn*)memcached_create_benchmark }, - {"memcached_clone", 1, (test_callback_fn*)memcached_clone_benchmark }, - {0, 0, 0} -}; - - -collection_st collection[] ={ - {"smash", 0, 0, smash_tests}, - {"smash_nonblock", (test_callback_fn*)pre_nonblock, 0, smash_tests}, - {"micro-benchmark", (test_callback_fn*)pre_allocate, (test_callback_fn*)post_allocate, micro_tests}, - {0, 0, 0, 0} -}; - - -#include "tests/libmemcached_world.h" - -void get_world(libtest::Framework* world) -{ - world->collections(collection); - - world->create((test_callback_create_fn*)world_create); - world->destroy((test_callback_destroy_fn*)world_destroy); - - world->set_runner(new LibmemcachedRunner); -} diff --git a/tests/libmemcached-1.0/pool.cc b/tests/libmemcached-1.0/pool.cc deleted file mode 100644 index 26932996..00000000 --- a/tests/libmemcached-1.0/pool.cc +++ /dev/null @@ -1,497 +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 - -#include - -#include "libmemcached-1.0/memcached.h" -#include "libmemcachedutil-1.0/util.h" -#include "libmemcached/is.h" -#include "tests/pool.h" - -#include -#include - -#include "libmemcached/instance.hpp" - -#ifndef __INTEL_COMPILER -#pragma GCC diagnostic ignored "-Wstrict-aliasing" -#endif - - -test_return_t memcached_pool_test(memcached_st *) -{ - const char *config_string= "--SERVER=host10.example.com --SERVER=host11.example.com --SERVER=host10.example.com --POOL-MIN=10 --POOL-MAX=32"; - - char buffer[2048]; - - test_compare(libmemcached_check_configuration(config_string, sizeof(config_string) -1, buffer, sizeof(buffer)), MEMCACHED_PARSE_ERROR); - - memcached_pool_st* pool= memcached_pool(config_string, strlen(config_string)); - test_true(pool); - - memcached_return_t rc; - memcached_st *memc= memcached_pool_pop(pool, false, &rc); - - test_compare(rc, MEMCACHED_SUCCESS); - test_true(memc); - - /* - Release the memc_ptr that was pulled from the pool - */ - memcached_pool_push(pool, memc); - - /* - Destroy the pool. - */ - memcached_pool_destroy(pool); - - return TEST_SUCCESS; -} - - -#define POOL_SIZE 10 -test_return_t connection_pool_test(memcached_st *memc) -{ - memcached_pool_st* pool= memcached_pool_create(memc, 5, POOL_SIZE); - test_true(pool); - memcached_st *mmc[POOL_SIZE]; - - // Fill up our array that we will store the memc that are in the pool - for (size_t x= 0; x < POOL_SIZE; ++x) - { - memcached_return_t rc; - mmc[x]= memcached_pool_fetch(pool, NULL, &rc); - test_compare(MEMCACHED_SUCCESS, rc); - test_true(mmc[x]); - } - - // All memc should be gone - { - memcached_return_t rc; - test_null(memcached_pool_fetch(pool, NULL, &rc)); - test_compare(MEMCACHED_NOTFOUND, rc); - } - - // Release them.. - for (size_t x= 0; x < POOL_SIZE; ++x) - { - if (mmc[x]) - { - test_compare(MEMCACHED_SUCCESS, memcached_pool_release(pool, mmc[x])); - } - } - test_true(memcached_pool_destroy(pool) == memc); - - return TEST_SUCCESS; -} - -test_return_t connection_pool2_test(memcached_st *memc) -{ - memcached_pool_st* pool= memcached_pool_create(memc, 5, POOL_SIZE); - test_true(pool); - memcached_st *mmc[POOL_SIZE]; - - // Fill up our array that we will store the memc that are in the pool - for (size_t x= 0; x < POOL_SIZE; ++x) - { - memcached_return_t rc; - mmc[x]= memcached_pool_fetch(pool, NULL, &rc); - test_compare(MEMCACHED_SUCCESS, rc); - test_true(mmc[x]); - } - - // All memc should be gone - { - memcached_return_t rc; - test_null(memcached_pool_fetch(pool, NULL, &rc)); - test_compare(MEMCACHED_NOTFOUND, rc); - } - - // verify that I can do ops with all connections - test_compare(MEMCACHED_SUCCESS, - memcached_set(mmc[0], - test_literal_param("key"), - "0", 1, 0, 0)); - - for (uint64_t x= 0; x < POOL_SIZE; ++x) - { - uint64_t number_value; - test_compare(MEMCACHED_SUCCESS, - memcached_increment(mmc[x], - test_literal_param("key"), - 1, &number_value)); - test_compare(number_value, (x+1)); - } - - // Release them.. - for (size_t x= 0; x < POOL_SIZE; ++x) - { - test_compare(MEMCACHED_SUCCESS, memcached_pool_release(pool, mmc[x])); - } - - - /* verify that I can set behaviors on the pool when I don't have all - * of the connections in the pool. It should however be enabled - * when I push the item into the pool - */ - mmc[0]= memcached_pool_fetch(pool, NULL, NULL); - test_true(mmc[0]); - - test_compare(MEMCACHED_SUCCESS, - memcached_pool_behavior_set(pool, MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK, 9999)); - - { - memcached_return_t rc; - mmc[1]= memcached_pool_fetch(pool, NULL, &rc); - test_true(mmc[1]); - test_compare(MEMCACHED_SUCCESS, rc); - } - - test_compare(uint64_t(9999), memcached_behavior_get(mmc[1], MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK)); - test_compare(MEMCACHED_SUCCESS, memcached_pool_release(pool, mmc[1])); - test_compare(MEMCACHED_SUCCESS, memcached_pool_release(pool, mmc[0])); - - { - memcached_return_t rc; - mmc[0]= memcached_pool_fetch(pool, NULL, &rc); - test_true(mmc[0]); - test_compare(MEMCACHED_SUCCESS, rc); - } - - test_compare(uint64_t(9999), memcached_behavior_get(mmc[0], MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK)); - test_compare(MEMCACHED_SUCCESS, memcached_pool_release(pool, mmc[0])); - - test_true(memcached_pool_destroy(pool) == memc); - - return TEST_SUCCESS; -} - -struct test_pool_context_st { - volatile memcached_return_t rc; - memcached_pool_st* pool; - memcached_st* mmc; - sem_t _lock; - - test_pool_context_st(memcached_pool_st *pool_arg, memcached_st *memc_arg): - rc(MEMCACHED_FAILURE), - pool(pool_arg), - mmc(memc_arg) - { - sem_init(&_lock, 0, 0); - } - - void wait() - { - sem_wait(&_lock); - } - - void release() - { - sem_post(&_lock); - } - - ~test_pool_context_st() - { - sem_destroy(&_lock); - } -}; - -static __attribute__((noreturn)) void* connection_release(void *arg) -{ - test_pool_context_st *resource= static_cast(arg); - FATAL_IF(resource == NULL); - - // Release all of the memc we are holding - resource->rc= memcached_pool_release(resource->pool, resource->mmc); - resource->release(); - - pthread_exit(arg); -} - -test_return_t connection_pool3_test(memcached_st *memc) -{ -#ifdef __APPLE__ - return TEST_SKIPPED; -#endif - - memcached_pool_st* pool= memcached_pool_create(memc, 1, 1); - test_true(pool); - - memcached_st *pool_memc; - { - memcached_return_t rc; - pool_memc= memcached_pool_fetch(pool, NULL, &rc); - test_compare(MEMCACHED_SUCCESS, rc); - test_true(pool_memc); - } - - /* - @note This comment was written to describe what was believed to be the original authors intent. - - This portion of the test creates a thread that will wait until told to free a memcached_st - that will be grabbed by the main thread. - - It is believed that this tests whether or not we are handling ownership correctly. - */ - pthread_t tid; - test_pool_context_st item(pool, pool_memc); - - test_zero(pthread_create(&tid, NULL, connection_release, &item)); - item.wait(); - - memcached_return_t rc; - memcached_st *pop_memc; - // We do a hard loop, and try N times - int counter= 5; - do - { - struct timespec relative_time= { 0, 0 }; - pop_memc= memcached_pool_fetch(pool, &relative_time, &rc); - - if (memcached_success(rc)) - { - break; - } - - if (memcached_failed(rc)) - { - test_null(pop_memc); - test_true(rc != MEMCACHED_TIMEOUT); // As long as relative_time is zero, MEMCACHED_TIMEOUT is invalid - } - } while (--counter); - - if (memcached_failed(rc)) // Cleanup thread since we will exit once we test. - { - pthread_join(tid, NULL); - test_compare(MEMCACHED_SUCCESS, rc); - } - - { - int pthread_ret= pthread_join(tid, NULL); - test_true(pthread_ret == 0 or pthread_ret == ESRCH); - } - test_compare(MEMCACHED_SUCCESS, rc); - test_true(pool_memc == pop_memc); - - test_true(memcached_pool_destroy(pool) == memc); - - return TEST_SUCCESS; -} - -static memcached_st * create_single_instance_memcached(const memcached_st *original_memc, const char *options) -{ - /* - If no options are given, copy over at least the binary flag. - */ - char options_buffer[1024]= { 0 }; - if (options == NULL) - { - if (memcached_is_binary(original_memc)) - { - snprintf(options_buffer, sizeof(options_buffer), "--BINARY"); - } - } - - /* - * I only want to hit _one_ server so I know the number of requests I'm - * sending in the pipeline. - */ - const memcached_instance_st * instance= memcached_server_instance_by_position(original_memc, 0); - - char server_string[1024]; - int server_string_length; - if (instance->type == MEMCACHED_CONNECTION_UNIX_SOCKET) - { - if (options) - { - server_string_length= snprintf(server_string, sizeof(server_string), "--SOCKET=\"%s\" %s", - memcached_server_name(instance), options); - } - else - { - server_string_length= snprintf(server_string, sizeof(server_string), "--SOCKET=\"%s\"", - memcached_server_name(instance)); - } - } - else - { - if (options) - { - server_string_length= snprintf(server_string, sizeof(server_string), "--server=%s:%d %s", - memcached_server_name(instance), int(memcached_server_port(instance)), - options); - } - else - { - server_string_length= snprintf(server_string, sizeof(server_string), "--server=%s:%d", - memcached_server_name(instance), int(memcached_server_port(instance))); - } - } - - if (server_string_length <= 0) - { - return NULL; - } - - char errror_buffer[1024]; - if (memcached_failed(libmemcached_check_configuration(server_string, server_string_length, errror_buffer, sizeof(errror_buffer)))) - { - Error << "Failed to parse (" << server_string << ") " << errror_buffer; - return NULL; - } - - return memcached(server_string, server_string_length); -} - -pthread_mutex_t mutex= PTHREAD_MUTEX_INITIALIZER; -static bool _running= false; - -static void set_running(const bool arg) -{ - int error; - FATAL_IF_((error= pthread_mutex_lock(&mutex)) != 0, strerror(error)); - - _running= arg; - - FATAL_IF_((error= pthread_mutex_unlock(&mutex)) != 0, strerror(error)); -} - -static bool running() -{ - int error; - bool ret; - - FATAL_IF_((error= pthread_mutex_lock(&mutex)) != 0, strerror(error)); - - ret= _running; - - FATAL_IF_((error= pthread_mutex_unlock(&mutex)) != 0, strerror(error)); - - return ret; -} - -static void *worker_thread(void *ctx) -{ - memcached_pool_st *pool= (memcached_pool_st *)ctx; - - while (running()) - { - memcached_return_t rc; - memcached_st *mc= memcached_pool_pop(pool, true, &rc); - - if (mc == NULL) - { - Error << "failed to fetch a connection from the pool" << memcached_strerror(NULL, rc); - dream(1, 0); - continue; - } - - rc= memcached_set(mc, "test:kv", 7, "value", 5, 600, 0); - if (memcached_failed(rc)) - { - Out << "failed memcached_set()"; - } - - rc= memcached_pool_push(pool, mc); - if (memcached_failed(rc)) - { - Error << "failed to release a connection to the pool" << memcached_strerror(NULL, rc); - } - } - - return NULL; -} - -#define NUM_THREADS 20 -test_return_t regression_bug_962815(memcached_st *memc) -{ - pthread_t pid[NUM_THREADS]; - - test_false(running()); - - memcached_st *master = create_single_instance_memcached(memc, 0); - test_true(master); - - memcached_pool_st *pool= memcached_pool_create(master, 5, 10); - - test_true(pool); - - set_running(true); - - for (size_t x=0; x < NUM_THREADS; x++) - { - test_compare(0, pthread_create(&pid[x], NULL, worker_thread, (void*)pool)); - } - - { - pollfd fds[1]; - memset(fds, 0, sizeof(pollfd)); - fds[0].fd= -1; //STDIN_FILENO; - fds[0].events= POLLIN; - fds[0].revents= 0; - - int active_fd; - if ((active_fd= poll(fds, 1, 5000)) == -1) - { - Error << "poll() failed with:" << strerror(errno); - } - test_zero(active_fd); - - set_running(false); - } - - for (size_t x=0; x < NUM_THREADS; x++) - { - test_compare(0, pthread_join(pid[x], NULL)); - } - - memcached_pool_destroy(pool); - - memcached_free(master); - - return TEST_SUCCESS; -} diff --git a/tests/libmemcached-1.0/print.cc b/tests/libmemcached-1.0/print.cc deleted file mode 100644 index 1e948eb4..00000000 --- a/tests/libmemcached-1.0/print.cc +++ /dev/null @@ -1,82 +0,0 @@ -/* vim:expandtab:shiftwidth=2:tabstop=2:smarttab: - * - * Libmemcached client and server library. - * - * 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 "libmemcached-1.0/memcached.h" - -#include "tests/print.h" - -memcached_return_t server_print_callback(const memcached_st*, - const memcached_instance_st * server, - void *context) -{ - if (context) - { - std::cerr << memcached_server_name(server) << ":" << memcached_server_port(server) << std::endl; - } - - return MEMCACHED_SUCCESS; -} - -memcached_return_t server_print_version_callback(const memcached_st *, - const memcached_instance_st * server, - void *) -{ - std::cerr << "Server: " << memcached_server_name(server) << ":" << memcached_server_port(server) << " " - << int(memcached_server_major_version(server)) << "." - << int(memcached_server_minor_version(server)) << "." - << int(memcached_server_micro_version(server)) - << std::endl; - - return MEMCACHED_SUCCESS; -} - -const char * print_version(memcached_st *memc) -{ - memcached_server_fn callbacks[1]; - callbacks[0]= server_print_version_callback; - memcached_server_cursor(memc, callbacks, NULL, 1); - - return "print_version()"; -} diff --git a/tests/libmemcached-1.0/replication.cc b/tests/libmemcached-1.0/replication.cc deleted file mode 100644 index a760060e..00000000 --- a/tests/libmemcached-1.0/replication.cc +++ /dev/null @@ -1,446 +0,0 @@ -/* vim:expandtab:shiftwidth=2:tabstop=2:smarttab: - * - * Libmemcached client and server library. - * - * 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 "libmemcached-1.0/memcached.h" - -#include "libmemcached/server_instance.h" - -#include "tests/replication.h" -#include "tests/debug.h" - -#include "tests/libmemcached-1.0/setup_and_teardowns.h" - -test_return_t check_replication_sanity_TEST(memcached_st *memc) -{ - test_true(memc); - test_compare(uint64_t(1), - memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL)); - - /* - * Make sure that we store the item on all servers - * (master + replicas == number of servers) - */ - test_compare(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS), uint64_t(memcached_server_count(memc) - 1)); - - return TEST_SUCCESS; -} - -test_return_t replication_set_test(memcached_st *memc) -{ - memcached_st *memc_clone= memcached_clone(NULL, memc); - test_true(memc_clone); - test_compare(MEMCACHED_SUCCESS, - memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, 0)); - - test_compare(MEMCACHED_SUCCESS, - memcached_set(memc, "bubba", 5, "0", 1, 0, 0)); - - /* - ** We are using the quiet commands to store the replicas, so we need - ** to ensure that all of them are processed before we can continue. - ** In the test we go directly from storing the object to trying to - ** receive the object from all of the different servers, so we - ** could end up in a race condition (the memcached server hasn't yet - ** processed the quiet command from the replication set when it process - ** the request from the other client (created by the clone)). As a - ** workaround for that we call memcached_quit to send the quit command - ** to the server and wait for the response ;-) If you use the test code - ** as an example for your own code, please note that you shouldn't need - ** to do this ;-) - */ - memcached_quit(memc); - - /* - ** "bubba" should now be stored on all of our servers. We don't have an - ** easy to use API to address each individual server, so I'll just iterate - ** through a bunch of "master keys" and I should most likely hit all of the - ** servers... - */ - for (int x= 'a'; x <= 'z'; ++x) - { - const char key[2]= { (char)x, 0 }; - size_t len; - uint32_t flags; - memcached_return_t rc; - char *val= memcached_get_by_key(memc_clone, key, 1, "bubba", 5, - &len, &flags, &rc); - test_compare(MEMCACHED_SUCCESS, rc); - test_true(val); - free(val); - } - - memcached_free(memc_clone); - - return TEST_SUCCESS; -} - -#include "libmemcached/instance.hpp" - -test_return_t replication_get_test(memcached_st *memc) -{ - - /* - * Don't do the following in your code. I am abusing the internal details - * within the library, and this is not a supported interface. - * This is to verify correct behavior in the library - */ - for (uint32_t host= 0; host < memcached_server_count(memc); ++host) - { - memcached_st *memc_clone= memcached_clone(NULL, memc); - memcached_instance_st* instance= (memcached_instance_st*)memcached_server_instance_by_position(memc_clone, host); - - instance->port(0); - - for (int x= 'a'; x <= 'z'; ++x) - { - const char key[2]= { (char)x, 0 }; - size_t len; - uint32_t flags; - memcached_return_t rc; - char *val= memcached_get_by_key(memc_clone, key, 1, "bubba", 5, - &len, &flags, &rc); - test_compare(MEMCACHED_SUCCESS, rc); - test_true(val); - free(val); - } - - memcached_free(memc_clone); - } - - return TEST_SUCCESS; -} - -test_return_t replication_mget_test(memcached_st *memc) -{ - memcached_st *memc_clone= memcached_clone(NULL, memc); - test_true(memc_clone); - test_compare(MEMCACHED_SUCCESS, - memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, 0)); - - const char *keys[]= { "bubba", "key1", "key2", "key3" }; - size_t len[]= { 5, 4, 4, 4 }; - - for (size_t x= 0; x< 4; ++x) - { - test_compare(MEMCACHED_SUCCESS, memcached_set(memc, keys[x], len[x], "0", 1, 0, 0)); - } - - /* - ** We are using the quiet commands to store the replicas, so we need - ** to ensure that all of them are processed before we can continue. - ** In the test we go directly from storing the object to trying to - ** receive the object from all of the different servers, so we - ** could end up in a race condition (the memcached server hasn't yet - ** processed the quiet command from the replication set when it process - ** the request from the other client (created by the clone)). As a - ** workaround for that we call memcached_quit to send the quit command - ** to the server and wait for the response ;-) If you use the test code - ** as an example for your own code, please note that you shouldn't need - ** to do this ;-) - */ - memcached_quit(memc); - - /* - * Don't do the following in your code. I am abusing the internal details - * within the library, and this is not a supported interface. - * This is to verify correct behavior in the library - */ - memcached_result_st result_obj; - for (uint32_t host= 0; host < memcached_server_count(memc_clone); host++) - { - memcached_st *new_clone= memcached_clone(NULL, memc); - const memcached_instance_st * instance= memcached_server_instance_by_position(new_clone, host); - ((memcached_server_write_instance_st)instance)->port(0); - - for (int x= 'a'; x <= 'z'; ++x) - { - char key[2]= { (char)x, 0 }; - - test_compare(MEMCACHED_SUCCESS, - memcached_mget_by_key(new_clone, key, 1, keys, len, 4)); - - memcached_result_st *results= memcached_result_create(new_clone, &result_obj); - test_true(results); - - int hits= 0; - memcached_return_t rc; - while ((results= memcached_fetch_result(new_clone, &result_obj, &rc)) != NULL) - { - hits++; - } - test_compare(4, hits); - memcached_result_free(&result_obj); - } - - memcached_free(new_clone); - } - - memcached_free(memc_clone); - - return TEST_SUCCESS; -} - -test_return_t replication_randomize_mget_test(memcached_st *memc) -{ - memcached_result_st result_obj; - memcached_st *memc_clone= memcached_clone(NULL, memc); - memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, 3); - memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_RANDOMIZE_REPLICA_READ, 1); - - const char *keys[]= { "key1", "key2", "key3", "key4", "key5", "key6", "key7" }; - size_t len[]= { 4, 4, 4, 4, 4, 4, 4 }; - - for (size_t x= 0; x< 7; ++x) - { - test_compare(MEMCACHED_SUCCESS, - memcached_set(memc, keys[x], len[x], "1", 1, 0, 0)); - } - - memcached_quit(memc); - - for (size_t x= 0; x< 7; ++x) - { - const char key[2]= { (char)x, 0 }; - - test_compare(MEMCACHED_SUCCESS, - memcached_mget_by_key(memc_clone, key, 1, keys, len, 7)); - - memcached_result_st *results= memcached_result_create(memc_clone, &result_obj); - test_true(results); - - int hits= 0; - memcached_return_t rc; - while ((results= memcached_fetch_result(memc_clone, &result_obj, &rc)) != NULL) - { - ++hits; - } - test_compare(hits, 7); - memcached_result_free(&result_obj); - } - memcached_free(memc_clone); - - return TEST_SUCCESS; -} - -test_return_t replication_delete_test(memcached_st *memc_just_cloned) -{ - memcached_flush(memc_just_cloned, 0); - memcached_st *memc_not_replicate= memcached_clone(NULL, memc_just_cloned); - memcached_st *memc_replicated= memcached_clone(NULL, memc_just_cloned); - const char *keys[]= { "bubba", "key1", "key2", "key3", "key4" }; - - test_compare(uint64_t(1), memcached_behavior_get(memc_replicated, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL)); - test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc_replicated, MEMCACHED_BEHAVIOR_RANDOMIZE_REPLICA_READ, false)); - - // Make one copy - test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc_replicated, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, 1UL)); - test_compare(uint64_t(1), memcached_behavior_get(memc_replicated, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS)); - - test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc_not_replicate, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, 0UL)); - test_compare(uint64_t(0), memcached_behavior_get(memc_not_replicate, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS)); - - for (size_t x= 0; x < test_array_length(keys); ++x) - { - memcached_set(memc_replicated, - test_string_make_from_cstr(keys[x]), // Keys - test_string_make_from_cstr(keys[x]), // We use the keys as values - 0, 0); - } - - memcached_flush_buffers(memc_replicated); - - // Confirm keys with replication read - test_compare(TEST_SUCCESS, confirm_keys_exist(memc_replicated, keys, test_array_length(keys), true, true)); - test_compare(TEST_SUCCESS, confirm_keys_exist(memc_not_replicate, keys, test_array_length(keys), true, true)); - - /* Delete the items from all of the servers except 1, we use the non replicated memc so that we know we deleted the keys */ - for (size_t x= 0; x < test_array_length(keys); ++x) - { - memcached_return_t del_rc= memcached_delete(memc_replicated, - test_string_make_from_cstr(keys[x]), // Keys - 0); - if (del_rc == MEMCACHED_SUCCESS or del_rc == MEMCACHED_NOTFOUND) - { } - else - { - test_compare(MEMCACHED_SUCCESS, del_rc); - } - } - - test_compare(TEST_SUCCESS, confirm_keys_dont_exist(memc_replicated, keys, test_array_length(keys))); - test_compare(TEST_SUCCESS, confirm_keys_dont_exist(memc_not_replicate, keys, test_array_length(keys))); -#if 0 - test_zero(confirm_key_count(memc_not_replicate)); -#endif - - memcached_free(memc_not_replicate); - memcached_free(memc_replicated); - - return TEST_SUCCESS; -} - -test_return_t replication_randomize_mget_fail_test(memcached_st *memc) -{ - memcached_st *memc_clone= memcached_clone(NULL, memc); - memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, 3); - - for (int x= int(MEMCACHED_SUCCESS); x < int(MEMCACHED_MAXIMUM_RETURN); ++x) - { - const char *key= memcached_strerror(NULL, memcached_return_t(x)); - test_compare(MEMCACHED_SUCCESS, - memcached_set(memc, - key, strlen(key), - key, strlen(key), 0, 0)); - } - - memcached_flush_buffers(memc); - - // We need to now cause a failure in one server, never do this in your own - // code. - close(memc_clone->servers[1].fd); - memc_clone->servers[1].port(1); - memc_clone->servers[1].address_info_next= NULL; - - for (int x= int(MEMCACHED_SUCCESS); x < int(MEMCACHED_MAXIMUM_RETURN); ++x) - { - const char *key= memcached_strerror(NULL, memcached_return_t(x)); - uint32_t flags; - size_t value_length; - memcached_return_t rc; - char *value= memcached_get(memc_clone, key, strlen(key), &value_length, &flags, &rc); - test_compare(MEMCACHED_SUCCESS, rc); - test_compare(strlen(key), value_length); - test_strcmp(key, value); - free(value); - } - memcached_free(memc_clone); - return TEST_SUCCESS; -} - -/* Test that single miss does not cause replica reads to fail */ -test_return_t replication_miss_test(memcached_st *memc) -{ - test_skip(true, false); - - memcached_st *memc_repl= memcached_clone(NULL, memc); - test_true(memc_repl); - memcached_st *memc_single= memcached_clone(NULL, memc); - test_true(memc_single); - - const char *value = "my_value"; - size_t vlen; - uint32_t flags; - - /* this test makes sense only with 2 or more servers */ - test_true(memcached_server_count(memc_repl) > 1); - - /* Consistent hash */ - test_compare(MEMCACHED_SUCCESS, - memcached_behavior_set_distribution(memc_repl, MEMCACHED_DISTRIBUTION_CONSISTENT)); - test_compare(MEMCACHED_SUCCESS, - memcached_behavior_set_distribution(memc_single, MEMCACHED_DISTRIBUTION_CONSISTENT)); - - /* The first clone writes to all servers */ - test_compare(MEMCACHED_SUCCESS, - memcached_behavior_set(memc_repl, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, true)); - test_compare(MEMCACHED_SUCCESS, - memcached_behavior_set(memc_repl, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, - memcached_server_count(memc_repl))); - - /* Write to servers */ - { - memcached_return_t rc= memcached_set(memc_repl, - test_literal_param(__func__), - value, strlen(value), - time_t(1200), uint32_t(0)); - test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED); - } - - /* Use the second clone to remove the key from primary server. - This should remove the key from only one server */ - { - memcached_return_t rc= memcached_delete(memc_single, - test_literal_param(__func__), - 0); - test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED); - } - - /* Remove the server where the key was deleted */ - { -#if 0 - memcached_return_t rc; - const memcached_server_st *instance= memcached_server_by_key(memc_single, - test_literal_param(__func__), - &rc); - test_compare(MEMCACHED_SUCCESS, rc); - test_compare(MEMCACHED_SUCCESS, - memcached_server_remove(instance)); -#endif - } - - /* Test that others still have it */ - { - memcached_return_t rc; - char *get_value= memcached_get(memc_single, - test_literal_param(__func__), - &vlen, &flags, &rc); - test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED); - test_true(get_value and strcmp(get_value, value) == 0); - free(get_value); - } - - /* This read should still return the value as we have it on other servers */ - { - memcached_return_t rc; - char *get_value= memcached_get(memc_repl, - test_literal_param(__func__), - &vlen, &flags, &rc); - test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED); - test_true(get_value and strcmp(get_value, value) == 0); - free(get_value); - } - - memcached_free(memc_repl); - memcached_free(memc_single); - - return TEST_SUCCESS; -} diff --git a/tests/libmemcached-1.0/touch.cc b/tests/libmemcached-1.0/touch.cc deleted file mode 100644 index 5f894339..00000000 --- a/tests/libmemcached-1.0/touch.cc +++ /dev/null @@ -1,152 +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 "libmemcached-1.0/memcached.h" -#include "libmemcachedutil-1.0/util.h" - -#include "tests/touch.h" - -static test_return_t pre_touch(memcached_st *memc) -{ - test_compare(MEMCACHED_SUCCESS, memcached_version(memc)); - test_skip(true, libmemcached_util_version_check(memc, 1, 4, 15)); - - return TEST_SUCCESS; -} - -test_return_t test_memcached_touch(memcached_st *memc) -{ - test_skip(TEST_SUCCESS, pre_touch(memc)); - - size_t len; - uint32_t flags; - memcached_return rc; - - test_null(memcached_get(memc, - test_literal_param(__func__), - &len, &flags, &rc)); - test_zero(len); - test_compare(MEMCACHED_NOTFOUND, rc); - - test_compare(MEMCACHED_SUCCESS, - memcached_set(memc, - test_literal_param(__func__), - test_literal_param("touchval"), - 2, 0)); - - { - char *value= memcached_get(memc, - test_literal_param(__func__), - &len, &flags, &rc); - test_compare(8U, test_literal_param_size("touchval")); - test_true(value); - test_strcmp(value, "touchval"); - test_compare(MEMCACHED_SUCCESS, rc); - free(value); - } - - rc= memcached_touch(memc, test_literal_param(__func__), 60 *60); - ASSERT_EQ_(MEMCACHED_SUCCESS, rc, "%s", memcached_last_error_message(memc)); - - rc= memcached_touch(memc, test_literal_param(__func__), 60 *60 *24 *60); - ASSERT_EQ_(MEMCACHED_SUCCESS, rc, "%s", memcached_last_error_message(memc)); - - rc= memcached_exist(memc, test_literal_param(__func__)); - ASSERT_EQ_(MEMCACHED_NOTFOUND, rc, "%s", memcached_last_error_message(memc)); - - return TEST_SUCCESS; -} - -test_return_t test_memcached_touch_by_key(memcached_st *memc) -{ - test_skip(TEST_SUCCESS, pre_touch(memc)); - - size_t len; - uint32_t flags; - memcached_return rc; - - test_null(memcached_get_by_key(memc, - test_literal_param("grouping_key"), - test_literal_param(__func__), - &len, &flags, &rc)); - test_zero(len); - test_compare(MEMCACHED_NOTFOUND, rc); - - test_compare(MEMCACHED_SUCCESS, - memcached_set_by_key(memc, - test_literal_param("grouping_key"), - test_literal_param(__func__), - test_literal_param("touchval"), - 2, 0)); - - { - char *value= memcached_get_by_key(memc, - test_literal_param("grouping_key"), - test_literal_param(__func__), - &len, &flags, &rc); - test_compare(8U, test_literal_param_size("touchval")); - test_true(value); - test_strcmp(value, "touchval"); - test_compare(MEMCACHED_SUCCESS, rc); - free(value); - } - - rc= memcached_touch_by_key(memc, - test_literal_param("grouping_key"), - test_literal_param(__func__), - 60 *60); - ASSERT_EQ_(MEMCACHED_SUCCESS, rc, "%s", memcached_last_error_message(memc)); - - rc= memcached_touch_by_key(memc, - test_literal_param("grouping_key"), - test_literal_param(__func__), - 60 *60 *24 *60); - ASSERT_EQ_(MEMCACHED_SUCCESS, rc, "%s", memcached_last_error_message(memc)); - - rc= memcached_exist_by_key(memc, test_literal_param("grouping_key"),test_literal_param(__func__)); - ASSERT_EQ_(MEMCACHED_NOTFOUND, rc, "%s", memcached_last_error_message(memc)); - - return TEST_SUCCESS; -} - - - -- 2.30.2