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

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