On success, we should exit the loop.

[m6w6/libmemcached] / tests / plus.cpp

diff --git a/tests/plus.cpp b/tests/plus.cpp
index 3bc85bc1a8632526e08e77ea873bd419afbec377..d9d00ad1604713910cc329adeb6d047aefccd83f 100644 (file)
--- a/tests/plus.cpp
+++ b/tests/plus.cpp
@@ -40,7 +40,7 @@
 /*
   C++ interface test
 */
-#include <libmemcached/memcached.hpp>
+#include <libmemcached-1.0/memcached.hpp>
 #include <libtest/test.hpp>
 
 #include <cstdio>
@@ -59,18 +59,6 @@ using namespace std;
 using namespace memcache;
 using namespace libtest;
 
-extern "C" {
-   test_return_t basic_test(memcached_st *memc);
-   test_return_t increment_test(memcached_st *memc);
-   test_return_t basic_master_key_test(memcached_st *memc);
-   test_return_t mget_result_function(memcached_st *memc);
-   test_return_t basic_behavior(memcached_st *memc);
-   test_return_t mget_test(memcached_st *memc);
-   memcached_return_t callback_counter(const memcached_st *,
-                                       memcached_result_st *,
-                                       void *context);
-}
-
 static void populate_vector(vector<char> &vec, const string &str)
 {
   vec.reserve(str.length());
@@ -86,7 +74,7 @@ static void copy_vec_to_string(vector<char> &vec, string &str)
   }
 }
 
-test_return_t basic_test(memcached_st *memc)
+static test_return_t basic_test(memcached_st *memc)
 {
   Memcache foo(memc);
   const string value_set("This is some data");
@@ -104,7 +92,7 @@ test_return_t basic_test(memcached_st *memc)
   return TEST_SUCCESS;
 }
 
-test_return_t increment_test(memcached_st *original)
+static test_return_t increment_test(memcached_st *original)
 {
   Memcache mcach(original);
   const string key("blah");
@@ -139,7 +127,7 @@ test_return_t increment_test(memcached_st *original)
   return TEST_SUCCESS;
 }
 
-test_return_t basic_master_key_test(memcached_st *original)
+static test_return_t basic_master_key_test(memcached_st *original)
 {
   Memcache foo(original);
   const string value_set("Data for server A");
@@ -167,19 +155,7 @@ test_return_t basic_master_key_test(memcached_st *original)
   return TEST_SUCCESS;
 }
 
-/* Count the results */
-memcached_return_t callback_counter(const memcached_st *,
-                                    memcached_result_st *,
-                                    void *context)
-{
-  unsigned int *counter= static_cast<unsigned int *>(context);
-
-  *counter= *counter +1;
-
-  return MEMCACHED_SUCCESS;
-}
-
-test_return_t mget_test(memcached_st *original)
+static test_return_t mget_test(memcached_st *original)
 {
   Memcache memc(original);
   memcached_return_t mc_rc;
@@ -226,7 +202,7 @@ test_return_t mget_test(memcached_st *original)
   return TEST_SUCCESS;
 }
 
-test_return_t basic_behavior(memcached_st *original)
+static test_return_t basic_behavior(memcached_st *original)
 {
   Memcache memc(original);
   uint64_t value= 1;
@@ -237,22 +213,70 @@ test_return_t basic_behavior(memcached_st *original)
   return TEST_SUCCESS;
 }
 
+static test_return_t error_test(memcached_st *)
+{
+  Memcache memc("--server=localhost:0");
+  std::vector<char> value;
+
+  test_false(memc.set("key", value, time_t(0), uint32_t(0)));
+
+  test_true(memc.error());
+
+  return TEST_SUCCESS;
+}
+
+static test_return_t error_std_string_test(memcached_st *)
+{
+  Memcache memc("--server=localhost:0");
+  std::vector<char> value;
+
+  test_false(memc.set("key", value, time_t(0), uint32_t(0)));
+
+  std::string error_message;
+  test_true(memc.error(error_message));
+  test_false(error_message.empty());
+
+  return TEST_SUCCESS;
+}
+
+static test_return_t error_memcached_return_t_test(memcached_st *)
+{
+  Memcache memc("--server=localhost:0");
+  std::vector<char> value;
+
+  test_false(memc.set("key", value, time_t(0), uint32_t(0)));
+
+  memcached_return_t rc;
+  test_true(memc.error(rc));
+  test_compare(MEMCACHED_CONNECTION_FAILURE, rc);
+
+  return TEST_SUCCESS;
+}
+
+test_st error_tests[] ={
+  { "error()", false, reinterpret_cast<test_callback_fn*>(error_test) },
+  { "error(std::string&)", false, reinterpret_cast<test_callback_fn*>(error_std_string_test) },
+  { "error(memcached_return_t&)", false, reinterpret_cast<test_callback_fn*>(error_memcached_return_t_test) },
+  {0, 0, 0}
+};
+
 test_st tests[] ={
-  { "basic", 0,
+  { "basic", false,
     reinterpret_cast<test_callback_fn*>(basic_test) },
-  { "basic_master_key", 0,
+  { "basic_master_key", false,
     reinterpret_cast<test_callback_fn*>(basic_master_key_test) },
-  { "increment_test", 0,
+  { "increment_test", false,
     reinterpret_cast<test_callback_fn*>(increment_test) },
-  { "mget", 1,
+  { "mget", true,
     reinterpret_cast<test_callback_fn*>(mget_test) },
-  { "basic_behavior", 0,
+  { "basic_behavior", false,
     reinterpret_cast<test_callback_fn*>(basic_behavior) },
   {0, 0, 0}
 };
 
 collection_st collection[] ={
   {"block", 0, 0, tests},
+  {"error()", 0, 0, error_tests},
   {0, 0, 0, 0}
 };