env.cpp

About: hamsterdb is a database engine written in ANSI C. It supports a B+Tree index structure, uses

        for (i=0; i<MAX_DB; i++) {
            CPPUNIT_ASSERT_EQUAL(0, ham_cursor_close(cursor[i]));
            CPPUNIT_ASSERT_EQUAL(0, ham_close(db[i]));
            CPPUNIT_ASSERT_EQUAL(0, ham_delete(db[i]));
        }

        CPPUNIT_ASSERT_EQUAL(0, ham_env_close(env));
        CPPUNIT_ASSERT_EQUAL(0, ham_env_delete(env));
    }

    void multiDbInsertFindExtendedCloseReopenTest(void)
    {
        int i;
        const int MAX_DB=5;
        const int MAX_ITEMS=300;
        ham_env_t *env;
        ham_db_t *db[MAX_DB];
        ham_record_t rec;
        ham_key_t key;
        char buffer[512];

        CPPUNIT_ASSERT_EQUAL(0, ham_env_new(&env));
        CPPUNIT_ASSERT_EQUAL(0, ham_env_create(env, ".test", m_flags, 0664));

        for (i=0; i<MAX_DB; i++) {
            CPPUNIT_ASSERT_EQUAL(0, ham_new(&db[i]));
            CPPUNIT_ASSERT_EQUAL(0, ham_env_create_db(env, db[i], 
                        (ham_u16_t)i+1, 0, 0));
        }

        for (i=0; i<MAX_DB; i++) {
            for (int j=0; j<MAX_ITEMS; j++) {
                int value=j*(i+1);
                memset(&key, 0, sizeof(key));
                memset(&rec, 0, sizeof(rec));
                memset(buffer, (char)value, sizeof(buffer));
                key.data=buffer;
                key.size=sizeof(buffer);
                rec.data=buffer;
                rec.size=sizeof(buffer);
                sprintf(buffer, "%08x%08x", j, i+1);

                CPPUNIT_ASSERT_EQUAL(0, ham_insert(db[i], 0, &key, &rec, 0));
            }
            CPPUNIT_ASSERT_EQUAL(0, ham_close(db[i]));
        }

        if (!(m_flags&HAM_IN_MEMORY_DB)) {
            CPPUNIT_ASSERT_EQUAL(0, ham_env_close(env));
            CPPUNIT_ASSERT_EQUAL(0, ham_env_open(env, ".test", m_flags));

            for (i=0; i<MAX_DB; i++) {
                CPPUNIT_ASSERT_EQUAL(0, ham_env_open_db(env, db[i], 
                            (ham_u16_t)i+1, 0, 0));
                for (int j=0; j<MAX_ITEMS; j++) {
                    int value=j*(i+1);
                    memset(&key, 0, sizeof(key));
                    memset(&rec, 0, sizeof(rec));
                    memset(buffer, (char)value, sizeof(buffer));
                    key.data=buffer;
                    key.size=sizeof(buffer);
                    sprintf(buffer, "%08x%08x", j, i+1);
    
                    CPPUNIT_ASSERT_EQUAL(0, ham_find(db[i], 0, &key, &rec, 0));
                    CPPUNIT_ASSERT_EQUAL((ham_size_t)sizeof(buffer), rec.size);
                    CPPUNIT_ASSERT_EQUAL(0, memcmp(buffer, rec.data, rec.size));
                }
            }

            for (i=0; i<MAX_DB; i++) {
                CPPUNIT_ASSERT_EQUAL(0, ham_close(db[i]));
            }
        }

        for (i=0; i<MAX_DB; i++) {
            CPPUNIT_ASSERT_EQUAL(0, ham_delete(db[i]));
        }

        CPPUNIT_ASSERT_EQUAL(0, ham_env_close(env));
        CPPUNIT_ASSERT_EQUAL(0, ham_env_delete(env));
    }

    void renameOpenDatabases(void)
    {
        int i;
        const int MAX_DB=10;
        ham_env_t *env;
        ham_db_t *db[MAX_DB];

        CPPUNIT_ASSERT_EQUAL(0, ham_env_new(&env));
        CPPUNIT_ASSERT_EQUAL(0, ham_env_create(env, ".test", m_flags, 0664));

        for (i=0; i<MAX_DB; i++) {
            CPPUNIT_ASSERT_EQUAL(0, ham_new(&db[i]));
            CPPUNIT_ASSERT_EQUAL(0, ham_env_create_db(env, db[i], 
                        (ham_u16_t)i+1, 0, 0));
        }

        for (i=0; i<MAX_DB; i++) {
            CPPUNIT_ASSERT_EQUAL(0, ham_env_rename_db(env, 
                        (ham_u16_t)i+1, (ham_u16_t)i+1000, 0));
            CPPUNIT_ASSERT_EQUAL(0, ham_close(db[i]));
        }

        if (!(m_flags&HAM_IN_MEMORY_DB)) {
            for (i=0; i<MAX_DB; i++) {
                CPPUNIT_ASSERT_EQUAL(0, ham_env_open_db(env, db[i], 
                            (ham_u16_t)i+1000, 0, 0));
            }

            for (i=0; i<MAX_DB; i++) {
                CPPUNIT_ASSERT_EQUAL(0, ham_close(db[i]));
            }
        }

        for (i=0; i<MAX_DB; i++) {
            CPPUNIT_ASSERT_EQUAL(0, ham_delete(db[i]));
        }

        CPPUNIT_ASSERT_EQUAL(0, ham_env_close(env));
        CPPUNIT_ASSERT_EQUAL(0, ham_env_delete(env));
    }

    void renameClosedDatabases(void)
    {
        int i;
        const int MAX_DB=10;
        ham_env_t *env;
        ham_db_t *db[MAX_DB];

        CPPUNIT_ASSERT_EQUAL(0, ham_env_new(&env));
        CPPUNIT_ASSERT_EQUAL(0, ham_env_create(env, ".test", m_flags, 0664));

        for (i=0; i<MAX_DB; i++) {
            CPPUNIT_ASSERT_EQUAL(0, ham_new(&db[i]));
            CPPUNIT_ASSERT_EQUAL(0, ham_env_create_db(env, db[i], 
                        (ham_u16_t)i+1, 0, 0));
            CPPUNIT_ASSERT_EQUAL(0, ham_close(db[i]));
        }

        for (i=0; i<MAX_DB; i++) {
            CPPUNIT_ASSERT_EQUAL(0, ham_env_rename_db(env, 
                        (ham_u16_t)i+1, (ham_u16_t)i+1000, 0));
        }

        for (i=0; i<MAX_DB; i++) {
            CPPUNIT_ASSERT_EQUAL(0, ham_env_open_db(env, db[i], 
                        (ham_u16_t)i+1000, 0, 0));
            CPPUNIT_ASSERT_EQUAL(0, ham_close(db[i]));
            CPPUNIT_ASSERT_EQUAL(0, ham_delete(db[i]));
        }

        CPPUNIT_ASSERT_EQUAL(0, ham_env_close(env));
        CPPUNIT_ASSERT_EQUAL(0, ham_env_delete(env));
    }

    void eraseOpenDatabases(void)
    {
        int i;
        const int MAX_DB=1;
        ham_env_t *env;
        ham_db_t *db[MAX_DB];

        CPPUNIT_ASSERT_EQUAL(0, ham_env_new(&env));
        CPPUNIT_ASSERT_EQUAL(0, ham_env_create(env, ".test", m_flags, 0664));

        for (i=0; i<MAX_DB; i++) {
            CPPUNIT_ASSERT_EQUAL(0, ham_new(&db[i]));
            CPPUNIT_ASSERT_EQUAL(0, ham_env_create_db(env, db[i], 
                        (ham_u16_t)i+1, 0, 0));
        }

        for (i=0; i<MAX_DB; i++) {
            CPPUNIT_ASSERT_EQUAL(HAM_DATABASE_ALREADY_OPEN, 
                            ham_env_erase_db(env, (ham_u16_t)i+1, 0));
            CPPUNIT_ASSERT_EQUAL(0, ham_close(db[i]));
            CPPUNIT_ASSERT_EQUAL(0, ham_delete(db[i]));
            if (m_flags&HAM_IN_MEMORY_DB)
                CPPUNIT_ASSERT_EQUAL(HAM_DATABASE_NOT_FOUND, 
                        ham_env_erase_db(env, (ham_u16_t)i+1, 0));
            else
                CPPUNIT_ASSERT_EQUAL(0, 
                        ham_env_erase_db(env, (ham_u16_t)i+1, 0));
        }

        CPPUNIT_ASSERT_EQUAL(0, ham_env_close(env));
        CPPUNIT_ASSERT_EQUAL(0, ham_env_delete(env));
    }

    void eraseUnknownDatabases(void)
    {
        int i;
        const int MAX_DB=1;
        ham_env_t *env;
        ham_db_t *db[MAX_DB];

        CPPUNIT_ASSERT_EQUAL(0, ham_env_new(&env));
        CPPUNIT_ASSERT_EQUAL(0, ham_env_create(env, ".test", m_flags, 0664));

        for (i=0; i<MAX_DB; i++) {
            CPPUNIT_ASSERT_EQUAL(0, ham_new(&db[i]));
            CPPUNIT_ASSERT_EQUAL(0, ham_env_create_db(env, db[i], 
                        (ham_u16_t)i+1, 0, 0));
        }

        for (i=0; i<MAX_DB; i++) {
            CPPUNIT_ASSERT_EQUAL(HAM_DATABASE_NOT_FOUND, 
                            ham_env_erase_db(env, (ham_u16_t)i+1000, 0));
            CPPUNIT_ASSERT_EQUAL(0, ham_close(db[i]));
            CPPUNIT_ASSERT_EQUAL(HAM_DATABASE_NOT_FOUND, 
                            ham_env_erase_db(env, (ham_u16_t)i+1000, 0));
            CPPUNIT_ASSERT_EQUAL(0, ham_delete(db[i]));
        }

        CPPUNIT_ASSERT_EQUAL(0, ham_env_close(env));
        CPPUNIT_ASSERT_EQUAL(0, ham_env_delete(env));
    }

    void eraseMultipleDatabases(void)
    {
        int i, j;
        const int MAX_DB=10;
        const int MAX_ITEMS=300;
        ham_env_t *env;
        ham_db_t *db[MAX_DB];
        ham_record_t rec;
        ham_key_t key;
        char buffer[512];

        CPPUNIT_ASSERT_EQUAL(0, ham_env_new(&env));
        CPPUNIT_ASSERT_EQUAL(0, ham_env_create(env, ".test", m_flags, 0664));

        for (i=0; i<MAX_DB; i++) {
            CPPUNIT_ASSERT_EQUAL(0, ham_new(&db[i]));
            CPPUNIT_ASSERT_EQUAL(0, ham_env_create_db(env, db[i], 
                        (ham_u16_t)i+1, 0, 0));
            for (j=0; j<MAX_ITEMS; j++) {
                memset(&key, 0, sizeof(key));
                memset(&rec, 0, sizeof(rec));
                sprintf(buffer, "%08x%08x", j, i+1);
                key.data=buffer;
                key.size=sizeof(buffer);
                rec.data=buffer;
                rec.size=sizeof(buffer);

                CPPUNIT_ASSERT_EQUAL(0, ham_insert(db[i], 0, &key, &rec, 0));
            }
            CPPUNIT_ASSERT_EQUAL(0, ham_close(db[i]));
        }

        for (i=0; i<MAX_DB; i++) {
            CPPUNIT_ASSERT_EQUAL(0, ham_env_erase_db(env, (ham_u16_t)i+1, 0));
        }

        for (i=0; i<10; i++) {
            CPPUNIT_ASSERT_EQUAL(HAM_DATABASE_NOT_FOUND, 
                            ham_env_open_db(env, db[i], (ham_u16_t)i+1, 0, 0));
            CPPUNIT_ASSERT_EQUAL(0, ham_delete(db[i]));
        }

        CPPUNIT_ASSERT_EQUAL(0, ham_env_close(env));
        CPPUNIT_ASSERT_EQUAL(0, ham_env_delete(env));
    }

    void endianTestOpenDatabase(void)
    {
        ham_env_t *env;
        ham_db_t *db;

        CPPUNIT_ASSERT_EQUAL(0, ham_env_new(&env));
        CPPUNIT_ASSERT_EQUAL(0, ham_new(&db));

#if HAM_LITTLE_ENDIAN
        CPPUNIT_ASSERT_EQUAL(0, ham_env_open(env, 
                    "data/env-endian-test-open-database-be.hdb", 0));
#else
        CPPUNIT_ASSERT_EQUAL(0, ham_env_open(env, 
                    "data/env-endian-test-open-database-le.hdb", 0));
#endif
        CPPUNIT_ASSERT_EQUAL(0, ham_env_open_db(env, db, 1, 0, 0));
        CPPUNIT_ASSERT_EQUAL(0, ham_close(db));
        CPPUNIT_ASSERT_EQUAL(0, ham_env_open_db(env, db, 2, 0, 0));
        CPPUNIT_ASSERT_EQUAL(0, ham_close(db));

        CPPUNIT_ASSERT_EQUAL(0, ham_delete(db));
        CPPUNIT_ASSERT_EQUAL(0, ham_env_close(env));
        CPPUNIT_ASSERT_EQUAL(0, ham_env_delete(env));
    }

};

class InMemoryEnvTest : public EnvTest
{
    CPPUNIT_TEST_SUITE(InMemoryEnvTest);
    CPPUNIT_TEST      (createCloseTest);
    CPPUNIT_TEST      (openWithKeysizeTest);
    CPPUNIT_TEST      (createWithKeysizeTest);
    CPPUNIT_TEST      (createDbWithKeysizeTest);
    CPPUNIT_TEST      (disableVarkeyTests);
    CPPUNIT_TEST      (memoryDbTest);
    CPPUNIT_TEST      (multiDbInsertFindTest);
    CPPUNIT_TEST      (multiDbInsertFindExtendedTest);
    CPPUNIT_TEST      (multiDbInsertFindExtendedEraseTest);
    CPPUNIT_TEST      (multiDbInsertCursorTest);
    CPPUNIT_TEST      (multiDbInsertFindExtendedCloseReopenTest);
    CPPUNIT_TEST      (renameOpenDatabases);
    CPPUNIT_TEST      (eraseOpenDatabases);
    CPPUNIT_TEST      (eraseUnknownDatabases);
    CPPUNIT_TEST_SUITE_END();

public:
    InMemoryEnvTest()
    :   EnvTest(HAM_IN_MEMORY_DB)
    {
    }

    void memoryDbTest(void)
    {
        int i;
        ham_env_t *env;
        ham_db_t *db[10];

        CPPUNIT_ASSERT_EQUAL(0, ham_env_new(&env));
        CPPUNIT_ASSERT_EQUAL(0, ham_env_create(env, ".test", m_flags, 0664));

        for (i=0; i<10; i++) {
            CPPUNIT_ASSERT_EQUAL(0, ham_new(&db[i]));
            CPPUNIT_ASSERT_EQUAL(0, ham_env_create_db(env, db[i], 
                        (ham_u16_t)i+1, 0, 0));
        }

        for (i=0; i<10; i++) {
            CPPUNIT_ASSERT_EQUAL(0, ham_close(db[i]));
            CPPUNIT_ASSERT_EQUAL(0, ham_delete(db[i]));
        }

        CPPUNIT_ASSERT_EQUAL(0, ham_env_close(env));
        CPPUNIT_ASSERT_EQUAL(0, ham_env_delete(env));
    }
};

CPPUNIT_TEST_SUITE_REGISTRATION(EnvTest);
CPPUNIT_TEST_SUITE_REGISTRATION(InMemoryEnvTest);