1 /* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3 * libHashKit Functions Test
5 * Copyright (C) 2011 Data Differential, http://datadifferential.com/
6 * Copyright (C) 2006-2009 Brian Aker All rights reserved.
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions are
12 * * Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
15 * * Redistributions in binary form must reproduce the above
16 * copyright notice, this list of conditions and the following disclaimer
17 * in the documentation and/or other materials provided with the
20 * * The names of its contributors may not be used to endorse or
21 * promote products derived from this software without specific prior
24 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
25 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
26 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
27 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
28 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
29 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
30 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
31 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
32 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
33 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
34 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
45 #include <libhashkit/hashkit.h>
47 #include <libtest/test.hpp>
49 #include "hash_results.h"
51 static hashkit_st global_hashk
;
54 @brief hash_test_st is a structure we use in testing. It is currently empty.
56 typedef struct hash_test_st hash_test_st
;
63 static test_return_t
init_test(void *not_used
)
66 hashkit_st
*hashk_ptr
;
69 hashk_ptr
= hashkit_create(&hashk
);
71 test_true(hashk_ptr
== &hashk
);
72 test_true(hashkit_is_allocated(hashk_ptr
) == false);
74 hashkit_free(hashk_ptr
);
79 static test_return_t
allocation_test(void *not_used
)
81 hashkit_st
*hashk_ptr
;
84 hashk_ptr
= hashkit_create(NULL
);
86 test_true(hashkit_is_allocated(hashk_ptr
) == true);
87 hashkit_free(hashk_ptr
);
92 static test_return_t
clone_test(hashkit_st
*hashk
)
94 // First we make sure that the testing system is giving us what we expect.
95 assert(&global_hashk
== hashk
);
97 // Second we test if hashk is even valid
101 hashkit_st
*hashk_ptr
;
102 hashk_ptr
= hashkit_clone(NULL
, NULL
);
103 test_true(hashk_ptr
);
104 test_true(hashkit_is_allocated(hashk_ptr
));
105 hashkit_free(hashk_ptr
);
108 /* Can we init from null? */
110 hashkit_st
*hashk_ptr
;
112 hashk_ptr
= hashkit_clone(NULL
, hashk
);
114 test_true(hashk_ptr
);
115 test_true(hashkit_is_allocated(hashk_ptr
));
117 hashkit_free(hashk_ptr
);
120 /* Can we init from struct? */
122 hashkit_st declared_clone
;
123 hashkit_st
*hash_clone
;
125 hash_clone
= hashkit_clone(&declared_clone
, NULL
);
126 test_true(hash_clone
);
127 test_true(hash_clone
== &declared_clone
);
128 test_false(hashkit_is_allocated(hash_clone
));
130 hashkit_free(hash_clone
);
133 /* Can we init from struct? */
135 hashkit_st declared_clone
;
136 hashkit_st
*hash_clone
;
138 hash_clone
= hashkit_clone(&declared_clone
, hashk
);
139 test_true(hash_clone
);
140 test_true(hash_clone
== &declared_clone
);
141 test_false(hashkit_is_allocated(hash_clone
));
143 hashkit_free(hash_clone
);
149 static test_return_t
one_at_a_time_run (hashkit_st
*hashk
)
155 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
159 hash_val
= libhashkit_one_at_a_time(*ptr
, strlen(*ptr
));
160 test_true(one_at_a_time_values
[x
] == hash_val
);
166 static test_return_t
md5_run (hashkit_st
*hashk
)
172 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
176 hash_val
= libhashkit_md5(*ptr
, strlen(*ptr
));
177 test_true(md5_values
[x
] == hash_val
);
183 static test_return_t
crc_run (hashkit_st
*hashk
)
189 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
193 hash_val
= libhashkit_crc32(*ptr
, strlen(*ptr
));
194 assert(crc_values
[x
] == hash_val
);
200 static test_return_t
fnv1_64_run (hashkit_st
*hashk
)
206 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
210 hash_val
= libhashkit_fnv1_64(*ptr
, strlen(*ptr
));
211 assert(fnv1_64_values
[x
] == hash_val
);
217 static test_return_t
fnv1a_64_run (hashkit_st
*hashk
)
223 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
227 hash_val
= libhashkit_fnv1a_64(*ptr
, strlen(*ptr
));
228 assert(fnv1a_64_values
[x
] == hash_val
);
234 static test_return_t
fnv1_32_run (hashkit_st
*hashk
)
240 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
244 hash_val
= libhashkit_fnv1_32(*ptr
, strlen(*ptr
));
245 assert(fnv1_32_values
[x
] == hash_val
);
251 static test_return_t
fnv1a_32_run (hashkit_st
*hashk
)
257 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
261 hash_val
= libhashkit_fnv1a_32(*ptr
, strlen(*ptr
));
262 assert(fnv1a_32_values
[x
] == hash_val
);
268 static test_return_t
hsieh_run (hashkit_st
*hashk
)
274 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
278 #ifdef HAVE_HSIEH_HASH
279 hash_val
= libhashkit_hsieh(*ptr
, strlen(*ptr
));
283 assert(hsieh_values
[x
] == hash_val
);
289 static test_return_t
murmur_run (hashkit_st
*hashk
)
293 #ifdef WORDS_BIGENDIAN
300 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
304 #ifdef HAVE_MURMUR_HASH
305 hash_val
= libhashkit_murmur(*ptr
, strlen(*ptr
));
309 assert(murmur_values
[x
] == hash_val
);
316 static test_return_t
jenkins_run (hashkit_st
*hashk
)
322 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
326 hash_val
= libhashkit_jenkins(*ptr
, strlen(*ptr
));
327 assert(jenkins_values
[x
] == hash_val
);
337 @brief now we list out the tests.
340 test_st allocation
[]= {
341 {"init", 0, (test_callback_fn
*)init_test
},
342 {"create and free", 0, (test_callback_fn
*)allocation_test
},
343 {"clone", 0, (test_callback_fn
*)clone_test
},
347 static test_return_t
hashkit_digest_test(hashkit_st
*hashk
)
350 value
= hashkit_digest(hashk
, "a", sizeof("a"));
355 static test_return_t
hashkit_set_function_test(hashkit_st
*hashk
)
357 for (int algo
= int(HASHKIT_HASH_DEFAULT
); algo
< int(HASHKIT_HASH_MAX
); algo
++)
363 hashkit_return_t rc
= hashkit_set_function(hashk
, static_cast<hashkit_hash_algorithm_t
>(algo
));
365 /* Hsieh is disabled most of the time for patent issues */
366 #ifndef HAVE_HSIEH_HASH
367 if (rc
== HASHKIT_FAILURE
&& algo
== HASHKIT_HASH_HSIEH
)
371 #ifndef HAVE_MURMUR_HASH
372 if (rc
== HASHKIT_FAILURE
&& algo
== HASHKIT_HASH_MURMUR
)
376 if (rc
== HASHKIT_INVALID_ARGUMENT
&& algo
== HASHKIT_HASH_CUSTOM
)
379 test_true_got(rc
== HASHKIT_SUCCESS
, hashkit_strerror(NULL
, rc
));
383 case HASHKIT_HASH_DEFAULT
:
384 list
= one_at_a_time_values
;
386 case HASHKIT_HASH_MD5
:
389 case HASHKIT_HASH_CRC
:
392 case HASHKIT_HASH_FNV1_64
:
393 list
= fnv1_64_values
;
395 case HASHKIT_HASH_FNV1A_64
:
396 list
= fnv1a_64_values
;
398 case HASHKIT_HASH_FNV1_32
:
399 list
= fnv1_32_values
;
401 case HASHKIT_HASH_FNV1A_32
:
402 list
= fnv1a_32_values
;
404 case HASHKIT_HASH_HSIEH
:
407 case HASHKIT_HASH_MURMUR
:
410 case HASHKIT_HASH_JENKINS
:
411 list
= jenkins_values
;
413 case HASHKIT_HASH_CUSTOM
:
414 case HASHKIT_HASH_MAX
:
420 // Now we make sure we did set the hash correctly.
423 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
427 hash_val
= hashkit_digest(hashk
, *ptr
, strlen(*ptr
));
428 test_true(list
[x
] == hash_val
);
440 static uint32_t hash_test_function(const char *string
, size_t string_length
, void *context
)
443 return libhashkit_md5(string
, string_length
);
446 static test_return_t
hashkit_set_custom_function_test(hashkit_st
*hashk
)
453 rc
= hashkit_set_custom_function(hashk
, hash_test_function
, NULL
);
454 test_true(rc
== HASHKIT_SUCCESS
);
456 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
460 hash_val
= hashkit_digest(hashk
, *ptr
, strlen(*ptr
));
461 test_true(md5_values
[x
] == hash_val
);
467 static test_return_t
hashkit_set_distribution_function_test(hashkit_st
*hashk
)
469 for (int algo
= int(HASHKIT_HASH_DEFAULT
); algo
< int(HASHKIT_HASH_MAX
); algo
++)
471 hashkit_return_t rc
= hashkit_set_distribution_function(hashk
, static_cast<hashkit_hash_algorithm_t
>(algo
));
473 /* Hsieh is disabled most of the time for patent issues */
474 if (rc
== HASHKIT_FAILURE
&& algo
== HASHKIT_HASH_HSIEH
)
477 if (rc
== HASHKIT_INVALID_ARGUMENT
&& algo
== HASHKIT_HASH_CUSTOM
)
480 test_true(rc
== HASHKIT_SUCCESS
);
486 static test_return_t
hashkit_set_custom_distribution_function_test(hashkit_st
*hashk
)
488 hashkit_return_t rc
= hashkit_set_custom_distribution_function(hashk
, hash_test_function
, NULL
);
489 test_true(rc
== HASHKIT_SUCCESS
);
495 static test_return_t
hashkit_get_function_test(hashkit_st
*hashk
)
497 for (int algo
= int(HASHKIT_HASH_DEFAULT
); algo
< int(HASHKIT_HASH_MAX
); algo
++)
500 if (HASHKIT_HASH_CUSTOM
or HASHKIT_HASH_HSIEH
)
503 hashkit_return_t rc
= hashkit_set_function(hashk
, static_cast<hashkit_hash_algorithm_t
>(algo
));
504 test_true(rc
== HASHKIT_SUCCESS
);
506 test_true(hashkit_get_function(hashk
) == algo
);
511 static test_return_t
hashkit_compare_test(hashkit_st
*hashk
)
513 hashkit_st
*clone
= hashkit_clone(NULL
, hashk
);
515 test_true(hashkit_compare(clone
, hashk
));
521 test_st hashkit_st_functions
[] ={
522 {"hashkit_digest", 0, (test_callback_fn
*)hashkit_digest_test
},
523 {"hashkit_set_function", 0, (test_callback_fn
*)hashkit_set_function_test
},
524 {"hashkit_set_custom_function", 0, (test_callback_fn
*)hashkit_set_custom_function_test
},
525 {"hashkit_get_function", 0, (test_callback_fn
*)hashkit_get_function_test
},
526 {"hashkit_set_distribution_function", 0, (test_callback_fn
*)hashkit_set_distribution_function_test
},
527 {"hashkit_set_custom_distribution_function", 0, (test_callback_fn
*)hashkit_set_custom_distribution_function_test
},
528 {"hashkit_compare", 0, (test_callback_fn
*)hashkit_compare_test
},
532 static test_return_t
libhashkit_digest_test(hashkit_st
*hashk
)
537 uint32_t value
= libhashkit_digest("a", sizeof("a"), HASHKIT_HASH_DEFAULT
);
543 test_st library_functions
[] ={
544 {"libhashkit_digest", 0, (test_callback_fn
*)libhashkit_digest_test
},
548 test_st hash_tests
[] ={
549 {"one_at_a_time", 0, (test_callback_fn
*)one_at_a_time_run
},
550 {"md5", 0, (test_callback_fn
*)md5_run
},
551 {"crc", 0, (test_callback_fn
*)crc_run
},
552 {"fnv1_64", 0, (test_callback_fn
*)fnv1_64_run
},
553 {"fnv1a_64", 0, (test_callback_fn
*)fnv1a_64_run
},
554 {"fnv1_32", 0, (test_callback_fn
*)fnv1_32_run
},
555 {"fnv1a_32", 0, (test_callback_fn
*)fnv1a_32_run
},
556 {"hsieh", 0, (test_callback_fn
*)hsieh_run
},
557 {"murmur", 0, (test_callback_fn
*)murmur_run
},
558 {"jenkis", 0, (test_callback_fn
*)jenkins_run
},
559 {0, 0, (test_callback_fn
*)0}
563 * The following test suite is used to verify that we don't introduce
564 * regression bugs. If you want more information about the bug / test,
565 * you should look in the bug report at
566 * http://bugs.launchpad.net/libmemcached
568 test_st regression
[]= {
572 collection_st collection
[] ={
573 {"allocation", 0, 0, allocation
},
574 {"hashkit_st_functions", 0, 0, hashkit_st_functions
},
575 {"library_functions", 0, 0, library_functions
},
576 {"hashing", 0, 0, hash_tests
},
577 {"regression", 0, 0, regression
},
581 /* Prototypes for functions we will pass to test framework */
582 void *world_create(test_return_t
*error
);
583 test_return_t
world_destroy(hashkit_st
*hashk
);
585 void *world_create(test_return_t
*error
)
587 hashkit_st
*hashk_ptr
= hashkit_create(&global_hashk
);
589 if (hashk_ptr
!= &global_hashk
)
591 *error
= TEST_FAILURE
;
595 if (hashkit_is_allocated(hashk_ptr
) == true)
597 *error
= TEST_FAILURE
;
601 *error
= TEST_SUCCESS
;
607 test_return_t
world_destroy(hashkit_st
*hashk
)
609 // Did we get back what we expected?
610 assert(hashkit_is_allocated(hashk
) == false);
611 hashkit_free(&global_hashk
);
616 void get_world(Framework
*world
)
618 world
->collections
= collection
;
619 world
->_create
= (test_callback_create_fn
*)world_create
;
620 world
->_destroy
= (test_callback_fn
*)world_destroy
;