/*

  *  VersionDictionary_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.

  */

 #define VERSIONDICTIONARY_TESTING 1

 #include <gtest/gtest.h>

 #include "TestUtils.h"

 #include "Chunk.h"

 #include "File.h"

 #include "VersionDictionary.h"

 #include "Hash.h"

 #include <fcntl.h>

 #include <stdio.h>

 using namespace Mooseyard;

 class OverlayVersionDictionary :public OverlayDictionary {

 public:

     OverlayVersionDictionary (File *file)

     :OverlayDictionary(new VersionDictionary(file))

     { }  

     int generation() const                  {return ((VersionDictionary*)base())->generation();}

     time_t timestamp() const                {return ((VersionDictionary*)base())->timestamp();}

     void save(){

         saveAs(((VersionDictionary*)base())->file());

     }

     void saveAs (File *dstFile) {

         VersionDictionary* oldBase = (VersionDictionary*) base();

         revertTo( ((VersionDictionary*)base())->_appendAndOpen(overlay(), dstFile, baseReplaced()) );

         delete oldBase;

     }

 };

 TEST(File,HasPath) {

     {

         File f("/tmp/jubba", O_RDWR | O_CREAT | O_TRUNC, true);

         f.write("howdy");

     }

     {

         File f("/tmp/jubba", O_RDWR, true);

         EXPECT_TRUE(f.hasPath("/tmp/jubba"));

         File::unlink("/tmp/jubba");

         EXPECT_FALSE(f.hasPath("/tmp/jubba"));

         File f2("/tmp/jubba", O_RDWR | O_CREAT | O_TRUNC, true);

         f2.write("howdy");

         f2.flush();

         EXPECT_FALSE(f.hasPath("/tmp/jubba"));

         EXPECT_TRUE(f2.hasPath("/tmp/jubba"));

     }

     File::unlink("/tmp/jubba");

 }

 static int TestIterate (File *file) {

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

     int lastType = -1;

     int count = 0;

     int n = 0;

     ChunkIterator it(file, 4);

     for (; it; ++it) {

         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++;

         EXPECT_LE(type, 3);

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

             n++;

     }

     if (count > 0)

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

     EXPECT_TRUE(it.atEOF());

     return n;

 }    

 static void TestWithWords (const int nWords) {

     ASSERT_EQ(8, sizeof(Chunk));

     ASSERT_EQ(8, sizeof(KeyValueChunk));

     printf("Building dictionary of %i words...\n", nWords);

     readWords();

     HashDictionary dict;

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

         Blob kv(sWords[i]);

         dict.put(Key(kv),kv);

     }

     time_t startTime = ::time(NULL);

     time_t createTime;

     {

         File file("/tmp/hashfiletest", O_RDWR | O_CREAT | O_TRUNC, true);

         VersionDictionary *hf;

         {

             Timer t("Creating & writing VersionDictionary", nWords);

             file.write("Ha5h", 4);     // VersionDictionary won't write to an empty file

             hf = VersionDictionary::create(&file, &dict);

         }

         printf("File size: %llu bytes\n", file.length());

         ASSERT_TRUE(hf!=NULL);

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

         createTime = hf->timestamp();

         ASSERT_GE(createTime, startTime);

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

         delete hf;

     }

     {

         File file("/tmp/hashfiletest");

         VersionDictionary hf(&file);

         ASSERT_EQ(0, hf.generation());

         ASSERT_EQ(createTime, hf.timestamp());

         {

             Timer t("Reading from VersionDictionary", nWords);

             EXPECT_EQ( nWords ,  hf.count() );

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

                 Key key(sWords[i]);

                 Blob value = hf.get(key);

                 ASSERT_TRUE(value);

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

             }

         }

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

         Timer t("Iterating VersionDictionary", nWords);

         int n=0;

         for( VersionDictionary::Iterator it(&hf); 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(nWords, n);

     }

     {

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

         File file("/tmp/hashfiletest", O_RDWR, true);

         OverlayVersionDictionary hf(&file);

         EXPECT_EQ( nWords ,  hf.count() );

         EXPECT_TRUE(hf.get("abatement").equals("abatement"));

         hf.put("abaser", "DEBASER");

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

         EXPECT_TRUE(hf.remove("abatement"));

         EXPECT_EQ( nWords, hf.count() );

         EXPECT_TRUE(hf.get("abaser").equals("DEBASER"));

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

         EXPECT_EQ( NULL, hf.get("abatement").bytes );

         EXPECT_TRUE(!hf.contains("abatement"));

         int n=0;

         for( OverlayVersionDictionary::Iterator it(hf); it; ++it) {

             n++;

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

         }

         ASSERT_EQ(nWords, n);

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

         {

             Timer t("Saving OverlayVersionDictionary");

             hf.save();

         }

         printf("File size: %llu bytes\n", file.length());

         EXPECT_EQ( nWords, hf.count() );

         EXPECT_TRUE(hf.get("abaser").equals("DEBASER"));

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

         EXPECT_EQ( NULL, hf.get("abatement").bytes );

         EXPECT_TRUE(!hf.contains("abatement"));

         n=0;

         for( OverlayVersionDictionary::Iterator it(hf); it; ++it) {

             n++;

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

         }

         ASSERT_EQ(nWords, n);

     }

     {

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

         File file("/tmp/hashfiletest");

         OverlayVersionDictionary hf(&file);

         ASSERT_EQ(1, hf.generation());

         ASSERT_GE(hf.timestamp(), createTime);

         ASSERT_LE(hf.timestamp(), ::time(NULL));

         EXPECT_EQ( nWords ,  hf.count() );

         EXPECT_TRUE(hf.get("abaser").equals("DEBASER"));

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

         EXPECT_EQ( NULL, hf.get("abatement").bytes );

         EXPECT_TRUE(!hf.contains("abatement"));

         int n=0;

         for( OverlayVersionDictionary::Iterator it(hf); it; ++it) {

             n++;

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

         }

         ASSERT_EQ(nWords, n);

         n = TestIterate(&file);

         EXPECT_GE(n, nWords+1+4);

         if (nWords > 1000)

             EXPECT_GE(n, nWords+256+4);

     }

     {

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

         File oldFile("/tmp/hashfiletest");

         OverlayVersionDictionary oldhf(&oldFile);

         File newFile("/tmp/hashfiletest2", O_RDWR | O_CREAT | O_TRUNC, true);

         newFile.write("Ha5h", 4);     // VersionDictionary won't write to an empty file

         oldhf.saveAs(&newFile);

         printf("File size: %llu bytes\n", newFile.length());

     }

     {

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

         File file("/tmp/hashfiletest2");

         OverlayVersionDictionary hf(&file);

         EXPECT_EQ( nWords ,  hf.count() );

         EXPECT_TRUE(hf.get("abaser").equals("DEBASER"));

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

         EXPECT_EQ( NULL, hf.get("abatement").bytes );

         EXPECT_TRUE(!hf.contains("abatement"));

         int n=0;

         for( OverlayVersionDictionary::Iterator it(hf); it; ++it) {

             n++;

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

         }

         ASSERT_EQ(nWords, n);

         n = TestIterate(&file);

         EXPECT_GE(n, nWords+1+1);

         if (nWords > 1000)

             EXPECT_EQ(nWords+256+1, n);

     }

 }    

 TEST(VersionDictionary,BuildSmall) {

     TestWithWords(100);

 }

 TEST(VersionDictionary,BuildLarge) {

     TestWithWords(sNWords);

 }