free-list-test.cpp

Go to the documentation of this file.

/*
 * free-list-test.cpp
 *
 * Copyright (C) 2010  Thomas A. Vaughan
 * All rights reserved.
 *
 * Quick test of free_list_t<T> template.
 */

// includes --------------------------------------------------------------------
#include "util/free_list.h"

#include <iostream>

#include "perf/perf.h"


struct type_t {
        long                    value;
        smart_ptr<type_t>       next;
};


typedef free_list_t<type_t> free_type_t;

typedef std::vector<smart_ptr<type_t> > vec_type_t;


////////////////////////////////////////////////////////////////////////////////
//
//      static helper methods
//
////////////////////////////////////////////////////////////////////////////////

static void
freeVector
(
IN vec_type_t& vec,
IN free_type_t& freeList
)
{
        DPRINTF("Returning all objects in vector back to free list...");
        for (vec_type_t::iterator i = vec.begin(); i != vec.end(); ++i) {
                smart_ptr<type_t>& p = *i;
                ASSERT_THROW(p, "null element in our vector");
                ASSERT_THROW(!p->next, "should be isolated element in our list");
                freeList.returnElement(*i);
        }
        vec.clear();
}



static void
populateVector
(
IN vec_type_t& vec,
IN free_type_t& freeList,
IN int count
)
{
        DPRINTF("Adding %d objects to vector from free list...", count);
        ASSERT(count > 0, "bad count: %d", count);
        for (int i = 0; i < count; ++i) {
                smart_ptr<type_t> p = freeList.getElement();
                ASSERT_THROW(p, "got a null element from free list");
                ASSERT_THROW(!p->next, "should be isolated element");
                vec.push_back(p);
        }
}



static void
doTest
(
IN int count
)
{
        int divisor = 10;
        ASSERT(count > divisor, "Bad count: %d", count);

        vec_type_t vec;
        vec.reserve(count);

        int max = count / divisor;
        free_type_t freeList(max);

        populateVector(vec, freeList, count);
        ASSERT_THROW(!freeList.size(), "should have null size");
        ASSERT_THROW(count == (int) vec.size(), "mismatch");

        freeVector(vec, freeList);
        int nAvail = freeList.size();
        ASSERT_THROW(max == nAvail,
            "Free list does not have correct number available: " << nAvail);

        populateVector(vec, freeList, max);
        nAvail = freeList.size();
        ASSERT_THROW(!nAvail, "free list should be empty again");

        freeVector(vec, freeList);
        nAvail = freeList.size();
        ASSERT_THROW(max == nAvail, "free list should be full again");

        int nRemain = 5;
        populateVector(vec, freeList, max - nRemain);
        nAvail = freeList.size();
        ASSERT_THROW(nRemain == nAvail, "Should have " << nRemain <<
            " elements in free list, but list claims " << nAvail);
        freeVector(vec, freeList);
        nAvail = freeList.size();
        ASSERT_THROW(max == nAvail, "free list should be full again");

        freeList.clear();
        nAvail = freeList.size();
        ASSERT_THROW(!nAvail, "Free list should be empty, claims " << nAvail);
}



////////////////////////////////////////////////////////////////////////////////
//
//      entry point
//
////////////////////////////////////////////////////////////////////////////////

int
main
(
IN int argc,
IN const char * argv[]
)
{
        int retval = 0;
        try {
                perf::Timer timer("overall timer");

                doTest(1000);

        } catch (std::exception& e) {
                DPRINTF("Exception: %s", e.what());
                retval = 1;
        }

        perf::dumpTimingSummary(std::cerr);

        return retval;
}