bsp-test.cpp

Go to the documentation of this file.

/*
 * bsp-test.cpp
 *
 * Copyright (C) 2010  Thomas A. Vaughan
 * All rights reserved.
 *
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the <organization> nor the
 *       names of its contributors may be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THOMAS A. VAUGHAN ''AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THOMAS A. VAUGHAN BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 *
 * Quick test for BSP parsing
 */

// includes --------------------------------------------------------------------
#include "quake/bsp/bsp.h"

#include <iostream>

#include "perf/perf.h"
#include "util/file.h"



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

static void
doTest
(
IN const char * filename
)
{
        ASSERT(filename, "null");

        // create filesystem manager
        std::string parentDir;
        GetParentDirectory(filename, parentDir);

        smart_ptr<nstream::Manager> mgr =
            nstream::getFilesystemManager(parentDir.c_str());
        ASSERT_THROW(mgr, "failed to get filesystem manager");

        const char * name = GetFilename(filename);

        // open stream
        smart_ptr<nstream::Stream> stream =
            nstream::openNamedStream(mgr, name);
        ASSERT_THROW(stream, "failed to open named stream: " << name);

        // now load bsp
        smart_ptr<quake::Bsp> bsp = quake::Bsp::load(stream);
        ASSERT_THROW(bsp, "failed to load bsp");

        DPRINTF("Just loaded bsp with name: '%s'", bsp->getName());

        // iterate lumps
        const quake::vec_lump_type_t& lumps = bsp->getLumps();
        DPRINTF("Contains %d lumps", (int) lumps.size());
        for (quake::vec_lump_type_t::const_iterator i = lumps.begin();
             i != lumps.end(); ++i) {
                quake::eLumpType type = *i;
                const char * name = quake::getLumpName(type);
                ASSERT_THROW(name, "Name not found for type: " << type);
                DPRINTF("Reading lump: %s", name);

                int nObjects = bsp->getLumpObjectCount(type);
                DPRINTF("  There are %d objects of this type", nObjects);
                if (!nObjects) {
                        DPRINTF("  Lump is empty or does not exist!");
                        continue;
                }
                if (nObjects < 0) {
                        DPRINTF("  Variable number of objects in lump!");
                        nObjects = 0x7ffff;
                }

                // okay, apparently have objects.  Start iteration!
                std::string timerName = "iterateAllLump";
                timerName += name;

                {
                        perf::Timer timer(timerName.c_str());

                        bsp->startLumpIteration(type);
                        const quake::lump_object_t * obj = NULL;
                        int j = 0;      // index
                        while (true) {
                                obj = bsp->getNextLumpObject();
                                if (!obj) {
                                        // end of iteration
                                        break;
                                }
                                ASSERT_THROW(obj->index == j,
                                    "Iteration object has bad index " <<
                                    obj->index << " vs. correct index " << j);
                                quake::eLumpType oType = obj->getType();
                                ASSERT_THROW(oType == type,
                                    "Iteration object has bad type " << oType
                                    << " vs. correct type " << type);
                                ++j;
                        }
                        DPRINTF("  Read %d total objects", j);
                }
        }
}



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

int
main
(
IN int argc,
IN const char * argv[]
)
{
        ASSERT(2 == argc, "usage: quake-bsp-test <bsp-filename>");
        const char * filename = argv[1];

        int retval = 0;
        try {
                perf::Timer timer("test -- overall timer");
                doTest(filename);

        } catch (std::exception& e) {
                DPRINTF("Exception: %s", e.what());
                retval = 1;
        } catch (...) {
                DPRINTF("Unknown exception!");
                retval = 2;
        }
        perf::dumpTimingSummary(std::cerr);

        return retval;
}