void test_hash_iterator_key_pair()
{
HashTable *hash_table;
HashTableIterator iterator;
HashTablePair pair;
int *key = 0;
int *val = 0;
hash_table = hash_table_new(int_hash, int_equal);
/* Add some values */
hash_table_insert(hash_table, &value1, &value1);
hash_table_insert(hash_table, &value2, &value2);
hash_table_iterate(hash_table, &iterator);
while (hash_table_iter_has_more(&iterator)) {
/* Retrieve both Key and Value */
pair = hash_table_iter_next(&iterator);
key = (int*) pair.key;
val = (int*) pair.value;
assert(*key == *val);
}
hash_table_free(hash_table);
}
void test_hash_table_iterating_remove(void)
{
HashTable *hash_table;
HashTableIterator iterator;
char buf[10];
char *val;
HashTablePair pair;
int count;
unsigned int removed;
int i;
hash_table = generate_hash_table();
/* Iterate over all values in the table */
count = 0;
removed = 0;
hash_table_iterate(hash_table, &iterator);
while (hash_table_iter_has_more(&iterator)) {
/* Read the next value */
pair = hash_table_iter_next(&iterator);
val = pair.value;
/* Remove every hundredth entry */
if ((atoi(val) % 100) == 0) {
hash_table_remove(hash_table, val);
++removed;
}
++count;
}
/* Check counts */
assert(removed == 100);
assert(count == NUM_TEST_VALUES);
assert(hash_table_num_entries(hash_table)
== NUM_TEST_VALUES - removed);
/* Check all entries divisible by 100 were really removed */
for (i=0; i<NUM_TEST_VALUES; ++i) {
sprintf(buf, "%i", i);
if (i % 100 == 0) {
assert(hash_table_lookup(hash_table, buf) == NULL);
} else {
assert(hash_table_lookup(hash_table, buf) != NULL);
}
}
hash_table_free(hash_table);
}
void test_hash_table_iterating(void)
{
HashTable *hash_table;
HashTableIterator iterator;
int count;
hash_table = generate_hash_table();
/* Iterate over all values in the table */
count = 0;
hash_table_iterate(hash_table, &iterator);
while (hash_table_iter_has_more(&iterator)) {
hash_table_iter_next(&iterator);
++count;
}
assert(count == NUM_TEST_VALUES);
/* Test iter_next after iteration has completed. */
assert(hash_table_iter_next(&iterator) == HASH_TABLE_NULL);
hash_table_free(hash_table);
/* Test iterating over an empty table */
hash_table = hash_table_new(int_hash, int_equal);
hash_table_iterate(hash_table, &iterator);
assert(hash_table_iter_has_more(&iterator) == 0);
hash_table_free(hash_table);
}
void
__la_dump_table(HashTable *table, __value_handler_t func)
{
HashTableIterator itr;
LOGV("%p (hash table: dump table)", table);
if (func == NULL) {
LOGW("%p (dump hash table: given no handler)", table);
return;
}
/* Print each value in detail */
hash_table_iterate(table, &itr);
while (hash_table_iter_has_more(&itr)) {
(*func)(hash_table_iter_next(&itr));
}
}
int main(int arg, char *argv) {
char * str1 = "HTTP/1.1 index.html";
char * str2 = "HTTP/1.0 aaaaa.html";
char * str3 = "HTTP/1.0 bbbbb.html";
char * str4 = "HTTP/1.1 ccccc.html";
char * str5 = "HTTP/0.9 ddddd.html";
char * str6 = "HTTP/1.1 fffff.html";
char * str7 = "HTTP/0.9 eeeee.html";
LST_String * nbytes1 = lst_string_new(str1, 1, strlen(str1));
LST_String * nbytes2 = lst_string_new(str2, 1, strlen(str2));
LST_String * nbytes3 = lst_string_new(str3, 1, strlen(str3));
LST_String * nbytes4 = lst_string_new(str4, 1, strlen(str4));
LST_String * nbytes5 = lst_string_new(str5, 1, strlen(str5));
LST_String * nbytes6 = lst_string_new(str6, 1, strlen(str6));
LST_String * nbytes7 = lst_string_new(str7, 1, strlen(str7));
LST_StringSet * set = lst_stringset_new();
lst_stringset_add(set, nbytes1);
lst_stringset_add(set, nbytes2);
lst_stringset_add(set, nbytes3);
lst_stringset_add(set, nbytes4);
lst_stringset_add(set, nbytes5);
lst_stringset_add(set, nbytes6);
lst_stringset_add(set, nbytes7);
int first_bytes = 8;
int last_bytes = 10;
int num_bytes = 19;
int gamma_merge = 2;
product_distribution_t * pd = product_distribution_new(set, first_bytes, last_bytes, num_bytes);
/* print pd */
HashTableIterator iterator1;
hash_table_iterate(pd->offset_distribution, &iterator1);
while (hash_table_iter_has_more(&iterator1)){
HashTablePair pair1 = hash_table_iter_next(&iterator1);
int *key1 = (int *) pair1.key;
byte_distribution_t *value1 = (byte_distribution_t *) pair1.value;
HashTableIterator iterator2;
hash_table_iterate(value1->value_frequency, &iterator2);
if (hash_table_num_entries(value1->value_frequency) > gamma_merge) {
continue;
}
printf("offset %d : ", *key1);
while(hash_table_iter_has_more(&iterator2)){
HashTablePair pair2 = hash_table_iter_next(&iterator2);
char *key2 = (char *) pair2.key;
int *value2 = (int *) pair2.value;
//printf("<%c, %d>\t", key2[0], *value2);
if (0 == *key1) {
printf("^%s\t", key2);
} else if (num_bytes - 1 == *key1) {
printf("%s$\t", key2);
} else {
printf("%s\t", key2);
}
}
printf("\n");
}
product_distribution_free(pd);
return 0;
}
