/*

 *  Dictionary_test.cpp

 *  Ottoman

 *

 *  Created by Jens Alfke on 9/4/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 "Dictionary.h"

#include "Hash.h"

#include <fcntl.h>

#include <stdio.h>

using namespace Mooseyard;

static const HashDictionary& getDict() {

    static HashDictionary *sDict;

    if (!sDict) {

        printf("Building large HashDictionary...\n");

        sDict = new HashDictionary();

        readWords();

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

            Blob kv(sWords[i]);

            sDict->put(Key(kv),kv);

        }

    }

    return *sDict;

}

TEST(Dictionary,AddRemove) {

    HashDictionary dict;

    EXPECT_EQ(0, dict.count());

    dict.put("key 1", "value 1");

    EXPECT_EQ(1, dict.count());

    dict.put("key 2", "value 2");

    EXPECT_EQ(2, dict.count());

    dict.put("key 3", "value 3");

    EXPECT_TRUE(dict.get("key 1").equals("value 1"));

    EXPECT_TRUE(dict.get("key 2").equals("value 2"));

    EXPECT_TRUE(dict.get("key 3").equals("value 3"));

    EXPECT_TRUE(!dict.get("key 4"));

    EXPECT_TRUE(dict.remove("key 2"));

    EXPECT_EQ(2, dict.count());

    EXPECT_TRUE(dict.get("key 1").equals("value 1"));

    EXPECT_TRUE(!dict.get("key 2"));

    EXPECT_TRUE(dict.get("key 3").equals("value 3"));

}

TEST(Dictionary,GetAll) {

    const Dictionary &dict = getDict();

    EXPECT_EQ( sNWords ,  dict.count() );

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

        Key key(sWords[i]);

        Blob value = dict.get(key);

        EXPECT_TRUE(value);

        EXPECT_TRUE( value.equals(key) );

    }

}

TEST(Dictionary,Iterate) {

    const HashDictionary &dict = getDict();

    Timer t("Iterating Dictionary", sNWords);

    int n=0;

    for( HashDictionary::Iterator it(dict); it; ++it) {

        n++;

        EXPECT_TRUE(it.key().length > 0 && it.key().length < 50);

        EXPECT_TRUE(it.key().equals(it.value()));

        EXPECT_EQ( 0, ((size_t)it.value().bytes & 0x3) );  // 4-byte aligned

    }

    EXPECT_EQ(sNWords, n);

}

TEST(Dictionary,Overlay) {

    const Dictionary &dict = getDict();

    OverlayDictionary overlay(&dict);

    EXPECT_EQ( sNWords ,  overlay.count() );

    EXPECT_TRUE(overlay.get("animal").equals("animal"));

    EXPECT_TRUE(overlay.get("asparagus").equals("asparagus"));

    EXPECT_FALSE(overlay.get("growf"));

    overlay.put("animal", "AMINAL");

    overlay.put("growf", "growf");

    EXPECT_TRUE(overlay.remove("asparagus"));

    EXPECT_EQ( sNWords, overlay.count() );

    EXPECT_TRUE(overlay.get("animal").equals("AMINAL"));

    EXPECT_TRUE(overlay.get("growf").equals("growf"));

    EXPECT_TRUE(overlay.contains("growf"));

    EXPECT_FALSE(overlay.get("asparagus"));

    EXPECT_FALSE(overlay.contains("asparagus"));

    int n=0;

    for( OverlayDictionary::Iterator it(overlay); it; ++it) {

        n++;

        EXPECT_TRUE(!it.key().equals("asparagus"));

    }

    EXPECT_EQ(sNWords, n);

    printf("Testing ChangeIterator...\n");

    n=0;

    int foundAsparagus=0, foundAnimal=0, foundGrowf=0;

    for( Dictionary::ChangeIterator it(&overlay); it; ++it) {

        n++;

        if (it.key().equals("animal")) {

            foundAnimal++;

            EXPECT_TRUE(it.value().equals("AMINAL"));

            EXPECT_TRUE(it.otherValue().equals("animal"));

        } else if (it.key().equals("asparagus")) {

            foundAsparagus++;

            EXPECT_FALSE(it.value());

            EXPECT_TRUE(it.otherValue().equals("asparagus"));

        } else if (it.key().equals("growf")) {

            foundGrowf++;

            EXPECT_TRUE(it.value().equals("growf"));

            EXPECT_FALSE(it.otherValue());

        } else {

            EXPECT_TRUE(false);

        }

    }

    EXPECT_EQ(1, foundAnimal);

    EXPECT_EQ(1, foundAsparagus);

    EXPECT_EQ(1, foundGrowf);

    EXPECT_EQ(3, n);

}