/*

 *  Hash_test.cpp

 *  Ottoman

 *

 *  Created by Jens Alfke on 9/2/09.

 *  Copyright 2009 Jens Alfke. All rights reserved.

 *  BSD-Licensed: See the file "LICENSE.txt" for details.

 */

#include <gtest/gtest.h>

#include "TestUtils.h"

#include "File.h"

#include "Hash.h"

#include <stdio.h>

using namespace Mooseyard;

static bool verbose = false;

static int num = 100;

#pragma mark -

#pragma mark UTILITIES:

char* mkKey (int i) {

    static char* sKeys[100];

    if (i>=0 && i<100 && sKeys[i] != NULL)

        return sKeys[i];

    char str[10];

    sprintf(str, "%i",i);

    char *key = strdup(str);

    if (i>=0 && i<100)

        sKeys[i] = key;

    return key;

}

static char* Insert(Hash &hash, const char* key) {

    char string[100];

    sprintf(string, "value for %s", key);

    if (verbose)

        fprintf(stderr, "\nInserting %s -> '%s'\n", key,string);

    int count = hash.count();

    char *leaf = strdup(string);

    hash.put(key,leaf);

    if (verbose)

        hash.dump();

    EXPECT_EQ( count+1, hash.count() );

    EXPECT_EQ( leaf, hash.get(key) );

    return leaf;

}

static char* Insert(Hash &hash, int i) {

    return Insert(hash, mkKey(i));

}

static void Remove(Hash &hash, int i) {

    char* key = mkKey(i);

    char string[100];

    sprintf(string, "value for %s", key);

    if (verbose)

        fprintf(stderr, "\nRemoving %s\n", key);

    int count = hash.count();

    char *value = (char*) hash.get(key);

    EXPECT_TRUE(value!=NULL);

    EXPECT_EQ(0, strcmp(value,string));

    EXPECT_TRUE(hash.remove(key));

    if (verbose)

        hash.dump();

    EXPECT_EQ( count-1, hash.count() );

    EXPECT_EQ( NULL, hash.get(key) );

}

#pragma mark -

#pragma mark TESTS:

TEST(Hash,Simple) {

    Hash hash;

    hash.dump();

    EXPECT_EQ(0, hash.count());

    char *seventeen = Insert(hash, "seventeen");

    EXPECT_EQ(NULL, hash.get("zero"));

    EXPECT_EQ(NULL, hash.get("eighteen"));

    char *four = Insert(hash, "four");

    EXPECT_EQ(seventeen, hash.get("seventeen"));

    char *zero = Insert(hash, "zero");

    char *hundred = Insert(hash, "one hundred");

    char *eight = Insert(hash, "eight");

    char *twenty = Insert(hash, "twenty");

    EXPECT_EQ(zero, hash.get("zero"));

    EXPECT_EQ(four, hash.get("four"));

    EXPECT_EQ(eight, hash.get("eight"));

    EXPECT_EQ(seventeen, hash.get("seventeen"));

    EXPECT_EQ(twenty, hash.get("twenty"));

    EXPECT_EQ(hundred, hash.get("one hundred"));

    int i=0;

    for (Hash::Iterator iter(&hash); iter; ++iter, ++i) {

        Blob key = iter.key();

        if (verbose)

            fprintf(stderr, "   %*s -> %s\n", 

                    (int)key.length,(const char*)key.bytes,

                    ((char*)iter.value()));

    }

    EXPECT_EQ(6, i);

}

TEST(Hash,InsertLotsAtRandom) {

    int map[num];

    for (int i=0; i<num; i++)

        map[i] = i;

    shuffle(map,num);

    if (verbose) {

        for (int i=0; i<num; i++)

            fprintf(stderr, "%3d ",map[i]);

        fprintf(stderr, "\n");

    }

    Hash hash(8);

    char* expected[num];

    memset(&expected,0,sizeof(expected));

    for (int i=0; i<num; i++) {

        expected[map[i]] = Insert(hash, map[i]);

        for (int j=0; j<num; j++)

            EXPECT_EQ(expected[map[j]], hash.get(mkKey(map[j])));

    }

}

TEST(Hash,DeleteAtRandom) {

    Hash hash;

    for (int i=0; i<num; i++)

        Insert(hash,i);

    int map[num];

    for (int i=0; i<num; i++)

        map[i] = i;

    shuffle(map,num);

    if (verbose) {

        for (int i=0; i<num; i++)

            fprintf(stderr, "%3d ",map[i]);

        fprintf(stderr, "\n");

    }

    for (int i=0; i<num; i++)

        Remove(hash,map[i]);

}

TEST(Hash,Words) {

    const int kIterations = 3;

    readWords();

    double totalAdd = 0.0, totalGet = 0.0, totalRemove = 0.0;

    for (int iter=0; iter<kIterations; iter++) {

        printf("Adding words to Hash...\n");

        Hash hash;

        {

            Timer t("adding");

            for( int i=0; i<sNWords; i++)

                hash.put(sWords[i], sWords[i]);

            EXPECT_EQ(sNWords, hash.count());

            totalAdd += t.elapsed();

        }        

        {

            Timer t("getting");

            for( int i=0; i<sNWords; i++)

                EXPECT_EQ( sWords[i] ,  hash.get(sWords[i]) );

            totalGet += t.elapsed();

        }        

        {

            Timer t("removing");

            for( int i=0; i<sNWords; i++)

                EXPECT_TRUE( hash.remove(sWords[i]) );

            totalRemove += t.elapsed();

        }        

    }

    printf("Average put   = %.0lfns\n", totalAdd/kIterations/sNWords*1e9);

    printf("Average get   = %.0lfns\n", totalGet/kIterations/sNWords*1e9);

    printf("Average remove= %.0lfns\n", totalRemove/kIterations/sNWords*1e9);

}