couchbase-memcached 1.2.8

data/ext/libmemcached-0.50/tests/basic.cc

@@ -0,0 +1,134 @@
+/*  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+ * 
+ *  Libmemcached
+ *
+ *  Copyright (C) 2011 Data Differential, http://datadifferential.com/
+ *  All rights reserved.
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions are
+ *  met:
+ *
+ *      * Redistributions of source code must retain the above copyright
+ *  notice, this list of conditions and the following disclaimer.
+ *
+ *      * Redistributions in binary form must reproduce the above
+ *  copyright notice, this list of conditions and the following disclaimer
+ *  in the documentation and/or other materials provided with the
+ *  distribution.
+ *
+ *      * The names of its contributors may not be used to endorse or
+ *  promote products derived from this software without specific prior
+ *  written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include <libtest/common.h>
+
+#include <libmemcached/memcached.h>
+#include <libmemcached/is.h>
+
+#include "tests/basic.h"
+
+#include <cstring>
+
+test_return_t basic_init_test(memcached_st *junk)
+{
+  (void)junk;
+
+  memcached_st memc;
+  memcached_st *memc_ptr;
+
+  memc_ptr= memcached_create(&memc);
+  test_true(memc_ptr);
+  test_false(memcached_is_allocated(&memc));
+  memcached_free(memc_ptr);
+
+  return TEST_SUCCESS;
+}
+
+test_return_t basic_clone_test(memcached_st *memc)
+{
+  memcached_st *memc_ptr;
+
+  memc_ptr= memcached_clone(NULL, memc);
+  test_true(memc_ptr);
+  test_true(memcached_is_allocated(memc_ptr));
+  memcached_free(memc_ptr);
+
+  return TEST_SUCCESS;
+}
+
+test_return_t basic_reset_stack_test(memcached_st *junk)
+{
+  (void)junk;
+  memcached_st memc;
+
+  memcached_create(&memc);
+
+  memcached_reset(&memc);
+  test_false(memcached_is_allocated(&memc));
+
+  memcached_free(&memc);
+  test_false(memcached_is_allocated(&memc));
+
+  return TEST_SUCCESS;
+}
+
+test_return_t basic_reset_heap_test(memcached_st *junk)
+{
+  (void)junk;
+  memcached_st *memc_ptr;
+
+  memc_ptr= memcached_create(NULL);
+  test_true(memcached_is_allocated(memc_ptr));
+
+  memcached_reset(memc_ptr);
+  test_true(memcached_is_allocated(memc_ptr));
+
+  memcached_free(memc_ptr);
+
+  return TEST_SUCCESS;
+}
+
+test_return_t basic_reset_stack_clone_test(memcached_st *memc)
+{
+  memcached_st clone;
+  memcached_st *memc_ptr;
+
+  memset(&clone, 0, sizeof(clone));
+  memc_ptr= memcached_clone(&clone, memc);
+  test_true(memc_ptr);
+
+  memcached_reset(memc_ptr);
+
+  memcached_free(memc_ptr);
+
+  return TEST_SUCCESS;
+}
+
+test_return_t basic_reset_heap_clone_test(memcached_st *memc)
+{
+  memcached_st *memc_ptr;
+
+  memc_ptr= memcached_clone(NULL, memc);
+  test_true(memc_ptr);
+
+  memcached_reset(memc_ptr);
+
+  memcached_free(memc_ptr);
+
+  return TEST_SUCCESS;
+}

data/ext/libmemcached-0.50/tests/basic.h

@@ -0,0 +1,66 @@
+/*  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+ * 
+ *  Libmemcached
+ *
+ *  Copyright (C) 2011 Data Differential, http://datadifferential.com/
+ *  All rights reserved.
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions are
+ *  met:
+ *
+ *      * Redistributions of source code must retain the above copyright
+ *  notice, this list of conditions and the following disclaimer.
+ *
+ *      * Redistributions in binary form must reproduce the above
+ *  copyright notice, this list of conditions and the following disclaimer
+ *  in the documentation and/or other materials provided with the
+ *  distribution.
+ *
+ *      * The names of its contributors may not be used to endorse or
+ *  promote products derived from this software without specific prior
+ *  written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#pragma once
+
+#include <libtest/visibility.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+LIBTEST_INTERNAL_API
+test_return_t basic_init_test(memcached_st *junk);
+
+LIBTEST_INTERNAL_API
+test_return_t basic_clone_test(memcached_st *memc);
+
+LIBTEST_INTERNAL_API
+test_return_t basic_reset_stack_test(memcached_st *junk);
+
+LIBTEST_INTERNAL_API
+test_return_t basic_reset_heap_test(memcached_st *junk);
+
+LIBTEST_INTERNAL_API
+test_return_t basic_reset_stack_clone_test(memcached_st *memc);
+
+LIBTEST_INTERNAL_API
+test_return_t basic_reset_heap_clone_test(memcached_st *memc);
+
+#ifdef	__cplusplus
+}
+#endif

data/ext/libmemcached-0.50/tests/cpp_example.cc

@@ -0,0 +1,195 @@
+/*
+ * An example file showing the usage of the C++ libmemcached interface.
+ */
+#include <config.h>
+
+#include <vector>
+#include <string>
+#include <iostream>
+#include <algorithm>
+#include <map>
+
+#include <string.h>
+
+#include <libmemcached/memcached.hpp>
+
+using namespace std;
+using namespace memcache;
+
+class DeletePtrs
+{
+public:
+  template<typename T>
+  inline void operator()(const T *ptr) const
+  {
+    delete ptr;
+  }
+};
+
+class MyCache
+{
+public:
+
+  static const uint32_t num_of_clients= 10;
+
+  static MyCache &singleton()
+  {
+    static MyCache instance;
+    return instance;
+  }
+
+  void set(const string &key,
+           const vector<char> &value)
+  {
+    time_t expiry= 0;
+    uint32_t flags= 0;
+    getCache()->set(key, value, expiry, flags);
+  }
+
+  vector<char> get(const string &key)
+  {
+    vector<char> ret_value;
+    getCache()->get(key, ret_value);
+    return ret_value;
+  }
+
+  void remove(const string &key)
+  {
+    getCache()->remove(key);
+  }
+
+  Memcache *getCache()
+  {
+    /* 
+     * pick a random element from the vector of clients. Obviously, this is
+     * not very random but suffices as an example!
+     */
+    uint32_t index= rand() % num_of_clients;
+    return clients[index];
+  } 
+
+private:
+
+  /*
+   * A vector of clients.
+   */
+  std::vector<Memcache *> clients;
+
+  MyCache()
+    :
+      clients()
+  {
+    /* create clients and add them to the vector */
+    for (uint32_t i= 0; i < num_of_clients; i++)
+    {
+      Memcache *client= new Memcache("127.0.0.1:11211");
+      clients.push_back(client);
+    }
+  }
+
+  ~MyCache()
+  {
+    for_each(clients.begin(), clients.end(), DeletePtrs());
+    clients.clear();
+  }
+
+  MyCache(const MyCache&);
+
+};
+
+class Product
+{
+public:
+
+  Product(int in_id, double in_price)
+    :
+      id(in_id),
+      price(in_price)
+  {}
+
+  Product()
+    :
+      id(0),
+      price(0.0)
+  {}
+
+  int getId() const
+  {
+    return id;
+  }
+
+  double getPrice() const
+  {
+    return price;
+  }
+
+private:
+
+  int id;
+  double price;
+
+};
+
+void setAllProducts(vector<Product> &products)
+{
+  vector<char> raw_products(products.size() * sizeof(Product));
+  memcpy(&raw_products[0], &products[0], products.size() * sizeof(Product));
+  MyCache::singleton().set("AllProducts", raw_products);
+}
+
+vector<Product> getAllProducts()
+{
+  vector<char> raw_products = MyCache::singleton().get("AllProducts");
+  vector<Product> products(raw_products.size() / sizeof(Product));
+  memcpy(&products[0], &raw_products[0], raw_products.size());
+  return products;
+}
+
+Product getProduct(const string &key)
+{
+  vector<char> raw_product= MyCache::singleton().get(key);
+  Product ret;
+  if (! raw_product.empty())
+  {
+    memcpy(&ret, &raw_product[0], sizeof(Product));
+  }
+  else
+  {
+    /* retrieve it from the persistent store */
+  }
+  return ret;
+}
+
+void setProduct(const string &key, const Product &product)
+{
+  vector<char> raw_product(sizeof(Product));
+  memcpy(&raw_product[0], &product, sizeof(Product));
+  MyCache::singleton().set(key, raw_product);
+}
+
+int main()
+{
+  Memcache first_client("127.0.0.1:19191");
+  map< string, map<string, string> > my_stats;
+  first_client.getStats(my_stats);
+  
+  /*
+   * Iterate through the retrieved stats.
+   */
+  map< string, map<string, string> >::iterator it=
+    my_stats.begin();
+  while (it != my_stats.end())
+  {
+    cout << "working with server: " << (*it).first << endl;
+    map<string, string> serv_stats= (*it).second;
+    map<string, string>::iterator iter= serv_stats.begin();
+    while (iter != serv_stats.end())
+    {
+      cout << (*iter).first << ":" << (*iter).second << endl;
+      ++iter;
+    }
+    ++it;
+  }
+
+  return EXIT_SUCCESS;
+}

data/ext/libmemcached-0.50/tests/deprecated.cc

@@ -0,0 +1,72 @@
+/*  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+ * 
+ *  Libmemcached library
+ *
+ *  Copyright (C) 2011 Data Differential, http://datadifferential.com/
+ *  Copyright (C) 2006-2009 Brian Aker 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 <libtest/common.h>
+
+#include <cassert>
+
+#include <libmemcached/memcached.h>
+#include <tests/deprecated.h>
+
+test_return_t server_list_null_test(memcached_st *ptr)
+{
+  memcached_server_st *server_list;
+  memcached_return_t rc;
+  (void)ptr;
+
+  server_list= memcached_server_list_append_with_weight(NULL, NULL, 0, 0, NULL);
+  test_true(server_list == NULL);
+
+  server_list= memcached_server_list_append_with_weight(NULL, "localhost", 0, 0, NULL);
+  test_true(server_list == NULL);
+
+  server_list= memcached_server_list_append_with_weight(NULL, NULL, 0, 0, &rc);
+  test_true(server_list == NULL);
+
+  return TEST_SUCCESS;
+}
+
+// Look for memory leak
+test_return_t regression_bug_728286(memcached_st *)
+{
+  memcached_server_st *servers = memcached_servers_parse("1.2.3.4:99");
+  assert(servers);
+  memcached_server_free(servers);
+
+  return TEST_SUCCESS;
+}
+