/*

  *  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,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);

 }