Import/Merge of libtest latest.

[m6w6/libmemcached] / tests / hash_plus.cc

diff --git a/tests/hash_plus.cc b/tests/hash_plus.cc
index c148d3effd10528ac8cf427ef6bc4447a02df93d..19c77c3822e11f92281a918f60df6273d2d495e0 100644 (file)
--- a/tests/hash_plus.cc
+++ b/tests/hash_plus.cc
@@ -1,29 +1,32 @@
 /*
   C++ to libhashkit
 */
-#include <libtest/test.h>
 
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
+#include <config.h>
 
-#include <libhashkit/hashkit.h>
+#include <libtest/test.hpp>
 
-#include "hash_results.h"
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
 
-static test_return_t exists_test(void *obj)
+#include <libhashkit-1.0/hashkit.hpp>
+
+using namespace libtest;
+
+#include "tests/hash_results.h"
+
+static test_return_t exists_test(void *)
 {
   Hashkit hashk;
-  (void)obj;
   (void)hashk;
 
   return TEST_SUCCESS;
 }
 
-static test_return_t new_test(void *obj)
+static test_return_t new_test(void *)
 {
   Hashkit *hashk= new Hashkit;
-  (void)obj;
 
   (void)hashk;
 
@@ -32,11 +35,10 @@ static test_return_t new_test(void *obj)
   return TEST_SUCCESS;
 }
 
-static test_return_t copy_test(void *obj)
+static test_return_t copy_test(void *)
 {
   Hashkit *hashk= new Hashkit;
   Hashkit *copy(hashk);
-  (void)obj;
 
   (void)copy;
 
@@ -45,11 +47,10 @@ static test_return_t copy_test(void *obj)
   return TEST_SUCCESS;
 }
 
-static test_return_t assign_test(void *obj)
+static test_return_t assign_test(void *)
 {
   Hashkit hashk;
   Hashkit copy;
-  (void)obj;
 
   copy= hashk;
 
@@ -58,18 +59,15 @@ static test_return_t assign_test(void *obj)
   return TEST_SUCCESS;
 }
 
-static test_return_t digest_test(void *obj)
+static test_return_t digest_test(void *)
 {
   Hashkit hashk;
-  uint32_t value;
-  (void)obj;
-
-  value= hashk.digest("Foo", sizeof("Foo"));
+  test_true(hashk.digest("Foo", sizeof("Foo")));
 
   return TEST_SUCCESS;
 }
 
-static test_return_t set_function_test(void *obj)
+static test_return_t set_function_test(void *)
 {
   Hashkit hashk;
   hashkit_hash_algorithm_t algo_list[]= { 
@@ -84,53 +82,65 @@ static test_return_t set_function_test(void *obj)
     HASHKIT_HASH_JENKINS,
     HASHKIT_HASH_MAX
   };
-  hashkit_hash_algorithm_t *algo;
-  (void)obj;
 
 
-  for (algo= algo_list; *algo != HASHKIT_HASH_MAX; algo++)
+  for (hashkit_hash_algorithm_t *algo= algo_list; *algo != HASHKIT_HASH_MAX; algo++)
   {
-    hashkit_return_t rc;
-    uint32_t x;
-    const char **ptr;
-    uint32_t *list;
+    hashkit_return_t rc= hashk.set_function(*algo);
 
-    rc= hashk.set_function(*algo);
+    if (rc == HASHKIT_INVALID_ARGUMENT)
+    {
+      continue;
+    }
 
-    test_true(rc == HASHKIT_SUCCESS);
+    test_compare(HASHKIT_SUCCESS, rc);
 
+    uint32_t *list;
     switch (*algo)
     {
     case HASHKIT_HASH_DEFAULT:
       list= one_at_a_time_values;
       break;
+
     case HASHKIT_HASH_MD5:
       list= md5_values;
       break;
+
     case HASHKIT_HASH_CRC:
       list= crc_values;
       break;
+
     case HASHKIT_HASH_FNV1_64:
       list= fnv1_64_values;
       break;
+
     case HASHKIT_HASH_FNV1A_64:
       list= fnv1a_64_values;
       break;
+
     case HASHKIT_HASH_FNV1_32:
       list= fnv1_32_values;
       break;
+
     case HASHKIT_HASH_FNV1A_32:
       list= fnv1a_32_values;
       break;
+
     case HASHKIT_HASH_HSIEH:
       list= hsieh_values;
       break;
+
     case HASHKIT_HASH_MURMUR:
+#ifdef WORDS_BIGENDIAN
+      continue;
+#endif
       list= murmur_values;
       break;
+
     case HASHKIT_HASH_JENKINS:
       list= jenkins_values;
       break;
+
     case HASHKIT_HASH_CUSTOM:
     case HASHKIT_HASH_MAX:
     default:
@@ -139,37 +149,39 @@ static test_return_t set_function_test(void *obj)
     }
 
     // Now we make sure we did set the hash correctly.
+    uint32_t x;
+    const char **ptr;
     for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
     {
       uint32_t hash_val;
 
       hash_val= hashk.digest(*ptr, strlen(*ptr));
-      test_true(list[x] == hash_val);
+      char buffer[1024];
+      snprintf(buffer, sizeof(buffer), "%lu %lus %s", (unsigned long)list[x], (unsigned long)hash_val, libhashkit_string_hash(*algo));
+      test_compare(list[x], hash_val);
     }
   }
 
   return TEST_SUCCESS;
 }
 
-static test_return_t set_distribution_function_test(void *obj)
+static test_return_t set_distribution_function_test(void *)
 {
   Hashkit hashk;
   hashkit_return_t rc;
-  (void)obj;
 
   rc= hashk.set_distribution_function(HASHKIT_HASH_CUSTOM);
-  test_true(rc == HASHKIT_FAILURE);
+  test_true(rc == HASHKIT_FAILURE or rc == HASHKIT_INVALID_ARGUMENT);
 
-  rc= hashk.set_distribution_function(HASHKIT_HASH_JENKINS);
-  test_true(rc == HASHKIT_SUCCESS);
+  test_compare(HASHKIT_SUCCESS,
+               hashk.set_distribution_function(HASHKIT_HASH_JENKINS));
 
   return TEST_SUCCESS;
 }
 
-static test_return_t compare_function_test(void *obj)
+static test_return_t compare_function_test(void *)
 {
   Hashkit a, b;
-  (void)obj;
 
   b= a;
   
@@ -185,14 +197,14 @@ static test_return_t compare_function_test(void *obj)
 }
 
 test_st basic[] ={
-  { "exists", 0, reinterpret_cast<test_callback_fn>(exists_test) },
-  { "new", 0, reinterpret_cast<test_callback_fn>(new_test) },
-  { "copy", 0, reinterpret_cast<test_callback_fn>(copy_test) },
-  { "assign", 0, reinterpret_cast<test_callback_fn>(assign_test) },
-  { "digest", 0, reinterpret_cast<test_callback_fn>(digest_test) },
-  { "set_function", 0, reinterpret_cast<test_callback_fn>(set_function_test) },
-  { "set_distribution_function", 0, reinterpret_cast<test_callback_fn>(set_distribution_function_test) },
-  { "compare", 0, reinterpret_cast<test_callback_fn>(compare_function_test) },
+  { "exists", 0, reinterpret_cast<test_callback_fn*>(exists_test) },
+  { "new", 0, reinterpret_cast<test_callback_fn*>(new_test) },
+  { "copy", 0, reinterpret_cast<test_callback_fn*>(copy_test) },
+  { "assign", 0, reinterpret_cast<test_callback_fn*>(assign_test) },
+  { "digest", 0, reinterpret_cast<test_callback_fn*>(digest_test) },
+  { "set_function", 0, reinterpret_cast<test_callback_fn*>(set_function_test) },
+  { "set_distribution_function", 0, reinterpret_cast<test_callback_fn*>(set_distribution_function_test) },
+  { "compare", 0, reinterpret_cast<test_callback_fn*>(compare_function_test) },
   { 0, 0, 0}
 };
 
@@ -201,7 +213,7 @@ collection_st collection[] ={
   {0, 0, 0, 0}
 };
 
-void get_world(world_st *world)
+void get_world(Framework *world)
 {
-  world->collections= collection;
+  world->collections(collection);
 }