git.m6w6.name Git - m6w6/libmemcached/blob - tests/hash_plus.cc

   1 /*
   2   C++ to libhashkit
   3 */
   4 #include <libtest/test.h>
   5
   6 #include <cstdio>
   7 #include <cstdlib>
   8 #include <cstring>
   9
  10 #include <libhashkit/hashkit.h>
  11
  12 #include "hash_results.h"
  13
  14 static test_return_t exists_test(void *obj)
  15 {
  16   Hashkit hashk;
  17   (void)obj;
  18   (void)hashk;
  19
  20   return TEST_SUCCESS;
  21 }
  22
  23 static test_return_t new_test(void *obj)
  24 {
  25   Hashkit *hashk= new Hashkit;
  26   (void)obj;
  27
  28   (void)hashk;
  29
  30   delete hashk;
  31
  32   return TEST_SUCCESS;
  33 }
  34
  35 static test_return_t copy_test(void *obj)
  36 {
  37   Hashkit *hashk= new Hashkit;
  38   Hashkit *copy(hashk);
  39   (void)obj;
  40
  41   (void)copy;
  42
  43   delete hashk;
  44
  45   return TEST_SUCCESS;
  46 }
  47
  48 static test_return_t assign_test(void *obj)
  49 {
  50   Hashkit hashk;
  51   Hashkit copy;
  52   (void)obj;
  53
  54   copy= hashk;
  55
  56   (void)copy;
  57
  58   return TEST_SUCCESS;
  59 }
  60
  61 static test_return_t digest_test(void *obj)
  62 {
  63   Hashkit hashk;
  64   uint32_t value;
  65   (void)obj;
  66
  67   value= hashk.digest("Foo", sizeof("Foo"));
  68
  69   return TEST_SUCCESS;
  70 }
  71
  72 static test_return_t set_function_test(void *)
  73 {
  74   Hashkit hashk;
  75   hashkit_hash_algorithm_t algo_list[]= {
  76     HASHKIT_HASH_DEFAULT,
  77     HASHKIT_HASH_MD5,
  78     HASHKIT_HASH_CRC,
  79     HASHKIT_HASH_FNV1_64,
  80     HASHKIT_HASH_FNV1A_64,
  81     HASHKIT_HASH_FNV1_32,
  82     HASHKIT_HASH_FNV1A_32,
  83     HASHKIT_HASH_MURMUR,
  84     HASHKIT_HASH_JENKINS,
  85     HASHKIT_HASH_MAX
  86   };
  87
  88
  89   for (hashkit_hash_algorithm_t *algo= algo_list; *algo != HASHKIT_HASH_MAX; algo++)
  90   {
  91     hashkit_return_t rc= hashk.set_function(*algo);
  92
  93     test_true(rc == HASHKIT_SUCCESS);
  94
  95     uint32_t *list;
  96     switch (*algo)
  97     {
  98     case HASHKIT_HASH_DEFAULT:
  99       list= one_at_a_time_values;
 100       break;
 101     case HASHKIT_HASH_MD5:
 102       list= md5_values;
 103       break;
 104     case HASHKIT_HASH_CRC:
 105       list= crc_values;
 106       break;
 107     case HASHKIT_HASH_FNV1_64:
 108       list= fnv1_64_values;
 109       break;
 110     case HASHKIT_HASH_FNV1A_64:
 111       list= fnv1a_64_values;
 112       break;
 113     case HASHKIT_HASH_FNV1_32:
 114       list= fnv1_32_values;
 115       break;
 116     case HASHKIT_HASH_FNV1A_32:
 117       list= fnv1a_32_values;
 118       break;
 119     case HASHKIT_HASH_HSIEH:
 120 #ifndef HAVE_HSIEH_HASH
 121       continue;
 122 #endif
 123       list= hsieh_values;
 124       break;
 125     case HASHKIT_HASH_MURMUR:
 126 #ifdef WORDS_BIGENDIAN
 127       continue;
 128 #endif
 129 #ifndef HAVE_MURMUR_HASH
 130       continue;
 131 #endif
 132       list= murmur_values;
 133       break;
 134     case HASHKIT_HASH_JENKINS:
 135       list= jenkins_values;
 136       break;
 137     case HASHKIT_HASH_CUSTOM:
 138     case HASHKIT_HASH_MAX:
 139     default:
 140       list= NULL;
 141       test_fail("We ended up on a non-existent hash");
 142     }
 143
 144     // Now we make sure we did set the hash correctly.
 145     uint32_t x;
 146     const char **ptr;
 147     for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
 148     {
 149       uint32_t hash_val;
 150
 151       hash_val= hashk.digest(*ptr, strlen(*ptr));
 152       char buffer[1024];
 153       snprintf(buffer, sizeof(buffer), "%lu %lus %s", (unsigned long)list[x], (unsigned long)hash_val, libhashkit_string_hash(*algo));
 154       test_true_got(list[x] == hash_val, buffer);
 155     }
 156   }
 157
 158   return TEST_SUCCESS;
 159 }
 160
 161 static test_return_t set_distribution_function_test(void *obj)
 162 {
 163   Hashkit hashk;
 164   hashkit_return_t rc;
 165   (void)obj;
 166
 167   rc= hashk.set_distribution_function(HASHKIT_HASH_CUSTOM);
 168   test_true_got(rc == HASHKIT_FAILURE or rc == HASHKIT_INVALID_ARGUMENT, hashkit_strerror(NULL, rc));
 169
 170   rc= hashk.set_distribution_function(HASHKIT_HASH_JENKINS);
 171   test_true(rc == HASHKIT_SUCCESS);
 172
 173   return TEST_SUCCESS;
 174 }
 175
 176 static test_return_t compare_function_test(void *obj)
 177 {
 178   Hashkit a, b;
 179   (void)obj;
 180
 181   b= a;
 182
 183   test_true(a == b);
 184
 185   b.set_function(HASHKIT_HASH_MURMUR);
 186
 187   test_false(a == b);
 188   test_true(b == b);
 189   test_true(a == a);
 190
 191   return TEST_SUCCESS;
 192 }
 193
 194 test_st basic[] ={
 195   { "exists", 0, reinterpret_cast<test_callback_fn>(exists_test) },
 196   { "new", 0, reinterpret_cast<test_callback_fn>(new_test) },
 197   { "copy", 0, reinterpret_cast<test_callback_fn>(copy_test) },
 198   { "assign", 0, reinterpret_cast<test_callback_fn>(assign_test) },
 199   { "digest", 0, reinterpret_cast<test_callback_fn>(digest_test) },
 200   { "set_function", 0, reinterpret_cast<test_callback_fn>(set_function_test) },
 201   { "set_distribution_function", 0, reinterpret_cast<test_callback_fn>(set_distribution_function_test) },
 202   { "compare", 0, reinterpret_cast<test_callback_fn>(compare_function_test) },
 203   { 0, 0, 0}
 204 };
 205
 206 collection_st collection[] ={
 207   {"basic", 0, 0, basic},
 208   {0, 0, 0, 0}
 209 };
 210
 211 void get_world(world_st *world)
 212 {
 213   world->collections= collection;
 214 }