+++ /dev/null
-/* 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 <stdlib.h>
-
-#ifdef HAVE_SASL_SASL_H
-#include <sasl/sasl.h>
-#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;
-}
-
+++ /dev/null
-/* 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 <stdlib.h>
-
-#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;
-}
-
+++ /dev/null
-/* 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 <cstdlib>
-
-#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;
-}
-
+++ /dev/null
-/* 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 <cstdio>
-#include <cstdlib>
-#include <stdint.h>
-#include <cstring>
-#include <sys/time.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <unistd.h>
-#include <ctime>
-#include <bin/generator.h>
-#include <bin/execute.h>
-
-#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);
-}
+++ /dev/null
-/* 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 <vector>
-#include <iostream>
-#include <string>
-#include <cerrno>
-
-#include <semaphore.h>
-
-#include "libmemcached-1.0/memcached.h"
-#include "libmemcachedutil-1.0/util.h"
-#include "libmemcached/is.h"
-#include "tests/pool.h"
-
-#include <pthread.h>
-#include <poll.h>
-
-#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<test_pool_context_st *>(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;
-}
+++ /dev/null
-/* 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 <iostream>
-
-#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()";
-}
+++ /dev/null
-/* 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;
-}
+++ /dev/null
-/* 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;
-}
-
-
-
projects / awesomized / libmemcached / commitdiff
