test_amxc_hash_func.c File Reference

#include <stdlib.h>
#include <stdio.h>
#include <stdbool.h>
#include <string.h>
#include <amxc/amxc_hash.h>
#include "test_amxc_hash_func.h"
#include <amxc/amxc_macros.h>

Go to the source code of this file.

Functions
static void	generate_string (char *str, size_t length)
void	amxc_hash_generation_check (UNUSED void **state)
static int	amxc_hash_distribution_setup ()
static int	amxc_hash_distribution_teardown ()
void	amxc_hash_distibution_RS_check (UNUSED void **state)
void	amxc_hash_distibution_JS_check (UNUSED void **state)
void	amxc_hash_distibution_PJW_check (UNUSED void **state)
void	amxc_hash_distibution_ELF_check (UNUSED void **state)
void	amxc_hash_distibution_BKDR_check (UNUSED void **state)
void	amxc_hash_distibution_SBDM_check (UNUSED void **state)
void	amxc_hash_distibution_DJB_check (UNUSED void **state)
void	amxc_hash_distibution_DEK_check (UNUSED void **state)
void	amxc_hash_distibution_BP_check (UNUSED void **state)
void	amxc_hash_distibution_FNV_check (UNUSED void **state)
void	amxc_hash_distibution_AP_check (UNUSED void **state)
void	amxc_hash_BKDR_hashes_check (UNUSED void **state)

Variables
static unsigned int	array [2006]
static bool	first_double = false

Function Documentation

amxc_hash_BKDR_hashes_check()

void amxc_hash_BKDR_hashes_check

(

UNUSED void **

state

)

Definition at line 333 of file test_amxc_hash_func.c.

                                                      {
    printf("[Key1] = %d\n", amxc_BKDR_hash("Key1", 4) % 64);
    printf("[Key2] = %d\n", amxc_BKDR_hash("Key2", 4) % 64);
    printf("[Key3] = %d\n", amxc_BKDR_hash("Key3", 4) % 64);
    printf("[Key4] = %d\n", amxc_BKDR_hash("Key4", 4) % 64);
    printf("[Key5] = %d\n", amxc_BKDR_hash("Key5", 4) % 64);
    printf("[Key6] = %d\n", amxc_BKDR_hash("Key6", 4) % 64);
    printf("[Key7] = %d\n", amxc_BKDR_hash("Key7", 4) % 64);
    printf("[Key8] = %d\n", amxc_BKDR_hash("Key8", 4) % 64);
    printf("[Key9] = %d\n", amxc_BKDR_hash("Key9", 4) % 64);
    printf("[Key11] = %d\n", amxc_BKDR_hash("Key11", 5) % 64);
    printf("[Key21] = %d\n", amxc_BKDR_hash("Key21", 5) % 64);
    printf("[Key31] = %d\n", amxc_BKDR_hash("Key31", 5) % 64);
    printf("[Key41] = %d\n", amxc_BKDR_hash("Key41", 5) % 64);
    printf("[Key51] = %d\n", amxc_BKDR_hash("Key51", 5) % 64);
    printf("[Key61] = %d\n", amxc_BKDR_hash("Key61", 5) % 64);
    printf("[Key71] = %d\n", amxc_BKDR_hash("Key71", 5) % 64);
    printf("[Key81] = %d\n", amxc_BKDR_hash("Key81", 5) % 64);
    printf("[Key91] = %d\n", amxc_BKDR_hash("Key91", 5) % 64);
    printf("[Key110] = %d\n", amxc_BKDR_hash("Key110", 6) % 64);
    printf("[Key210] = %d\n", amxc_BKDR_hash("Key210", 6) % 64);
    printf("[Key310] = %d\n", amxc_BKDR_hash("Key310", 6) % 64);
    printf("[Key410] = %d\n", amxc_BKDR_hash("Key410", 6) % 64);
    printf("[Key510] = %d\n", amxc_BKDR_hash("Key510", 6) % 64);
    printf("[Key610] = %d\n", amxc_BKDR_hash("Key610", 6) % 64);
    printf("[Key710] = %d\n", amxc_BKDR_hash("Key710", 6) % 64);
    printf("[Key810] = %d\n", amxc_BKDR_hash("Key810", 6) % 64);
    printf("[Key910] = %d\n", amxc_BKDR_hash("Key910", 6) % 64);
}

amxc_hash_distibution_AP_check()

void amxc_hash_distibution_AP_check

(

UNUSED void **

state

)

Definition at line 316 of file test_amxc_hash_func.c.

                                                         {
    amxc_hash_distribution_setup();
    printf("AP hash algorithm\n");
 
    for(int i = 0; i < 2006; i++) {
        char key[15];
        generate_string(key, 15);
        unsigned int hash = amxc_AP_hash(key, 15) % 2006;
        if(array[hash] && !first_double) {
            first_double = true;
            printf("First double insertion = %d\n", i);
        }
        array[hash]++;
    }
    amxc_hash_distribution_teardown();
}

amxc_hash_distibution_BKDR_check()

void amxc_hash_distibution_BKDR_check

(

UNUSED void **

state

)

Definition at line 214 of file test_amxc_hash_func.c.

                                                           {
    amxc_hash_distribution_setup();
    printf("BKDR hash algorithm\n");
 
    for(int i = 0; i < 2006; i++) {
        char key[15];
        generate_string(key, 15);
        unsigned int hash = amxc_BKDR_hash(key, 15) % 2006;
        if(array[hash] && !first_double) {
            first_double = true;
            printf("First double insertion = %d\n", i);
        }
        array[hash]++;
    }
    amxc_hash_distribution_teardown();
}

amxc_hash_distibution_BP_check()

void amxc_hash_distibution_BP_check

(

UNUSED void **

state

)

Definition at line 282 of file test_amxc_hash_func.c.

                                                         {
    amxc_hash_distribution_setup();
    printf("BP hash algorithm\n");
 
    for(int i = 0; i < 2006; i++) {
        char key[15];
        generate_string(key, 15);
        unsigned int hash = amxc_BP_hash(key, 15) % 2006;
        if(array[hash] && !first_double) {
            first_double = true;
            printf("First double insertion = %d\n", i);
        }
        array[hash]++;
    }
    amxc_hash_distribution_teardown();
}

amxc_hash_distibution_DEK_check()

void amxc_hash_distibution_DEK_check

(

UNUSED void **

state

)

Definition at line 265 of file test_amxc_hash_func.c.

                                                          {
    amxc_hash_distribution_setup();
    printf("DEK hash algorithm\n");
 
    for(int i = 0; i < 2006; i++) {
        char key[15];
        generate_string(key, 15);
        unsigned int hash = amxc_DEK_hash(key, 15) % 2006;
        if(array[hash] && !first_double) {
            first_double = true;
            printf("First double insertion = %d\n", i);
        }
        array[hash]++;
    }
    amxc_hash_distribution_teardown();
}

amxc_hash_distibution_DJB_check()

void amxc_hash_distibution_DJB_check

(

UNUSED void **

state

)

Definition at line 248 of file test_amxc_hash_func.c.

                                                          {
    amxc_hash_distribution_setup();
    printf("DJB hash algorithm\n");
 
    for(int i = 0; i < 2006; i++) {
        char key[15];
        generate_string(key, 15);
        unsigned int hash = amxc_DJB_hash(key, 15) % 2006;
        if(array[hash] && !first_double) {
            first_double = true;
            printf("First double insertion = %d\n", i);
        }
        array[hash]++;
    }
    amxc_hash_distribution_teardown();
}

amxc_hash_distibution_ELF_check()

void amxc_hash_distibution_ELF_check

(

UNUSED void **

state

)

Definition at line 197 of file test_amxc_hash_func.c.

                                                          {
    amxc_hash_distribution_setup();
    printf("ELF hash algorithm\n");
 
    for(int i = 0; i < 2006; i++) {
        char key[15];
        generate_string(key, 15);
        unsigned int hash = amxc_ELF_hash(key, 15) % 2006;
        if(array[hash] && !first_double) {
            first_double = true;
            printf("First double insertion = %d\n", i);
        }
        array[hash]++;
    }
    amxc_hash_distribution_teardown();
}

amxc_hash_distibution_FNV_check()

void amxc_hash_distibution_FNV_check

(

UNUSED void **

state

)

Definition at line 299 of file test_amxc_hash_func.c.

                                                          {
    amxc_hash_distribution_setup();
    printf("FNV hash algorithm\n");
 
    for(int i = 0; i < 2006; i++) {
        char key[15];
        generate_string(key, 15);
        unsigned int hash = amxc_FNV_hash(key, 15) % 2006;
        if(array[hash] && !first_double) {
            first_double = true;
            printf("First double insertion = %d\n", i);
        }
        array[hash]++;
    }
    amxc_hash_distribution_teardown();
}

amxc_hash_distibution_JS_check()

void amxc_hash_distibution_JS_check

(

UNUSED void **

state

)

Definition at line 163 of file test_amxc_hash_func.c.

                                                         {
    amxc_hash_distribution_setup();
    printf("JS hash algorithm\n");
 
    for(int i = 0; i < 2006; i++) {
        char key[15];
        generate_string(key, 15);
        unsigned int hash = amxc_JS_hash(key, 15) % 2006;
        if(array[hash] && !first_double) {
            first_double = true;
            printf("First double insertion = %d\n", i);
        }
        array[hash]++;
    }
    amxc_hash_distribution_teardown();
}

amxc_hash_distibution_PJW_check()

void amxc_hash_distibution_PJW_check

(

UNUSED void **

state

)

Definition at line 180 of file test_amxc_hash_func.c.

                                                          {
    amxc_hash_distribution_setup();
    printf("PJW hash algorithm\n");
 
    for(int i = 0; i < 2006; i++) {
        char key[15];
        generate_string(key, 15);
        unsigned int hash = amxc_PJW_hash(key, 15) % 2006;
        if(array[hash] && !first_double) {
            first_double = true;
            printf("First double insertion = %d\n", i);
        }
        array[hash]++;
    }
    amxc_hash_distribution_teardown();
}

amxc_hash_distibution_RS_check()

void amxc_hash_distibution_RS_check

(

UNUSED void **

state

)

Definition at line 146 of file test_amxc_hash_func.c.

                                                         {
    amxc_hash_distribution_setup();
    printf("RS hash algorithm\n");
 
    for(int i = 0; i < 2006; i++) {
        char key[15];
        generate_string(key, 15);
        unsigned int hash = amxc_RS_hash(key, 15) % 2006;
        if(array[hash] && !first_double) {
            first_double = true;
            printf("First double insertion = %d\n", i);
        }
        array[hash]++;
    }
    amxc_hash_distribution_teardown();
}

amxc_hash_distibution_SBDM_check()

void amxc_hash_distibution_SBDM_check

(

UNUSED void **

state

)

Definition at line 231 of file test_amxc_hash_func.c.

                                                           {
    amxc_hash_distribution_setup();
    printf("SBDM hash algorithm\n");
 
    for(int i = 0; i < 2006; i++) {
        char key[15];
        generate_string(key, 15);
        unsigned int hash = amxc_SDBM_hash(key, 15) % 2006;
        if(array[hash] && !first_double) {
            first_double = true;
            printf("First double insertion = %d\n", i);
        }
        array[hash]++;
    }
    amxc_hash_distribution_teardown();
}

amxc_hash_distribution_setup()

static int amxc_hash_distribution_setup ( )

static

Definition at line 105 of file test_amxc_hash_func.c.

                                          {
    memset(array, 0, sizeof(array));
    srand(2013);
    first_double = false;
    printf("\n===========================================\n");
 
    return 0;
}

amxc_hash_distribution_teardown()

static int amxc_hash_distribution_teardown ( )

static

Definition at line 114 of file test_amxc_hash_func.c.

                                             {
    unsigned int empty_buckets = 0;
    unsigned int unique_buckets = 0;
    unsigned int max_chain_length = 0;
    unsigned int number_of_chains = 0;
    unsigned int total_chain_lengths = 0;
    for(int i = 0; i < 2006; i++) {
        if(array[i] == 0) {
            empty_buckets++;
        }
        if(array[i] > max_chain_length) {
            max_chain_length = array[i];
        }
        if(array[i] > 1) {
            number_of_chains++;
            total_chain_lengths += array[i];
        }
        if(array[i] == 1) {
            unique_buckets++;
        }
    }
    printf("Nr. of empty buckets   = %d\n", empty_buckets);
    printf("Nr. of chained buckets = %d\n", number_of_chains);
    printf("Nr. of uinque buckets  = %d\n", unique_buckets);
    printf("Total buckets          = %d\n", empty_buckets + number_of_chains + unique_buckets);
    printf("max chain length       = %d\n", max_chain_length);
    printf("average chain length   = %f\n", (double) (total_chain_lengths / number_of_chains));
    printf("===========================================\n");
 
    return 0;
}

amxc_hash_generation_check()

void amxc_hash_generation_check

(

UNUSED void **

state

)

Definition at line 73 of file test_amxc_hash_func.c.

                                                     {
    char* key[] = { "abcdefghijklmnopqrstuvwxyz1234567890",
        "0987654321zyxwvutsrqponmlkjihgfedcba",
        "Damien",
        "Tom",
        "Peter",
        "Project Ambiorix",
        "1234567890",
        "abcdefghijklmnopqrstuvwxyz",
        "!@#$%^&*()_",
        "1+1=2",
        NULL};
 
    for(int i = 0; key[i]; i++) {
        printf("Key:                         %s\n", key[i]);
        printf(" 1. RS-Hash Function Value:   %u\n", amxc_RS_hash(key[i], strlen(key[i])));
        printf(" 2. JS-Hash Function Value:   %u\n", amxc_JS_hash(key[i], strlen(key[i])));
        printf(" 3. PJW-Hash Function Value:  %u\n", amxc_PJW_hash(key[i], strlen(key[i])));
        printf(" 4. ELF-Hash Function Value:  %u\n", amxc_ELF_hash(key[i], strlen(key[i])));
        printf(" 5. BKDR-Hash Function Value: %u\n", amxc_BKDR_hash(key[i], strlen(key[i])));
        printf(" 6. SDBM-Hash Function Value: %u\n", amxc_SDBM_hash(key[i], strlen(key[i])));
        printf(" 7. DJB-Hash Function Value:  %u\n", amxc_DJB_hash(key[i], strlen(key[i])));
        printf(" 8. DEK-Hash Function Value:  %u\n", amxc_DEK_hash(key[i], strlen(key[i])));
        printf(" 9. BP-Hash Function Value:   %u\n", amxc_BP_hash(key[i], strlen(key[i])));
        printf("10. FNV-Hash Function Value:  %u\n", amxc_FNV_hash(key[i], strlen(key[i])));
        printf("11. AP-Hash Function Value:   %u\n", amxc_AP_hash(key[i], strlen(key[i])));
    }
}

generate_string()

static void generate_string ( char *  str, size_t  length  )

static

Definition at line 65 of file test_amxc_hash_func.c.

                                                      {
    const char* base = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
    size_t len = strlen(base);
    for(unsigned int i = 0; i < length; i++) {
        str[i] = base[rand() % len];
    }
}

Variable Documentation

array

unsigned int array[2006]

static

Definition at line 102 of file test_amxc_hash_func.c.

first_double

bool first_double = false

static

Definition at line 103 of file test_amxc_hash_func.c.