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

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