Fix all include location, and drop versions of the library that were never shipped.

[awesomized/libmemcached] / tests / libmemcached-1.0 / encoding_key.cc

diff --git a/tests/libmemcached-1.0/encoding_key.cc b/tests/libmemcached-1.0/encoding_key.cc
index 114de1f1a6bd711dfca3ffff89d00dbc5d0b7811..8d3e0dbc1ab58c7012f8827112cdda31e590cba0 100644 (file)
--- a/tests/libmemcached-1.0/encoding_key.cc
+++ b/tests/libmemcached-1.0/encoding_key.cc
@@ -39,7 +39,7 @@
 #include <libtest/test.hpp>
 
 #include <libmemcached-1.0/memcached.h>
-#include <libmemcached/util.h>
+#include <libmemcachedutil-1.0/util.h>
 
 #include "tests/libmemcached-1.0/encoding_key.h"
 
@@ -58,12 +58,11 @@ test_return_t memcached_set_encoding_key_set_get_TEST(memcached_st* memc)
   test_true(memc_no_crypt);
   test_compare(MEMCACHED_SUCCESS, memcached_set_encoding_key(memc, test_literal_param(__func__)));
 
-  test_compare_hint(MEMCACHED_SUCCESS, memcached_set(memc,
-                                                     test_literal_param(__func__), // Key
-                                                     test_literal_param(__func__), // Value
-                                                     time_t(0),
-                                                     uint32_t(0)),
-                    memcached_last_error_message(memc));
+  test_compare(MEMCACHED_SUCCESS, memcached_set(memc,
+                                                test_literal_param(__func__), // Key
+                                                test_literal_param(__func__), // Value
+                                                time_t(0),
+                                                uint32_t(0)));
 
   {
     memcached_return_t rc;
@@ -98,12 +97,11 @@ test_return_t memcached_set_encoding_key_add_get_TEST(memcached_st* memc)
 {
   test_compare(MEMCACHED_SUCCESS, memcached_set_encoding_key(memc, test_literal_param(__func__)));
 
-  test_compare_hint(MEMCACHED_SUCCESS, memcached_add(memc,
+  test_compare(MEMCACHED_SUCCESS, memcached_add(memc,
                                                      test_literal_param(__func__), // Key
                                                      test_literal_param(__func__), // Value
                                                      time_t(0),
-                                                     uint32_t(0)),
-                    memcached_last_error_message(memc));
+                                                     uint32_t(0)));
 
   {
     memcached_return_t rc;
@@ -127,12 +125,11 @@ test_return_t memcached_set_encoding_key_replace_get_TEST(memcached_st* memc)
 
   // First we add the key
   {
-    test_compare_hint(MEMCACHED_SUCCESS, memcached_add(memc,
-                                                       test_literal_param(__func__), // Key
-                                                       test_literal_param(__func__), // Value
-                                                       time_t(0),
-                                                       uint32_t(0)),
-                      memcached_last_error_message(memc));
+    test_compare(MEMCACHED_SUCCESS, memcached_add(memc,
+                                                  test_literal_param(__func__), // Key
+                                                  test_literal_param(__func__), // Value
+                                                  time_t(0),
+                                                  uint32_t(0)));
 
     memcached_return_t rc;
     size_t value_length;
@@ -151,12 +148,11 @@ test_return_t memcached_set_encoding_key_replace_get_TEST(memcached_st* memc)
     libtest::vchar_t new_value;
     vchar::make(new_value);
 
-    test_compare_hint(MEMCACHED_SUCCESS, memcached_replace(memc,
-                                                           test_literal_param(__func__), // Key
-                                                           vchar_param(new_value), // Value
-                                                           time_t(0),
-                                                           uint32_t(0)),
-                      memcached_last_error_message(memc));
+    test_compare(MEMCACHED_SUCCESS, memcached_replace(memc,
+                                                      test_literal_param(__func__), // Key
+                                                      vchar_param(new_value), // Value
+                                                      time_t(0),
+                                                      uint32_t(0)));
 
     memcached_return_t rc;
     size_t value_length;
@@ -261,12 +257,11 @@ test_return_t memcached_set_encoding_key_set_get_clone_TEST(memcached_st* memc)
   memcached_st *memc_crypt= memcached_clone(NULL, memc);
   test_true(memc_crypt);
 
-  test_compare_hint(MEMCACHED_SUCCESS, memcached_set(memc,
+  test_compare(MEMCACHED_SUCCESS, memcached_set(memc,
                                                      test_literal_param(__func__), // Key
                                                      test_literal_param(__func__), // Value
                                                      time_t(0),
-                                                     uint32_t(0)),
-                    memcached_last_error_message(memc));
+                                                     uint32_t(0)));
 
   {
     memcached_return_t rc;
@@ -317,3 +312,64 @@ test_return_t memcached_set_encoding_key_set_get_clone_TEST(memcached_st* memc)
 
   return TEST_SUCCESS;
 }
+
+test_return_t memcached_set_encoding_key_set_grow_key_TEST(memcached_st* memc)
+{
+  memcached_st *memc_no_crypt= memcached_clone(NULL, memc);
+  test_true(memc_no_crypt);
+  test_compare(MEMCACHED_SUCCESS, memcached_set_encoding_key(memc, test_literal_param(__func__)));
+
+  size_t payload_size[] = { 100, 1000, 10000, 1000000, 1000000, 0 };
+  libtest::vchar_t payload;
+  for (size_t *ptr= payload_size; *ptr; ptr++)
+  {
+    payload.reserve(*ptr);
+    for (size_t x= payload.size(); x < *ptr; x++)
+    { 
+      payload.push_back(rand());
+    }
+
+    {
+      memcached_return_t rc= memcached_set(memc,
+                                           test_literal_param(__func__), // Key
+                                           &payload[0], payload.size(), // Value
+                                           time_t(0),
+                                           uint32_t(0));
+
+      // If we run out of space on the server, we just end the test early.
+      if (rc == MEMCACHED_SERVER_MEMORY_ALLOCATION_FAILURE)
+      {
+        break;
+      }
+      test_compare(MEMCACHED_SUCCESS, rc);
+    }
+
+    {
+      memcached_return_t rc;
+      size_t value_length;
+      char *value;
+      test_true((value= memcached_get(memc,
+                                      test_literal_param(__func__), // Key
+                                      &value_length, NULL, &rc)));
+      test_compare(MEMCACHED_SUCCESS, rc);
+      test_compare(payload.size(), value_length);
+      test_memcmp(&payload[0], value, value_length);
+
+      size_t raw_value_length;
+      char *raw_value;
+      test_true((raw_value= memcached_get(memc_no_crypt,
+                                          test_literal_param(__func__), // Key
+                                          &raw_value_length, NULL, &rc)));
+      test_compare(MEMCACHED_SUCCESS, rc);
+      test_ne_compare(payload.size(), raw_value_length);
+      test_ne_compare(0, memcmp(&payload[0], raw_value, raw_value_length));
+
+      free(value);
+      free(raw_value);
+    }
+  }
+
+  memcached_free(memc_no_crypt);
+
+  return TEST_SUCCESS;
+}