diff -r 000000000000 -r 31a43d94cc26 test/Ottoman_test.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/Ottoman_test.cpp	Sun Sep 20 15:14:12 2009 -0700
@@ -0,0 +1,203 @@
+/*
+ *  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() );
+    }
+}    
+