testStore.cc

Go to the documentation of this file.

/*
 * Copyright (C) 1996-2023 The Squid Software Foundation and contributors
 *
 * Squid software is distributed under GPLv2+ license and includes
 * contributions from numerous individuals and organizations.
 * Please see the COPYING and CONTRIBUTORS files for details.
 */
 
#include "squid.h"
#include "Store.h"
#include "store/SwapMeta.h"
#include "testStore.h"
#include "unitTestMain.h"
 
#include <limits>
 
CPPUNIT_TEST_SUITE_REGISTRATION( TestStore );
 
int
StoreControllerStub::callback()
{
    return 1;
}
 
StoreEntry*
StoreControllerStub::get(const cache_key*)
{
    return nullptr;
}
 
void
StoreControllerStub::get(String, void (*)(StoreEntry*, void*), void*)
{}
 
void
StoreControllerStub::init()
{}
 
uint64_t
StoreControllerStub::maxSize() const
{
    return 3;
}
 
uint64_t
StoreControllerStub::minSize() const
{
    return 1;
}
 
uint64_t
StoreControllerStub::currentSize() const
{
    return 2;
}
 
uint64_t
StoreControllerStub::currentCount() const
{
    return 2;
}
 
int64_t
StoreControllerStub::maxObjectSize() const
{
    return 1;
}
 
void
StoreControllerStub::getStats(StoreInfoStats &) const
{
}
 
void
StoreControllerStub::stat(StoreEntry &) const
{
    const_cast<StoreControllerStub *>(this)->statsCalled = true;
}
 
StoreSearch *
StoreControllerStub::search()
{
    return nullptr;
}
 
void
TestStore::testSetRoot()
{
    Store::Controller *aStore(new StoreControllerStub);
    Store::Init(aStore);
 
    CPPUNIT_ASSERT_EQUAL(&Store::Root(), aStore);
    Store::FreeMemory();
}
 
void
TestStore::testUnsetRoot()
{
    Store::Controller *aStore(new StoreControllerStub);
    Store::Controller *aStore2(new StoreControllerStub);
    Store::Init(aStore);
    Store::FreeMemory();
    Store::Init(aStore2);
    CPPUNIT_ASSERT_EQUAL(&Store::Root(),aStore2);
    Store::FreeMemory();
}
 
void
TestStore::testStats()
{
    StoreControllerStub *aStore(new StoreControllerStub);
    Store::Init(aStore);
    CPPUNIT_ASSERT_EQUAL(false, aStore->statsCalled);
    StoreEntry entry;
    Store::Stats(&entry);
    CPPUNIT_ASSERT_EQUAL(true, aStore->statsCalled);
    Store::FreeMemory();
}
 
void
TestStore::testMaxSize()
{
    Store::Controller *aStore(new StoreControllerStub);
    Store::Init(aStore);
    CPPUNIT_ASSERT_EQUAL(static_cast<uint64_t>(3), aStore->maxSize());
    Store::FreeMemory();
}
 
namespace Store {
 
static void
checkIgnorableSwapMetaRawType(const RawSwapMetaType rawType)
{
    if (IgnoredSwapMetaType(rawType)) {
        // an ignored raw type is either deprecated or reserved
        CPPUNIT_ASSERT(DeprecatedSwapMetaType(rawType) || ReservedSwapMetaType(rawType));
        CPPUNIT_ASSERT(!(DeprecatedSwapMetaType(rawType) && ReservedSwapMetaType(rawType)));
    } else {
        // all other raw types are neither deprecated nor reserved
        CPPUNIT_ASSERT(!DeprecatedSwapMetaType(rawType) && !ReservedSwapMetaType(rawType));
    }
}
 
static void
checkTooSmallSwapMetaRawType(const RawSwapMetaType rawType)
{
    // RawSwapMetaTypeBottom and smaller values are unrelated to any named
    // SwapMetaDataType values, including past, current, and future ones
    CPPUNIT_ASSERT(!HonoredSwapMetaType(rawType)); // current
    CPPUNIT_ASSERT(!IgnoredSwapMetaType(rawType)); // past and future
    CPPUNIT_ASSERT(!DeprecatedSwapMetaType(rawType)); // past
    CPPUNIT_ASSERT(!ReservedSwapMetaType(rawType)); // future
}
 
static void
checkKnownSwapMetaRawType(const RawSwapMetaType rawType)
{
    // an in-range rawType other than STORE_META_VOID is either honored or ignored
    CPPUNIT_ASSERT(HonoredSwapMetaType(rawType) || IgnoredSwapMetaType(rawType));
    CPPUNIT_ASSERT(!(HonoredSwapMetaType(rawType) && IgnoredSwapMetaType(rawType)));
    checkIgnorableSwapMetaRawType(rawType);
}
 
static void
checkTooBigSwapMetaRawType(const RawSwapMetaType rawType)
{
    // values beyond RawSwapMetaTypeTop() cannot be honored but may be ignored
    CPPUNIT_ASSERT(!HonoredSwapMetaType(rawType));
    checkIgnorableSwapMetaRawType(rawType);
}
 
static void
checkSwapMetaRawType(const RawSwapMetaType rawType)
{
    if (rawType <= RawSwapMetaTypeBottom)
        checkTooSmallSwapMetaRawType(rawType);
    else if (rawType > RawSwapMetaTypeTop())
        checkTooBigSwapMetaRawType(rawType);
    else
        checkKnownSwapMetaRawType(rawType);
}
 
} // namespace Store
 
void
TestStore::testSwapMetaTypeClassification()
{
    using limits = std::numeric_limits<Store::RawSwapMetaType>;
    for (auto rawType = limits::min(); true; ++rawType) {
 
        Store::checkSwapMetaRawType(rawType);
 
        if (rawType == limits::max())
            break;
    }
 
    // Store::RawSwapMetaTypeTop() is documented as an honored type value
    CPPUNIT_ASSERT(Store::HonoredSwapMetaType(Store::RawSwapMetaTypeTop()));
}
 
class MyTestProgram: public TestProgram
{
public:
    /* TestProgram API */
    void startup() override { Mem::Init(); }
};
 
int
main(int argc, char *argv[])
{
    return MyTestProgram().run(argc, argv);
}