memcached 1.2.6 → 1.2.7

data/ext/libmemcached-0.32/tests/ketama_test_cases.h

@@ -0,0 +1,108 @@
+typedef struct {
+    const char *key;
+    unsigned long hash1;
+    unsigned long hash2;
+    const char *server;
+} TestCase;
+
+static TestCase test_cases[99] = {
+  { "SVa_]_V41)", 443691461UL, 445379617UL, "10.0.1.7" },
+  { "*/Z;?V(.\\8", 1422915503UL, 1428303028UL, "10.0.1.1" },
+  { "30C1*Z*S/_", 1473165754UL, 1480075959UL, "10.0.1.2" },
+  { "ERR:EC58G>", 2148406511UL, 2168579133UL, "10.0.1.7" },
+  { "1I=cTMNTKF", 2882686667UL, 2885206587UL, "10.0.1.5" },
+  { "]VG<`I*Z8)", 1103544263UL, 1104827657UL, "10.0.1.5" },
+  { "UUTC`-V159", 3716288206UL, 3727224240UL, "10.0.1.5" },
+  { "@7RU6C6T+Z", 3862737685UL, 3871917949UL, "10.0.1.5" },
+  { "/XLN0@+36;", 1623269830UL, 1627683651UL, "10.0.1.1" },
+  { "4(`X;\\V.^c", 373546328UL, 383925769UL, "10.0.1.1" },
+  { "726bW=9*a4", 4213440020UL, 4213950705UL, "10.0.1.7" },
+  { "\\`)<B)UE,c", 951096736UL, 955226069UL, "10.0.1.1" },
+  { "P1[Ma3=K1/", 1989324036UL, 1994028240UL, "10.0.1.8" },
+  { "C89I.-V?cT", 1604239957UL, 1606398093UL, "10.0.1.8" },
+  { "D[HE+cFXDK", 2117036136UL, 2117124014UL, "10.0.1.3" },
+  { "P1L?NAB[)K", 2129972569UL, 2132542634UL, "10.0.1.1" },
+  { "cDT0)Z5P6,", 176485284UL, 178675413UL, "10.0.1.5" },
+  { "@JW`+[WAO8", 2720940826UL, 2743975456UL, "10.0.1.5" },
+  { "\\39DKW^)N_", 3548879868UL, 3550704865UL, "10.0.1.3" },
+  { "EM75N0+[X1", 1558531507UL, 1559308507UL, "10.0.1.4" },
+  { "`,SS]NBP,b", 1883545960UL, 1884847278UL, "10.0.1.1" },
+  { "XX1a9LT+F?", 653487707UL, 656410408UL, "10.0.1.5" },
+  { "Zc\\-,F-c6V", 1160802451UL, 1171575728UL, "10.0.1.5" },
+  { "1*RTMC7,03", 1602398012UL, 1606398093UL, "10.0.1.8" },
+  { "*Xc+V0P>32", 536016577UL, 539988520UL, "10.0.1.7" },
+  { "U))Fb-(`,.", 4128682289UL, 4136854163UL, "10.0.1.7" },
+  { "R-08RNTaRT", 3718170086UL, 3727224240UL, "10.0.1.5" },
+  { "(LHcO203I3", 1007779411UL, 1014643570UL, "10.0.1.5" },
+  { "=256P+;Qc8", 3976201210UL, 3976304873UL, "10.0.1.5" },
+  { "OI5XZ_BBT(", 2155922164UL, 2168579133UL, "10.0.1.7" },
+  { "2TLRL/UL;:", 1086800909UL, 1095659802UL, "10.0.1.7" },
+  { "WHD\\O1`ZRW", 3087923411UL, 3095471560UL, "10.0.1.5" },
+  { ".=54)_c;=T", 2497691631UL, 2502731301UL, "10.0.1.1" },
+  { ";G<W-XWZ@b", 2888169733UL, 2888728739UL, "10.0.1.5" },
+  { "(,>E`)FT\\4", 580747448UL, 581063326UL, "10.0.1.2" },
+  { "HZAU*;P*N]", 2564670474UL, 2565697267UL, "10.0.1.7" },
+  { "NZ@ZE=O84_", 533335275UL, 539988520UL, "10.0.1.7" },
+  { "6,cEI`F_P>", 3972869246UL, 3974773167UL, "10.0.1.6" },
+  { "c,5AQ/T5)6", 2835605783UL, 2847870057UL, "10.0.1.8" },
+  { ".O,>>BT)RX", 3857978174UL, 3871917949UL, "10.0.1.5" },
+  { "XY\\X::LX50", 1749241099UL, 1752196488UL, "10.0.1.6" },
+  { "+550F^/.01", 3781824099UL, 3783248219UL, "10.0.1.6" },
+  { "<.X9E2S5+9", 3232479481UL, 3234387706UL, "10.0.1.7" },
+  { "]\\.UH8_0a1", 2419699252UL, 2423002920UL, "10.0.1.4" },
+  { "8(6=(T0/Z0", 728266737UL, 729026070UL, "10.0.1.7" },
+  { "8*6a;Sc*X+", 4223431086UL, 4230156966UL, "10.0.1.2" },
+  { "<QW:;3K6;H", 2731158143UL, 2743975456UL, "10.0.1.5" },
+  { "7C@EY@-Y?_", 760770733UL, 761576669UL, "10.0.1.5" },
+  { "aPb3E1WD4K", 2500489218UL, 2502731301UL, "10.0.1.1" },
+  { "?@12R<=1BH", 1494795329UL, 1502505505UL, "10.0.1.8" },
+  { "QR(a+Q=1FU", 3238535074UL, 3238996435UL, "10.0.1.6" },
+  { "`C9^FV,960", 2628553463UL, 2628733766UL, "10.0.1.6" },
+  { "UNHVP..^8H", 977096483UL, 977319837UL, "10.0.1.4" },
+  { ":Y.2W2[(35", 2777083668UL, 2784182515UL, "10.0.1.7" },
+  { "M/HV^_HZ4O", 3623390946UL, 3624445007UL, "10.0.1.7" },
+  { "ZY16KQ<ICD", 1831153193UL, 1838563516UL, "10.0.1.4" },
+  { "bV2,`a.PY9", 1962228869UL, 1962648654UL, "10.0.1.1" },
+  { "U;9:-+5N]9", 269504649UL, 277560877UL, "10.0.1.1" },
+  { "1S/:aJ[1(;", 578069729UL, 581063326UL, "10.0.1.2" },
+  { "Nb-X^]M)I:", 330865696UL, 331009896UL, "10.0.1.6" },
+  { "2;M;ES>J5/", 2776949824UL, 2784182515UL, "10.0.1.7" },
+  { "[>RZHG97Q9", 71954686UL, 72034069UL, "10.0.1.6" },
+  { "J3/G[)9<^Z", 2799896459UL, 2805183696UL, "10.0.1.7" },
+  { "N-)88>[O`,", 50404102UL, 51792557UL, "10.0.1.5" },
+  { "NP:=FR\\OaA", 3837333776UL, 3837792034UL, "10.0.1.7" },
+  { "`@L+W;a,O[", 1512157148UL, 1522285852UL, "10.0.1.6" },
+  { "W2`P:-+1T[", 2945171975UL, 2946196424UL, "10.0.1.5" },
+  { "-6G7K^YDIN", 3168617340UL, 3170513015UL, "10.0.1.7" },
+  { "U>*>9ZI6V5", 668514946UL, 674097631UL, "10.0.1.6" },
+  { ".I?^6Ic9RK", 938419020UL, 942832691UL, "10.0.1.6" },
+  { "0OZH^9BKM[", 3682518606UL, 3686781297UL, "10.0.1.8" },
+  { "5?50UGZ:ML", 868610882UL, 869425986UL, "10.0.1.5" },
+  { "?K2NF@3=IU", 381218851UL, 383925769UL, "10.0.1.1" },
+  { "YI@G-2X?UB", 3688706179UL, 3693197681UL, "10.0.1.5" },
+  { "7cY</BSaL=", 3976870223UL, 3978903843UL, "10.0.1.6" },
+  { "A(`KF:[RH8", 3292979676UL, 3294849139UL, "10.0.1.6" },
+  { ";=ZT\\W^P+H", 1401102653UL, 1416290674UL, "10.0.1.4" },
+  { "b2?WFF56;R", 480494704UL, 486971192UL, "10.0.1.4" },
+  { "CTR74,J+N.", 137446045UL, 146633907UL, "10.0.1.8" },
+  { "<b;*R+QDST", 1304985302UL, 1308223778UL, "10.0.1.5" },
+  { "\\R^7=9UCG`", 126218373UL, 129199837UL, "10.0.1.5" },
+  { "1bQS5]WOXB", 1853470245UL, 1855329369UL, "10.0.1.4" },
+  { "M(@X^b[L:K", 3019630308UL, 3022260113UL, "10.0.1.1" },
+  { "431cBF8,YO", 1679726993UL, 1685224295UL, "10.0.1.7" },
+  { "(bEIQJ:E./", 2922607787UL, 2925521819UL, "10.0.1.6" },
+  { "WS/3H*)7F;", 419488232UL, 422140585UL, "10.0.1.5" },
+  { "ZJF[Ia6Q)+", 3960568056UL, 3962489998UL, "10.0.1.7" },
+  { "<]*QCK8U,>", 2590140172UL, 2598117636UL, "10.0.1.7" },
+  { "\\[a\\^=V_M0", 689410119UL, 698690782UL, "10.0.1.6" },
+  { "7;RM+8J9YC", 1530175299UL, 1531107082UL, "10.0.1.7" },
+  { "4*=.SPR[AV", 3928582722UL, 3928853792UL, "10.0.1.1" },
+  { "-2F+^88P4U", 3023552752UL, 3025823613UL, "10.0.1.7" },
+  { "X;-F`(N?9D", 570465234UL, 572485994UL, "10.0.1.7" },
+  { "R=F_D-K2a]", 1287750228UL, 1290935562UL, "10.0.1.7" },
+  { "X*+2aaC.EG", 3200948713UL, 3201088518UL, "10.0.1.5" },
+  { "[1ZXONX2]a", 4108881567UL, 4109865744UL, "10.0.1.4" },
+  { "FL;\\GWacaV", 458449508UL, 467374054UL, "10.0.1.4" },
+  { "\\MQ_XNT7L-", 1259349383UL, 1259509450UL, "10.0.1.7" },
+  { "VD6D0]ba_\\", 3842502950UL, 3842588691UL, "10.0.1.1" },
+};

data/ext/libmemcached-0.32/tests/output.cmp

@@ -0,0 +1,7 @@
+servers localhost:11221,localhost:11222,localhost:11223,localhost:11224,localhost:11225,
+	localhost : 11221
+	localhost : 11222
+	localhost : 11223
+	localhost : 11224
+	localhost : 11225
+

data/ext/libmemcached-0.32/tests/output.res

@@ -0,0 +1,7 @@
+servers localhost:11221,localhost:11222,localhost:11223,localhost:11224,localhost:11225,
+	localhost : 11221
+	localhost : 11222
+	localhost : 11223
+	localhost : 11224
+	localhost : 11225
+

data/ext/libmemcached-0.32/tests/output2.res

@@ -0,0 +1,46 @@
+Error 0 -> SUCCESS
+Error 1 -> FAILURE
+Error 2 -> HOSTNAME LOOKUP FAILURE
+Error 3 -> CONNECTION FAILURE
+Error 4 -> CONNECTION BIND FAILURE
+Error 5 -> WRITE FAILURE
+Error 6 -> READ FAILURE
+Error 7 -> UNKNOWN READ FAILURE
+Error 8 -> PROTOCOL ERROR
+Error 9 -> CLIENT ERROR
+Error 10 -> SERVER ERROR
+Error 11 -> CONNECTION SOCKET CREATE FAILURE
+Error 12 -> CONNECTION DATA EXISTS
+Error 13 -> CONNECTION DATA DOES NOT EXIST
+Error 14 -> NOT STORED
+Error 15 -> NOT FOUND
+Error 16 -> MEMORY ALLOCATION FAILURE
+Error 17 -> PARTIAL READ
+Error 18 -> SOME ERRORS WERE REPORTED
+Error 19 -> NO SERVERS DEFINED
+Found key pid
+Found key uptime
+Found key time
+Found key version
+Found key pointer_size
+Found key rusage_user
+Found key rusage_system
+Found key rusage_user_seconds
+Found key rusage_user_microseconds
+Found key rusage_system_seconds
+Found key rusage_system_microseconds
+Found key curr_items
+Found key total_items
+Found key bytes
+Found key curr_connections
+Found key total_connections
+Found key connection_structures
+Found key cmd_get
+Found key cmd_set
+Found key get_hits
+Found key get_misses
+Found key evictions
+Found key bytes_read
+Found key bytes_written
+Found key limit_maxbytes
+Found key threads

data/ext/libmemcached-0.32/tests/plus.cpp

@@ -0,0 +1,293 @@
+/*
+  C++ interface test
+*/
+#include "libmemcached/memcached.hpp"
+
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <time.h>
+#include "server.h"
+
+#include "test.h"
+
+#include <string>
+
+using namespace std;
+using namespace memcache;
+
+extern "C" {
+   test_return basic_test(memcached_st *memc);
+   test_return increment_test(memcached_st *memc);
+   test_return basic_master_key_test(memcached_st *memc);
+   test_return mget_result_function(memcached_st *memc);
+   test_return mget_test(memcached_st *memc);
+   memcached_return callback_counter(memcached_st *,
+                                     memcached_result_st *, 
+                                     void *context);
+   void *world_create(void);
+   void world_destroy(void *p);
+}
+
+static void populate_vector(vector<char> &vec, const string &str)
+{
+  vec.reserve(str.length());
+  vec.assign(str.begin(), str.end());
+}
+
+static void copy_vec_to_string(vector<char> &vec, string &str)
+{
+  str.clear();
+  if (! vec.empty())
+  {
+    str.assign(vec.begin(), vec.end());
+  }
+}
+
+test_return basic_test(memcached_st *memc)
+{
+  Memcache foo(memc);
+  const string value_set("This is some data");
+  std::vector<char> value;
+  std::vector<char> test_value;
+
+  populate_vector(value, value_set);
+
+  foo.set("mine", value, 0, 0);
+  foo.get("mine", test_value);
+
+  assert((memcmp(&test_value[0], &value[0], test_value.size()) == 0));
+
+  return TEST_SUCCESS;
+}
+
+test_return increment_test(memcached_st *memc)
+{
+  Memcache mcach(memc);
+  bool rc;
+  const string key("blah");
+  const string inc_value("1");
+  std::vector<char> inc_val;
+  vector<char> ret_value;
+  string ret_string;
+  uint64_t int_inc_value;
+  uint64_t int_ret_value;
+
+  populate_vector(inc_val, inc_value);
+
+  rc= mcach.set(key, inc_val, 0, 0);
+  if (rc == false)
+  {
+    return TEST_FAILURE;
+  }
+  mcach.get(key, ret_value);
+  if (ret_value.empty())
+  {
+    return TEST_FAILURE;
+  }
+  copy_vec_to_string(ret_value, ret_string);
+
+  int_inc_value= uint64_t(atol(inc_value.c_str()));
+  int_ret_value= uint64_t(atol(ret_string.c_str()));
+  assert(int_ret_value == int_inc_value); 
+
+  rc= mcach.increment(key, 1, &int_ret_value);
+  assert(rc == true);
+  assert(int_ret_value == 2);
+
+  rc= mcach.increment(key, 1, &int_ret_value);
+  assert(rc == true);
+  assert(int_ret_value == 3);
+
+  rc= mcach.increment(key, 5, &int_ret_value);
+  assert(rc == true);
+  assert(int_ret_value == 8);
+
+  return TEST_SUCCESS;
+}
+
+test_return basic_master_key_test(memcached_st *memc)
+{
+  Memcache foo(memc);
+  const string value_set("Data for server A");
+  vector<char> value;
+  vector<char> test_value;
+  const string master_key_a("server-a");
+  const string master_key_b("server-b");
+  const string key("xyz");
+
+  populate_vector(value, value_set);
+
+  foo.setByKey(master_key_a, key, value, 0, 0);
+  foo.getByKey(master_key_a, key, test_value);
+
+  assert((memcmp(&value[0], &test_value[0], value.size()) == 0));
+
+  test_value.clear();
+
+  foo.getByKey(master_key_b, key, test_value);
+  assert((memcmp(&value[0], &test_value[0], value.size()) == 0));
+
+  return TEST_SUCCESS;
+}
+
+/* Count the results */
+memcached_return callback_counter(memcached_st *,
+                                  memcached_result_st *, 
+                                  void *context)
+{
+  unsigned int *counter= static_cast<unsigned int *>(context);
+
+  *counter= *counter + 1;
+
+  return MEMCACHED_SUCCESS;
+}
+
+test_return mget_result_function(memcached_st *memc)
+{
+  Memcache mc(memc);
+  bool rc;
+  string key1("fudge");
+  string key2("son");
+  string key3("food");
+  vector<string> keys;
+  vector< vector<char> *> values;
+  vector<char> val1;
+  vector<char> val2;
+  vector<char> val3;
+  populate_vector(val1, key1);
+  populate_vector(val2, key2);
+  populate_vector(val3, key3);
+  keys.reserve(3);
+  keys.push_back(key1);
+  keys.push_back(key2);
+  keys.push_back(key3);
+  values.reserve(3);
+  values.push_back(&val1);
+  values.push_back(&val2);
+  values.push_back(&val3);
+  unsigned int counter;
+  memcached_execute_function callbacks[1];
+
+  /* We need to empty the server before we continue the test */
+  rc= mc.flush(0);
+  rc= mc.setAll(keys, values, 50, 9);
+  assert(rc == true);
+
+  rc= mc.mget(keys);
+  assert(rc == true);
+
+  callbacks[0]= &callback_counter;
+  counter= 0;
+  rc= mc.fetchExecute(callbacks, static_cast<void *>(&counter), 1); 
+
+  assert(counter == 3);
+
+  return TEST_SUCCESS;
+}
+
+test_return mget_test(memcached_st *memc)
+{
+  Memcache mc(memc);
+  bool rc;
+  memcached_return mc_rc;
+  vector<string> keys;
+  vector< vector<char> *> values;
+  keys.reserve(3);
+  keys.push_back("fudge");
+  keys.push_back("son");
+  keys.push_back("food");
+  vector<char> val1;
+  vector<char> val2;
+  vector<char> val3;
+  populate_vector(val1, "fudge");
+  populate_vector(val2, "son");
+  populate_vector(val3, "food");
+  values.reserve(3);
+  values.push_back(&val1);
+  values.push_back(&val2);
+  values.push_back(&val3);
+
+  string return_key;
+  vector<char> return_value;
+
+  /* We need to empty the server before we continue the test */
+  rc= mc.flush(0);
+  assert(rc == true);
+
+  rc= mc.mget(keys);
+  assert(rc == true);
+
+  while ((mc_rc= mc.fetch(return_key, return_value)) != MEMCACHED_END)
+  {
+    assert(return_value.size() != 0);
+    return_value.clear();
+  }
+  assert(mc_rc == MEMCACHED_END);
+
+  rc= mc.setAll(keys, values, 50, 9);
+  assert(rc == true);
+
+  rc= mc.mget(keys);
+  assert(rc == true);
+
+  while ((mc_rc= mc.fetch(return_key, return_value)) != MEMCACHED_END)
+  {
+    assert(return_key.length() == return_value.size());
+    assert(!memcmp(&return_value[0], return_key.c_str(), return_value.size()));
+  }
+
+  return TEST_SUCCESS;
+}
+
+test_st tests[] ={
+  { "basic", 0, basic_test },
+  { "basic_master_key", 0, basic_master_key_test },
+  { "increment_test", 0, increment_test },
+  { "mget", 1, mget_test },
+  { "mget_result_function", 1, mget_result_function },
+  {0, 0, 0}
+};
+
+collection_st collection[] ={
+  {"block", 0, 0, tests},
+  {0, 0, 0, 0}
+};
+
+#define SERVERS_TO_CREATE 1
+
+extern "C" void *world_create(void)
+{
+  server_startup_st *construct;
+
+  construct= (server_startup_st *)malloc(sizeof(server_startup_st));
+  memset(construct, 0, sizeof(server_startup_st));
+
+  construct->count= SERVERS_TO_CREATE;
+  server_startup(construct);
+
+  return construct;
+}
+
+void world_destroy(void *p)
+{
+  server_startup_st *construct= static_cast<server_startup_st *>(p);
+  memcached_server_st *servers=
+    static_cast<memcached_server_st *>(construct->servers);
+  memcached_server_list_free(servers);
+
+  server_shutdown(construct);
+  free(construct);
+}
+
+void get_world(world_st *world)
+{
+  world->collections= collection;
+  world->create= world_create;
+  world->destroy= world_destroy;
+}