diff -r 000000000000 -r 31a43d94cc26 test/VersionDictionary_test.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/VersionDictionary_test.cpp	Sun Sep 20 15:14:12 2009 -0700
@@ -0,0 +1,265 @@
+/*
+ *  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);
+        f.write("howdy");
+    }
+    {
+        File f("/tmp/jubba", O_RDWR);
+        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);
+        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);
+        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);
+        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);
+        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);
+}