//#include <cgreen/cgreen.h>
|
#include "shmht.h"
|
#include <string.h>
|
#include<stdlib.h>
|
#include <stdio.h>
|
#include <math.h>
|
#include <assert.h>
|
|
/*dbj2 hash function:*/
|
unsigned int
|
dbj2_hash (void *str_)
|
{
|
unsigned long hash = 5381;
|
char *str = (char *) str_;
|
int c;
|
|
while (0 != (c = *str++))
|
hash = ((hash << 5) + hash) + c; /* hash * 33 + c */
|
|
return (unsigned int) hash;
|
}
|
|
/* comparison function: */
|
int
|
str_compar (void *c1, void *c2)
|
{
|
char *c1_str = (char *) c1;
|
return !bcmp (c1, c2, strlen (c1_str));
|
}
|
|
|
/*
|
* \test-name check_create_from_NotExistentFile
|
* \test-function test_check_create_from_NotExistentFile
|
*/
|
void
|
test_check_create_from_NotExistentFile ()
|
{
|
size_t key_size = 100;
|
struct shmht *h1 =
|
create_shmht ("Not_Exists_file", 16, key_size, dbj2_hash, str_compar);
|
assert(h1 == NULL);
|
} // test_check_create_from_NotExistentFile
|
|
|
/*
|
* \test-name check_create_HTs
|
* \test-function test_check_create_HTs
|
*/
|
void
|
test_check_create_HTs ()
|
{
|
struct shmht *h1 = NULL;
|
struct shmht *h2 = NULL;
|
size_t key_size = 100;
|
|
h1 = create_shmht ("run_tests", 16, key_size, dbj2_hash, str_compar);
|
//assert_not_equal (h1, NULL);
|
assert (h1 != NULL);
|
|
h2 = create_shmht ("run_tests", 16, key_size, dbj2_hash, str_compar);
|
//assert_not_equal (h2, NULL);
|
assert (h2 != NULL);
|
|
//Destroy the global shmht
|
shmht_destroy (h1);
|
shmht_destroy (h2);
|
|
//Free the two references
|
free (h1);
|
free (h2);
|
} // test_check_create_HTs
|
|
|
/*
|
* \test-name check_create_when_inserted
|
* \test-function test_check_create_when_inserted
|
*/
|
void
|
test_check_create_when_inserted ()
|
{
|
struct shmht *h1 = NULL;
|
struct shmht *h2 = NULL;
|
char *key = "Key_for_test_check_find";
|
char *stored_value = "This is the stored Value!";
|
size_t key_size = 100;
|
|
h1 = create_shmht ("run_tests", 16, key_size, dbj2_hash, str_compar);
|
assert(h1 != NULL);
|
|
int shmht_insert_ret = shmht_insert (h1, key, strlen (key)
|
, stored_value,
|
strlen (stored_value) + 1);
|
assert(shmht_insert_ret > 0);
|
|
h2 = create_shmht ("run_tests", 16, key_size, dbj2_hash, str_compar);
|
assert (h2 != NULL);
|
|
//Check that after creation the existing entries are still there.
|
assert(shmht_count (h2) == 0);
|
assert(shmht_count (h1) == 1);
|
|
//Destroy the global shmht
|
shmht_destroy (h1);
|
shmht_destroy (h2);
|
|
//Free the two references
|
free (h1);
|
free (h2);
|
|
} // test_check_create_when_inserted
|
|
/*
|
* \test-name check_find
|
* \test-function test_check_find
|
*/
|
void
|
test_check_find ()
|
{
|
struct shmht *h1 = NULL;
|
struct shmht *h2 = NULL;
|
struct shmht *h3 = NULL;
|
struct shmht *h4 = NULL;
|
char *key = "Key_for_test_check_find";
|
char *stored_value = "This is the stored Value!";
|
size_t key_size = 100;
|
|
h1 = create_shmht ("run_tests", 16, key_size, dbj2_hash, str_compar);
|
assert(h1 != NULL);
|
|
h2 = create_shmht ("run_tests", 16, key_size, dbj2_hash, str_compar);
|
assert(h2 != NULL);
|
|
h3 = create_shmht ("run_tests", 16, key_size, dbj2_hash, str_compar);
|
assert(h3 != NULL);
|
|
h4 = create_shmht ("run_tests", 16, key_size, dbj2_hash, str_compar);
|
assert(h4 != NULL);
|
|
int shmht_insert_ret = shmht_insert (h1, key, strlen (key) , stored_value, strlen (stored_value) + 1);
|
assert(shmht_insert_ret > 0);
|
|
size_t ret_size;
|
void *ret = shmht_search (h1, key, strlen (key), &ret_size);
|
|
assert(ret != NULL);
|
assert(strlen (stored_value) + 1 == ret_size);
|
assert(!strncmp (ret, stored_value, strlen (stored_value) + 1));
|
|
shmht_insert_ret = shmht_insert (h2, key, strlen (key), stored_value, strlen (stored_value) + 1);
|
assert(shmht_insert_ret > 0);
|
ret = shmht_search(h2, key, strlen (key), &ret_size);
|
|
assert(ret != NULL);
|
assert(strlen (stored_value) + 1 == ret_size);
|
assert(!strncmp (ret, stored_value, strlen (stored_value)));
|
|
shmht_insert_ret = shmht_insert (h3, key, strlen (key), stored_value, strlen (stored_value) + 1);
|
assert(shmht_insert_ret > 0);
|
ret = shmht_search(h3, key, strlen (key), &ret_size);
|
|
assert(ret != NULL);
|
assert(strlen (stored_value) + 1 == ret_size);
|
assert(!strncmp (ret, stored_value, strlen (stored_value)));
|
|
shmht_insert_ret = shmht_insert (h4, key, strlen (key), stored_value, strlen (stored_value) + 1);
|
assert(shmht_insert_ret > 0);
|
ret = shmht_search(h4, key, strlen (key), &ret_size);
|
|
assert(ret != NULL);
|
assert(strlen (stored_value) + 1 == ret_size);
|
assert(!strncmp (ret, stored_value, strlen (stored_value)));
|
|
|
//Destroy the global shmht
|
shmht_destroy (h1);
|
shmht_destroy (h2);
|
shmht_destroy (h3);
|
shmht_destroy (h4);
|
|
//Free the two references
|
free (h1);
|
free (h2);
|
free (h3);
|
free (h4);
|
|
} // test_check_find
|
|
/*
|
* \test-name check_count
|
* \test-function test_check_count
|
*/
|
void
|
test_check_count ()
|
{
|
char *key = "Key_for_test_check_count";
|
char *stored_value = "This is the stored Value!";
|
size_t key_size = 100;
|
|
//Create a shmht.
|
struct shmht *h =
|
create_shmht ("run_tests", 16, key_size, dbj2_hash, str_compar);
|
assert(h != NULL);
|
|
|
//Insert a value into.
|
int shmht_insert_ret = shmht_insert (h, key, strlen (key)
|
, stored_value,
|
strlen (stored_value) + 1);
|
assert(shmht_insert_ret > 0);
|
|
//Count
|
assert(shmht_count (h) == 1);
|
|
//Destroy the global shmht
|
shmht_destroy (h);
|
|
assert(shmht_count (h) < 0);
|
|
free (h);
|
} // test_check_count
|
|
|
/*
|
* \test-name check_long_insertions
|
* \test-function test_check_long_insertions
|
*/
|
void
|
test_check_long_insertions ()
|
{
|
char *key = "Key_for_test_check_count";
|
char *stored_value = "This is the stored Value!";
|
size_t key_size = 100;
|
int i;
|
|
//Create a shmht.
|
struct shmht *h =
|
create_shmht ("run_tests", 16, key_size, dbj2_hash, str_compar);
|
assert(h != NULL);
|
|
|
//Insert a value until all is over.
|
for (i = 0; i < 100; i++) {
|
int shmht_insert_ret = shmht_insert (h, key, strlen (key)
|
, stored_value,
|
strlen (stored_value) + 1);
|
if (shmht_insert_ret < 0) {
|
//Insert until there is no more space.
|
break;
|
}
|
}
|
|
int shmht_insert_ret = shmht_insert (h, key, strlen (key)
|
, stored_value,
|
strlen (stored_value) + 1);
|
assert(shmht_insert_ret < 0);
|
|
//Destroy the global shmht
|
shmht_destroy (h);
|
|
assert(shmht_count (h) < 0);
|
free (h);
|
|
} // test_check_long_insertions
|
|
/*
|
* \test-name check_flush
|
* \test-function test_check_flush
|
*/
|
void
|
test_check_flush ()
|
{
|
char *key = "Key_for_test_check_count";
|
char *stored_value = "This is the stored Value!";
|
size_t key_size = 100;
|
int i;
|
|
//Create a shmht.
|
struct shmht *h =
|
create_shmht ("run_tests", 16, key_size, dbj2_hash, str_compar);
|
assert(h != NULL);
|
|
//Create a shmht.
|
struct shmht *h2 =
|
create_shmht ("run_tests", 16, key_size, dbj2_hash, str_compar);
|
assert(h != NULL);
|
|
|
//Insert a value until all is over.
|
for (i = 0; i < 100; i++) {
|
int shmht_insert_ret = shmht_insert (h, key, strlen (key)
|
, stored_value,
|
strlen (stored_value) + 1);
|
if (shmht_insert_ret < 0) {
|
//Insert until there is no more space.
|
break;
|
}
|
}
|
|
//Check that we flush all the entries.
|
assert(shmht_flush (h2) == 0);
|
assert(shmht_count (h) != 0);
|
assert(shmht_count (h2) == 0);
|
|
//Destroy the global shmht
|
shmht_destroy (h);
|
shmht_destroy (h2);
|
|
assert(shmht_count (h) < 0);
|
assert(shmht_count (h2) < 0);
|
|
free (h);
|
free (h2);
|
|
} // test_check_flush
|
|
/*
|
* \test-name check_remove_older_entries
|
* \test-function test_check_remove_older_entries
|
*/
|
void
|
test_check_remove_older_entries ()
|
{
|
char *key = "Key_for_test_check_count";
|
char *stored_value = "This is the stored Value!";
|
size_t key_size = 100;
|
int i;
|
|
//Create a shmht.
|
struct shmht *h =
|
create_shmht ("run_tests", 16, key_size, dbj2_hash, str_compar);
|
assert(h != NULL);
|
|
|
//Insert a value 10000 times erasing the older entries.
|
for (i = 0; i < 10000; i++) {
|
int shmht_insert_ret = shmht_insert (h, key, strlen (key)
|
, stored_value,
|
strlen (stored_value) + 1);
|
if (shmht_insert_ret < 0) {
|
//remove the 30% of the older entries.
|
if (shmht_remove_older_entries (h, 30) == 0) {
|
assert(1);
|
break;
|
}
|
}
|
}
|
|
//Destroy the global shmht
|
shmht_destroy (h);
|
|
assert (shmht_count (h) < 0);
|
free (h);
|
|
} // test_check_remove_older_entries
|
|
|
/*
|
* \test-name check_number_of_removed_with_remove_older
|
* \test-function test_check_number_of_removed_with_remove_older
|
*/
|
void
|
test_check_number_of_removed_with_remove_older ()
|
{
|
char *key = "Key_for_test_remove_older";
|
char *stored_value = "This is the stored Value!";
|
size_t key_size = 100;
|
int i;
|
|
//Create a shmht.
|
struct shmht *h =
|
create_shmht ("run_tests", 16, key_size, dbj2_hash, str_compar);
|
assert (h != NULL);
|
|
//Insert a value until all is over.
|
for (i = 0; i < 100; i++) {
|
int shmht_insert_ret = shmht_insert (h, key, strlen (key)
|
, stored_value,
|
strlen (stored_value) + 1);
|
if (shmht_insert_ret < 0) {
|
//Insert until there is no more space.
|
break;
|
}
|
}
|
|
//Store the deletion of the 30% of the entries.
|
int number_of_destroyed_30 = shmht_remove_older_entries (h, 30);
|
|
//Fill the ht again:
|
|
//Insert a value until all is over.
|
for (i = 0; i < 100; i++) {
|
int shmht_insert_ret = shmht_insert (h, key, strlen (key)
|
, stored_value,
|
strlen (stored_value) + 1);
|
if (shmht_insert_ret < 0) {
|
//Insert until there is no more space.
|
break;
|
}
|
}
|
//Get the number of destroyed entries with 50%
|
int number_of_destroyed_50 = shmht_remove_older_entries (h, 50);
|
//Check that with the 50% we destroy more than with the 30%
|
assert(number_of_destroyed_50 > number_of_destroyed_30);
|
|
//Destroy the global shmht
|
shmht_destroy (h);
|
|
assert(shmht_count (h) < 0);
|
|
free (h);
|
|
} // test_check_flush
|
|
/*
|
* \test-name check_create_huge_number_ht
|
* \test-function test_check_create_huge_number_ht
|
*/
|
void
|
test_check_create_huge_number_ht ()
|
{
|
size_t key_size = 100;
|
char *key = "Key_for_huge_ht";
|
char *stored_value = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
|
int i;
|
#define MAX 1000
|
|
struct shmht **h = (struct shmht**)malloc(sizeof(struct shmht *) * MAX);
|
|
//Create a shmht.
|
for (i = 0; i < MAX; i++) {
|
h[i] =
|
create_shmht("run_tests", 16, key_size, dbj2_hash, str_compar);
|
if (h[i] == NULL) {
|
assert(1);
|
break;
|
}
|
}
|
|
assert(shmht_insert (h[0], key, strlen (key) , stored_value, strlen (stored_value) + 1) > 0);
|
//assert(shmht_insert (h[10], key, strlen (key) , stored_value, strlen (stored_value) + 1) > 0);
|
|
//assert(shmht_count (h[10]) == 1);
|
assert(shmht_count (h[0]) == 1);
|
|
|
size_t ret_size;
|
void *ret = shmht_search(h[0], key, strlen (key), &ret_size);
|
|
assert(ret != NULL);
|
assert(strlen (stored_value) + 1 == ret_size);
|
assert(!strncmp (ret, stored_value, strlen (stored_value)));
|
/*
|
assert(strncmp
|
((char *)
|
shmht_search (h[10], key, strlen (key), (size_t *)&ret_size),
|
stored_value, strlen(stored_value)) == 0);*/
|
|
|
//Destroy the global shmht
|
for (i = 0; i < MAX; i++) {
|
shmht_destroy (h[i]);
|
}
|
|
// assert(shmht_count (h[MAX/2]) == 0);
|
|
|
for (i = 0; i < MAX; i++) {
|
free (h[i]);
|
}
|
free(h);
|
|
} // test_check_create_huge_number_ht
|
|
|
int main (int argc, char * argv [])
|
{
|
//TestSuite *suite = create_test_suite();
|
|
// test_check_create_from_NotExistentFile();
|
test_check_create_HTs();
|
|
test_check_create_when_inserted();
|
test_check_find();
|
test_check_count();
|
test_check_long_insertions();
|
test_check_flush();
|
test_check_remove_older_entries();
|
test_check_number_of_removed_with_remove_older();
|
test_check_create_huge_number_ht();
|
|
//return run_test_suite(suite, create_text_reporter());
|
return 0;
|
}
|
