/*

  *  Ottoman_test.cpp

  *  Ottoman

  *

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

 #include "Ottoman.h"

 #include "VersionDictionary.h"

 #include <fcntl.h>

 #include <stdio.h>

 using namespace Mooseyard;

 TEST(Ottoman,Build) {

     ASSERT_EQ(8, sizeof(Chunk));

     ASSERT_EQ(8, sizeof(KeyValueChunk));

     time_t startTime = ::time(NULL);

     time_t createTime;

     {

         Ottoman otto;

         EXPECT_EQ((void*)NULL, otto.lastVersion());

         ASSERT_NE((void*)NULL, otto.currentVersion());

         readWords();

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

             Blob kv(sWords[i]);

             otto.currentVersion()->put(Key(kv),kv);

         }

         Timer t("Saving Ottoman", sNWords);

         otto.saveAs("/tmp/test.ottoman");

         VersionDictionary *last = otto.lastVersion();

         ASSERT_NE((void*)NULL, last);

         EXPECT_EQ(sNWords, last->count());

         ASSERT_NE((void*)NULL, otto.currentVersion());

         EXPECT_FALSE(otto.currentVersion()->isChanged());

         createTime = last->timestamp();

         EXPECT_GE(createTime, startTime);

         EXPECT_LE(createTime, ::time(NULL));

     }

     {

         Ottoman otto("/tmp/test.ottoman");

         VersionDictionary *last = otto.lastVersion();

         ASSERT_NE((void*)NULL, last);

         ASSERT_EQ(0, last->generation());

         ASSERT_EQ(createTime, last->timestamp());

         {

             Timer t("Reading from Ottoman", sNWords);

             EXPECT_EQ( sNWords ,  last->count() );

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

                 Key key(sWords[i]);

                 Blob value = last->get(key);

                 ASSERT_TRUE(value);

                 ASSERT_TRUE( value.equals(key) ) << "expected '" << key << "', got '" << value << "' (i=" << i <<")";

             }

         }

         printf("Iterating through the Ottoman...\n");

         Timer t("Iterating Ottoman", sNWords);

         int n=0;

         for( VersionDictionary::Iterator it(last); it; ++it) {

             n++;

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

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

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

         }

         ASSERT_EQ(sNWords, n);

     }

     {

         printf("Opening Ottoman...\n");

         Ottoman otto("/tmp/test.ottoman");

         OverlayDictionary *current = otto.currentVersion();

         ASSERT_TRUE(current != NULL);

         EXPECT_EQ( sNWords ,  current->count() );

         EXPECT_TRUE(current->get("asparagus").equals("asparagus"));

         current->put("animal", "AMINAL");

         current->put("growf", "growf");

         EXPECT_TRUE(current->remove("asparagus"));

         EXPECT_EQ( sNWords, current->count() );

         EXPECT_TRUE(current->get("animal").equals("AMINAL"));

         EXPECT_TRUE(current->get("growf").equals("growf"));

         EXPECT_EQ( NULL, current->get("asparagus").bytes );

         EXPECT_TRUE(!current->contains("asparagus"));

         int n=0;

         for( OverlayDictionary::Iterator it(*current); it; ++it) {

             n++;

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

         }

         ASSERT_EQ(sNWords, n);

         printf("Saving Ottoman...\n");

         {

             Timer t("Saving Ottoman");

             otto.save();

         }

         EXPECT_EQ( sNWords, current->count() );

         EXPECT_TRUE(current->get("animal").equals("AMINAL"));

         EXPECT_TRUE(current->get("growf").equals("growf"));

         EXPECT_EQ( NULL, current->get("asparagus").bytes );

         EXPECT_TRUE(!current->contains("asparagus"));

         n=0;

         for( OverlayDictionary::Iterator it(*current); it; ++it) {

             n++;

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

         }

         ASSERT_EQ(sNWords, n);

         EXPECT_EQ(1, otto.lastVersion()->generation());

         const VersionDictionary *prev = otto.lastVersion()->previousVersion();

         ASSERT_TRUE(prev != NULL);

         EXPECT_EQ(0, prev->generation());

         EXPECT_TRUE(prev->get("asparagus").equals("asparagus"));

         EXPECT_TRUE(prev->get("growf").equals(NULL));

     }

     {

         printf("Re-opening Ottoman...\n");

         Ottoman otto("/tmp/test.ottoman", false);

         ASSERT_EQ(NULL, otto.currentVersion());

         VersionDictionary *last = otto.lastVersion();

         ASSERT_TRUE(last != NULL);

         EXPECT_EQ(1, last->generation());

         EXPECT_GE(last->timestamp(), createTime);

         EXPECT_LE(last->timestamp(), ::time(NULL));

         EXPECT_EQ( sNWords ,  last->count() );

         EXPECT_TRUE(last->get("animal").equals("AMINAL"));

         EXPECT_TRUE(last->get("growf").equals("growf"));

         EXPECT_EQ( NULL, last->get("asparagus").bytes );

         EXPECT_TRUE(!last->contains("asparagus"));

         int n=0;

         for( VersionDictionary::Iterator it(last); it; ++it) {

             n++;

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

         }

         ASSERT_EQ(sNWords, n);

     }

     {

         printf("Writing Ottoman to a new file...\n");

         Ottoman oldhf("/tmp/test.ottoman");

         oldhf.saveAs("/tmp/test2.ottoman");

     }

     {

         printf("Opening new file...\n");

         Ottoman otto("/tmp/test2.ottoman");

         OverlayDictionary *current = otto.currentVersion();

         ASSERT_TRUE(current != NULL);

         EXPECT_EQ( sNWords ,  current->count() );

         EXPECT_TRUE(current->get("animal").equals("AMINAL"));

         EXPECT_TRUE(current->get("growf").equals("growf"));

         EXPECT_EQ( NULL, current->get("asparagus").bytes );

         EXPECT_TRUE(!current->contains("asparagus"));

         int n=0;

         for( OverlayDictionary::Iterator it(*current); it; ++it) {

             n++;

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

         }

         ASSERT_EQ(sNWords, n);

         printf("Iterating the chunks...\n");

         int lastType = -1;

         int count = 0;

         n = 0;

         ChunkIterator *it = otto.chunkIterator();

         for (; *it; it->next()) {

             uint16_t type = it->chunk()->type();

             if (type != lastType) {

                 if (count > 0)

                     printf("%6d\n", count);

                 printf("type %u ... ", type);

                 lastType = type;

                 count = 0;

             }

             count++;

             ASSERT_LE(type, 3);

             if (type != 0)      // don't count padding chunks

                 n++;

         }

         if (count > 0)

             printf("%6d\n", count);

         printf("Iterated over %i chunks\n",n);

         EXPECT_EQ(sNWords+256+1, n);

         EXPECT_TRUE(it->atEOF());

         printf("Scavenging...\n");

         EXPECT_TRUE( otto.scavenge() );

     }

 }