Merge lp:~brianaker/libmemcached/1220229 into lp:libmemcached/1.0

[Brian Aker]

=== modified file 'clients/generator.cc'
--- clients/generator.cc	2013-01-08 01:03:28 +0000
+++ clients/generator.cc	2013-09-15 07:21:23 +0000
@@ -22,6 +22,8 @@
 
 #include "clients/generator.h"
 
+#define KEY_BYTES 20
+
 /* Use this for string generation */
 static const char ALPHANUMERICS[]=
   "0123456789ABCDEFGHIJKLMNOPQRSTWXYZabcdefghijklmnopqrstuvwxyz";
@@ -75,13 +77,13 @@
 
   for (uint64_t x= 0; x < number_of; x++)
   {
-    pairs[x].key= (char *)calloc(100, sizeof(char));
+    pairs[x].key= (char *)calloc(KEY_BYTES, sizeof(char));
 
     if (pairs[x].key == NULL)
       goto error;
 
-    get_random_string(pairs[x].key, 100);
-    pairs[x].key_length= 100;
+    get_random_string(pairs[x].key, KEY_BYTES);
+    pairs[x].key_length= KEY_BYTES;
 
     if (value_length)
     {

=== modified file 'clients/memcp.cc'
--- clients/memcp.cc	2013-05-03 20:00:36 +0000
+++ clients/memcp.cc	2013-09-15 07:21:23 +0000
@@ -1,5 +1,5 @@
 /* LibMemcached
- * Copyright (C) 2011-2012 Data Differential, http://datadifferential.com/
+ * Copyright (C) 2011-2013 Data Differential, http://datadifferential.com/
  * Copyright (C) 2006-2009 Brian Aker
  * All rights reserved.
  *

=== modified file 'clients/memslap.cc'
--- clients/memslap.cc	2013-03-13 03:23:07 +0000
+++ clients/memslap.cc	2013-09-15 07:21:23 +0000
@@ -66,6 +66,8 @@
 #define DEFAULT_EXECUTE_NUMBER 10000
 #define DEFAULT_CONCURRENCY 1
 
+#define VALUE_BYTES 4096
+
 #define PROGRAM_NAME "memslap"
 #define PROGRAM_DESCRIPTION "Generates a load against a memcached custer of servers."
 
@@ -336,7 +338,7 @@
 
     if (opt_test == SET_TEST)
     {
-      context->execute_pairs= pairs_generate(opt_execute_number, 400);
+      context->execute_pairs= pairs_generate(opt_execute_number, VALUE_BYTES);
       context->execute_number= opt_execute_number;
     }
 
@@ -432,7 +434,7 @@
       break;
 
     case OPT_DEBUG: /* --debug or -d */
-      opt_verbose = OPT_DEBUG;
+      opt_verbose= OPT_DEBUG;
       break;
 
     case OPT_VERSION: /* --version or -V */
@@ -566,7 +568,7 @@
   /* We always used non-blocking IO for load since it is faster */
   memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_NO_BLOCK, 0);
 
-  pairs_st *pairs= pairs_generate(number_of, 400);
+  pairs_st *pairs= pairs_generate(number_of, VALUE_BYTES);
   *actual_loaded= execute_set(memc_clone, pairs, number_of);
 
   memcached_free(memc_clone);

=== modified file 'docs/memcached_auto.rst'
--- docs/memcached_auto.rst	2012-03-08 07:13:01 +0000
+++ docs/memcached_auto.rst	2013-09-15 07:21:23 +0000
@@ -53,7 +53,8 @@
 expiration values, the operation will succeed by seeding the value for that
 key with a initial value to expire with the provided expiration time. The
 flags will be set to zero.The value is then returned via the uint32_t
-value pointer you pass to it.
+value pointer you pass to it. memcached_increment_with_initial is only available 
+when using the binary protocol.
 
 memcached_decrement_with_initial takes a key and keylength and decrements
 the value by the offset passed to it. If the object specified by key does
@@ -62,7 +63,8 @@
 expiration values, the operation will succeed by seeding the value for that
 key with a initial value to expire with the provided expiration time. The
 flags will be set to zero.The value is then returned via the uint32_t
-value pointer you pass to it.
+value pointer you pass to it. memcached_decrement_with_initial is only available
+when using the binary protocol.
 
 :c:func:`memcached_increment_by_key`, :c:func:`memcached_decrement_by_key`,
 :c:func:`memcached_increment_with_initial_by_key`, and

=== modified file 'libmemcached/auto.cc'
--- libmemcached/auto.cc	2013-03-31 23:24:29 +0000
+++ libmemcached/auto.cc	2013-09-15 07:21:23 +0000
@@ -54,11 +54,17 @@
 
   if (memcached_fatal(rc))
   {
+    fprintf(stderr, "%s:%d %s\n", __FILE__, __LINE__, memcached_strerror(NULL, rc));
     assert(memcached_last_error(instance->root) != MEMCACHED_SUCCESS);
     *value= UINT64_MAX;
   }
+  else if (memcached_failed(rc))
+  {
+    *value= UINT64_MAX;
+  }
   else
   {
+    assert(memcached_last_error(instance->root) != MEMCACHED_NOTFOUND);
     *value= instance->root->result.numeric_value;
   }
 }

=== modified file 'libtest/main.cc'
--- libtest/main.cc	2013-07-18 10:28:37 +0000
+++ libtest/main.cc	2013-09-15 07:21:23 +0000
@@ -2,7 +2,7 @@
  *
  *  Data Differential YATL (i.e. libtest)  library
  *
- *  Copyright (C) 2012 Data Differential, http://datadifferential.com/
+ *  Copyright (C) 2012-2013 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
@@ -43,6 +43,9 @@
 #include <ctime>
 #include <fnmatch.h>
 #include <iostream>
+#ifdef HAVE_STRINGS_H
+# include <strings.h>
+#endif
 #include <fstream>
 #include <memory>
 #include <sys/stat.h>

=== modified file 'tests/libmemcached-1.0/all_tests.h'
--- tests/libmemcached-1.0/all_tests.h	2013-02-23 21:43:42 +0000
+++ tests/libmemcached-1.0/all_tests.h	2013-09-15 07:21:23 +0000
@@ -70,9 +70,11 @@
   {"partial mget", false, (test_callback_fn*)get_test5 },
   {"stats_servername", false, (test_callback_fn*)stats_servername_test },
   {"increment", false, (test_callback_fn*)increment_test },
-  {"increment_with_initial", true, (test_callback_fn*)increment_with_initial_test },
+  {"memcached_increment_with_initial(0)", true, (test_callback_fn*)increment_with_initial_test },
+  {"memcached_increment_with_initial(999)", true, (test_callback_fn*)increment_with_initial_999_test },
   {"decrement", false, (test_callback_fn*)decrement_test },
-  {"decrement_with_initial", true, (test_callback_fn*)decrement_with_initial_test },
+  {"memcached_decrement_with_initial(3)", true, (test_callback_fn*)decrement_with_initial_test },
+  {"memcached_decrement_with_initial(999)", true, (test_callback_fn*)decrement_with_initial_999_test },
   {"increment_by_key", false, (test_callback_fn*)increment_by_key_test },
   {"increment_with_initial_by_key", true, (test_callback_fn*)increment_with_initial_by_key_test },
   {"decrement_by_key", false, (test_callback_fn*)decrement_by_key_test },

=== modified file 'tests/libmemcached-1.0/mem_functions.cc'
--- tests/libmemcached-1.0/mem_functions.cc	2013-04-20 04:14:00 +0000
+++ tests/libmemcached-1.0/mem_functions.cc	2013-09-15 07:21:23 +0000
@@ -1294,24 +1294,39 @@
   return TEST_SUCCESS;
 }
 
+static test_return_t __increment_with_initial_test(memcached_st *memc, uint64_t initial)
+{
+  uint64_t new_number;
+
+  test_compare(MEMCACHED_SUCCESS, memcached_flush_buffers(memc));
+
+  if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL))
+  {
+    test_compare(MEMCACHED_SUCCESS, 
+                 memcached_increment_with_initial(memc, test_literal_param("number"), 1, initial, 0, &new_number));
+    test_compare(new_number, initial);
+
+    test_compare(MEMCACHED_SUCCESS, 
+                 memcached_increment_with_initial(memc, test_literal_param("number"), 1, initial, 0, &new_number));
+    test_compare(new_number, (initial +1));
+  }
+  else
+  {
+    test_compare(MEMCACHED_INVALID_ARGUMENTS, 
+                 memcached_increment_with_initial(memc, test_literal_param("number"), 1, initial, 0, &new_number));
+  }
+
+  return TEST_SUCCESS;
+}
+
 test_return_t increment_with_initial_test(memcached_st *memc)
 {
-  test_skip(true, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL));
-
-  uint64_t new_number;
-  uint64_t initial= 0;
-
-  test_compare(MEMCACHED_SUCCESS, memcached_flush_buffers(memc));
-
-  test_compare(MEMCACHED_SUCCESS, 
-               memcached_increment_with_initial(memc, test_literal_param("number"), 1, initial, 0, &new_number));
-  test_compare(new_number, initial);
-
-  test_compare(MEMCACHED_SUCCESS, 
-               memcached_increment_with_initial(memc, test_literal_param("number"), 1, initial, 0, &new_number));
-  test_compare(new_number, (initial +1));
-
-  return TEST_SUCCESS;
+  return __increment_with_initial_test(memc, 0);
+}
+
+test_return_t increment_with_initial_999_test(memcached_st *memc)
+{
+  return __increment_with_initial_test(memc, 999);
 }
 
 test_return_t decrement_test(memcached_st *memc)
@@ -1341,30 +1356,38 @@
   return TEST_SUCCESS;
 }
 
+static test_return_t __decrement_with_initial_test(memcached_st *memc, uint64_t initial)
+{
+  test_skip(true, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL));
+
+  test_compare(MEMCACHED_SUCCESS, memcached_flush_buffers(memc));
+
+  uint64_t new_number;
+  test_compare(MEMCACHED_SUCCESS,
+               memcached_decrement_with_initial(memc,
+                                                test_literal_param(__func__),
+                                                1, initial, 
+                                                0, &new_number));
+  test_compare(new_number, initial);
+
+  test_compare(MEMCACHED_SUCCESS,
+               memcached_decrement_with_initial(memc,
+                                                test_literal_param(__func__),
+                                                1, initial, 
+                                                0, &new_number));
+  test_compare(new_number, (initial - 1));
+
+  return TEST_SUCCESS;
+}
+
 test_return_t decrement_with_initial_test(memcached_st *memc)
 {
-  test_skip(true, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL));
-
-  uint64_t initial= 3;
-
-  test_compare(MEMCACHED_SUCCESS, memcached_flush_buffers(memc));
-
-  uint64_t new_number;
-  test_compare(MEMCACHED_SUCCESS,
-               memcached_decrement_with_initial(memc,
-                                                test_literal_param(__func__),
-                                                1, initial, 
-                                                0, &new_number));
-  test_compare(new_number, initial);
-
-  test_compare(MEMCACHED_SUCCESS,
-               memcached_decrement_with_initial(memc,
-                                                test_literal_param(__func__),
-                                                1, initial, 
-                                                0, &new_number));
-  test_compare(new_number, (initial - 1));
-
-  return TEST_SUCCESS;
+  return __decrement_with_initial_test(memc, 3);
+}
+
+test_return_t decrement_with_initial_999_test(memcached_st *memc)
+{
+  return __decrement_with_initial_test(memc, 999);
 }
 
 test_return_t increment_by_key_test(memcached_st *memc)
@@ -1398,24 +1421,32 @@
 
 test_return_t increment_with_initial_by_key_test(memcached_st *memc)
 {
-  test_skip(true, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL));
-
   uint64_t new_number;
   const char *master_key= "foo";
   const char *key= "number";
   uint64_t initial= 0;
 
-  test_compare(MEMCACHED_SUCCESS,
-               memcached_increment_with_initial_by_key(memc, master_key, strlen(master_key),
-                                                       key, strlen(key),
-                                                       1, initial, 0, &new_number));
-  test_compare(new_number, initial);
+  if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL))
+  {
+    test_compare(MEMCACHED_SUCCESS,
+                 memcached_increment_with_initial_by_key(memc, master_key, strlen(master_key),
+                                                         key, strlen(key),
+                                                         1, initial, 0, &new_number));
+    test_compare(new_number, initial);
 
-  test_compare(MEMCACHED_SUCCESS,
-               memcached_increment_with_initial_by_key(memc, master_key, strlen(master_key),
-                                                       key, strlen(key),
-                                                       1, initial, 0, &new_number));
-  test_compare(new_number, (initial +1));
+    test_compare(MEMCACHED_SUCCESS,
+                 memcached_increment_with_initial_by_key(memc, master_key, strlen(master_key),
+                                                         key, strlen(key),
+                                                         1, initial, 0, &new_number));
+    test_compare(new_number, (initial +1));
+  }
+  else
+  {
+    test_compare(MEMCACHED_INVALID_ARGUMENTS,
+                 memcached_increment_with_initial_by_key(memc, master_key, strlen(master_key),
+                                                         key, strlen(key),
+                                                         1, initial, 0, &new_number));
+  }
 
   return TEST_SUCCESS;
 }
@@ -1456,19 +1487,30 @@
   uint64_t new_number;
   uint64_t initial= 3;
 
-  test_compare(MEMCACHED_SUCCESS,
-               memcached_decrement_with_initial_by_key(memc,
-                                                       test_literal_param("foo"),
-                                                       test_literal_param("number"),
-                                                       1, initial, 0, &new_number));
-  test_compare(new_number, initial);
+  if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL))
+  {
+    test_compare(MEMCACHED_SUCCESS,
+                 memcached_decrement_with_initial_by_key(memc,
+                                                         test_literal_param("foo"),
+                                                         test_literal_param("number"),
+                                                         1, initial, 0, &new_number));
+    test_compare(new_number, initial);
 
-  test_compare(MEMCACHED_SUCCESS,
-               memcached_decrement_with_initial_by_key(memc,
-                                                       test_literal_param("foo"),
-                                                       test_literal_param("number"),
-                                                       1, initial, 0, &new_number));
-  test_compare(new_number, (initial - 1));
+    test_compare(MEMCACHED_SUCCESS,
+                 memcached_decrement_with_initial_by_key(memc,
+                                                         test_literal_param("foo"),
+                                                         test_literal_param("number"),
+                                                         1, initial, 0, &new_number));
+    test_compare(new_number, (initial - 1));
+  }
+  else
+  {
+    test_compare(MEMCACHED_INVALID_ARGUMENTS,
+                 memcached_decrement_with_initial_by_key(memc,
+                                                         test_literal_param("foo"),
+                                                         test_literal_param("number"),
+                                                         1, initial, 0, &new_number));
+  }
 
   return TEST_SUCCESS;
 }

=== modified file 'tests/libmemcached-1.0/mem_functions.h'
--- tests/libmemcached-1.0/mem_functions.h	2013-02-23 21:43:42 +0000
+++ tests/libmemcached-1.0/mem_functions.h	2013-09-15 07:21:23 +0000
@@ -67,6 +67,7 @@
 test_return_t decrement_test(memcached_st *memc);
 test_return_t decrement_with_initial_by_key_test(memcached_st *memc);
 test_return_t decrement_with_initial_test(memcached_st *memc);
+test_return_t decrement_with_initial_999_test(memcached_st *memc);
 test_return_t delete_test(memcached_st *memc);
 test_return_t deprecated_set_memory_alloc(memcached_st *memc);
 test_return_t enable_cas(memcached_st *memc);
@@ -88,6 +89,7 @@
 test_return_t increment_test(memcached_st *memc);
 test_return_t increment_with_initial_by_key_test(memcached_st *memc);
 test_return_t increment_with_initial_test(memcached_st *memc);
+test_return_t increment_with_initial_999_test(memcached_st *memc);
 test_return_t init_test(memcached_st *not_used);
 test_return_t jenkins_run (memcached_st *);
 test_return_t key_setup(memcached_st *memc);