Na}{

File Content: `hash_plus.cc`

/*
  C++ to libhashkit
*/

#include <mem_config.h>

#include <libtest/test.hpp>

#include <cstdio>
#include <cstdlib>
#include <cstring>

#include <libhashkit-1.0/hashkit.hpp>

using namespace libtest;

#include "tests/hash_results.h"

static test_return_t exists_test(void *)
{
  Hashkit hashk;
  (void)hashk;

  return TEST_SUCCESS;
}

static test_return_t new_test(void *)
{
  Hashkit *hashk= new Hashkit;

  (void)hashk;

  delete hashk;

  return TEST_SUCCESS;
}

static test_return_t copy_test(void *)
{
  Hashkit *hashk= new Hashkit;
  Hashkit *copy(hashk);

  (void)copy;

  delete hashk;

  return TEST_SUCCESS;
}

static test_return_t assign_test(void *)
{
  Hashkit hashk;
  Hashkit copy;

  copy= hashk;

  (void)copy;

  return TEST_SUCCESS;
}

static test_return_t digest_test(void *)
{
  Hashkit hashk;
  test_true(hashk.digest("Foo", sizeof("Foo")));

  return TEST_SUCCESS;
}

static test_return_t set_function_test(void *)
{
  Hashkit hashk;
  hashkit_hash_algorithm_t algo_list[]= { 
    HASHKIT_HASH_DEFAULT,
    HASHKIT_HASH_MD5,
    HASHKIT_HASH_CRC,
    HASHKIT_HASH_FNV1_64,
    HASHKIT_HASH_FNV1A_64,
    HASHKIT_HASH_FNV1_32,
    HASHKIT_HASH_FNV1A_32,
    HASHKIT_HASH_MURMUR,
    HASHKIT_HASH_JENKINS,
    HASHKIT_HASH_MAX
  };


  for (hashkit_hash_algorithm_t *algo= algo_list; *algo != HASHKIT_HASH_MAX; algo++)
  {
    hashkit_return_t rc= hashk.set_function(*algo);

    if (rc == HASHKIT_INVALID_ARGUMENT)
    {
      continue;
    }

    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_MURMUR3:
#ifdef WORDS_BIGENDIAN
      continue;
#endif
      list= murmur3_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:
      list= NULL;
      test_fail("We ended up on a non-existent hash");
    }

    // 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));
      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 *)
{
  Hashkit hashk;
  hashkit_return_t rc;

  rc= hashk.set_distribution_function(HASHKIT_HASH_CUSTOM);
  test_true(rc == HASHKIT_FAILURE or rc == HASHKIT_INVALID_ARGUMENT);

  test_compare(HASHKIT_SUCCESS,
               hashk.set_distribution_function(HASHKIT_HASH_JENKINS));

  return TEST_SUCCESS;
}

static test_return_t compare_function_test(void *)
{
  Hashkit a, b;

  b= a;
  
  test_true(a == b);

  b.set_function(HASHKIT_HASH_MURMUR);

  test_false(a == b);
  test_true(b == b);
  test_true(a == a);

  return TEST_SUCCESS;
}

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) },
  { 0, 0, 0}
};

collection_st collection[] ={
  {"basic", 0, 0, basic},
  {0, 0, 0, 0}
};

void get_world(libtest::Framework* world)
{
  world->collections(collection);
}

Name	Size	Permission
basic.h	2227 bytes	0644
callbacks.h	1881 bytes	0644
cpp_example.cc	3618 bytes	0644
cycle.cc	4176 bytes	0644
debug.h	2139 bytes	0644
deprecated.h	1912 bytes	0644
error_conditions.h	1836 bytes	0644
exist.h	1910 bytes	0644
failure.cc	7931 bytes	0644
hash_plus.cc	4441 bytes	0644
hash_results.h	6848 bytes	0644
hashkit_functions.cc	14149 bytes	0644
ketama.h	1903 bytes	0644
ketama_test_cases.h	6283 bytes	0644
ketama_test_cases_spy.h	6251 bytes	0644
libmemcached_test_container.h	2338 bytes	0644
libmemcached_world.h	3167 bytes	0644
libmemcached_world_socket.h	2916 bytes	0644
mem_udp.cc	18145 bytes	0644
memcapable.cc	3586 bytes	0644
memcat.cc	4441 bytes	0644
memcp.cc	3345 bytes	0644
memdump.cc	3851 bytes	0644
memerror.cc	3475 bytes	0644
memexist.cc	4762 bytes	0644
memflush.cc	3291 bytes	0644
memping.cc	3412 bytes	0644
memrm.cc	5037 bytes	0644
memslap.cc	6142 bytes	0644
memstat.cc	3841 bytes	0644
memtouch.cc	4821 bytes	0644
namespace.h	1770 bytes	0644
parser.cc	3338 bytes	0644
pool.h	1980 bytes	0644
print.h	2192 bytes	0644
replication.h	2209 bytes	0644
runner.h	4787 bytes	0644
server_add.h	1956 bytes	0644
string.h	2218 bytes	0644
touch.h	1802 bytes	0644
virtual_buckets.h	1863 bytes	0644

File Content: hash_plus.cc

File Content: `hash_plus.cc`