X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=tests%2Fplus.cpp;h=1b5631d144fc29e6b7a81c2d31fac9b236db86ce;hb=1805d9d7e2c959f92c28057b7cfadcd48ba9a68a;hp=aed34a4960f4079c03416e99f37f64efcae46a1f;hpb=91e92172731fe8a37e562a165d25a312569aff44;p=m6w6%2Flibmemcached

diff --git a/tests/plus.cpp b/tests/plus.cpp
index aed34a49..1b5631d1 100644
--- a/tests/plus.cpp
+++ b/tests/plus.cpp
@@ -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,27 +213,76 @@ 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}
 };
 
 #define SERVERS_TO_CREATE 5
 
+#define TEST_PORT_BASE MEMCACHED_DEFAULT_PORT +10
 #include "libmemcached_world.h"
 
 void get_world(Framework *world)