xdrbuf/test/test1.cpp

Go to the documentation of this file.

/*
 * test1.cpp
 *
 * Copyright (C) 2008  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 tests for the XDROutputBuffer object.
 */

// includes --------------------------------------------------------------------
#include "xdrbuf/xdrbuf.h"              // include library header first

#include <iostream>

#include "common/wave_ex.h"
#include "perf/perf.h"



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

static smart_ptr<xdrbuf::Output>
getOutput
(
IN int size,
IN int nLongs,
IN int nFloats,
IN const char * s
)
{
        ASSERT(size > 0, "Bad size: %d", size);
        ASSERT(nLongs >= 0, "Bad long count: %d", nLongs);
        ASSERT(nFloats >= 0, "Bad float count: %d", nFloats);
        ASSERT(s, "null");

        smart_ptr<xdrbuf::Output> out = xdrbuf::Output::create(size);
        ASSERT(out, "null");

        DPRINTF("Requested buffer of size: %d bytes", size);
        DPRINTF("  Remaining bytes: %d", out->getRemainingBytes());
        if (size != out->getRemainingBytes()) {
                WAVE_EX(wex);
                wex << "Should have size == remaining bytes!";
        }

        DPRINTF("  Adding %d int32s...", nLongs);
        std::vector<int32_t> veclong;
        veclong.resize(nLongs);
        for (long l = 0; l < nLongs; ++l) {
                veclong[l] = l;
        }
        out->addInt32Packlet('a', &veclong[0], nLongs);
        DPRINTF("  Remaining bytes: %d", out->getRemainingBytes());

        DPRINTF("  Adding %d floats...", nFloats);
        std::vector<float> vecfloat;
        vecfloat.resize(nFloats);
        for (long l = 0; l < nFloats; ++l) {
                vecfloat[l] = 1.0 * l;
        }
        out->addFloatPacklet('b', &vecfloat[0], nFloats);
        DPRINTF("  Remaining bytes: %d", out->getRemainingBytes());

        int len = strlen(s);
        DPRINTF("  Adding string: %s", s);
        DPRINTF("    length = %d", len);
        out->addStringPacklet('c', s, len);
        DPRINTF("  Remaining bytes: %d", out->getRemainingBytes());

        out->openPacklet('o');
        out->addStringPacklet('q', "test", 4);
        out->closePacklet('o');

        return out;
}



static void
parse
(
IN xdrbuf::Input * in
)
{
        ASSERT(in, "null");

        xdrbuf::PackletHeader p = in->getNextPackletHeader();

        char n = p.getName();
        DPRINTF("  name: '%c'", n);

        xdrbuf::ePackletType type = p.getType();
        DPRINTF("  type: %d", type);

        int count = p.getDataCount();
        DPRINTF("  count: %d", count);

        switch (type) {
        case xdrbuf::ePacklet_ParentBegin:
                {
                        DPRINTF("Opening a packlet!");
                        while (!in->endOfStream()) {
                                parse(in);
                        }
                }
                break;

        case xdrbuf::ePacklet_ParentEnd:
                {
                        DPRINTF("End of buffer!");
                        return;
                }

        case xdrbuf::ePacklet_String:
                {
                        DPRINTF("Found a string!");
                        DPRINTF("  %d characters", count);
                        char buffer[2048];
                        in->readString(buffer, count);
                        buffer[count] = 0;
                        DPRINTF("  Read: '%s'", buffer);
                }
                break;

        case xdrbuf::ePacklet_Int32s:
                {
                        DPRINTF("Found %d int32s", count);
                        int32_t buffer[2048];
                        in->readInt32s(buffer, count);
                }
                break;

        case xdrbuf::ePacklet_Floats:
                {
                        DPRINTF("Found %d floats", count);
                        float buffer[2048];
                        in->readFloats(buffer, count);
                }
                break;

        default:
                ASSERT(false, "Unknown type?");
        }
}



static void
doTest1
(
IN int bytes,
IN int nLongs,
IN int nFloats,
IN const char * s
)
{
        perf::Timer timer("doTest1");
        smart_ptr<xdrbuf::Output> out = getOutput(bytes, nLongs, nFloats, s);
        ASSERT(out, "null");

        const byte_t * data = out->getData();
        ASSERT(data, "null");

        int dbytes = out->getDataBytes();
        ASSERT(dbytes > 0, "Bad bytes: %d", dbytes);

        smart_ptr<xdrbuf::Input> in = xdrbuf::Input::create();
        ASSERT(in, "null");

        in->reset(data, dbytes);

        while (!in->endOfStream()) {
                parse(in);
        }
}



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

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

                doTest1(1200, 100, 100, "foo");
                doTest1(1200, 100, 100, "a");
                doTest1(1200, 100, 100, "foot");
                doTest1(1200, 100, 100, "foote");

                bool threw = false;
                try {
                        doTest1(40, 10, 10, "yessiree");
                } catch (std::exception&) {
                        threw = true;
                }
                ASSERT_THROW(threw,
                    "Should have complained about small buffer!");

        } catch (std::exception& e) {
                DPRINTF("Exception: %s", e.what());
                retval = 1;
        } catch (...) {
                DPRINTF("Unknown exception!");
                retval = 2;
        }
        if (!retval) {
                DPRINTF("Success!  All tests passed.");
        }

        perf::dumpTimingSummary(std::cerr);

        return retval;
}