tool/testResources/test.cpp

Go to the documentation of this file.

/*
 * test.cpp
 *
 * Copyright (C) 2010,2011  Thomas A. Vaughan
 * All rights reserved.
 *
 * Simple test of the resource APIs/build
 */

// includes --------------------------------------------------------------------
#include "resources/resources.h"


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

static void
registerString
(
IN const char * nameSpace,
IN const char * name,
IN const char * value
)
{
        ASSERT(nameSpace, "null");
        ASSERT(name, "null");
        ASSERT(value, "null");

        int bytes = strlen(value) + 1;  // add one for null terminator

        registerResource(nameSpace, name, (const byte_t *) value, bytes);

        ASSERT_THROW(getResourceData(nameSpace, name),
            "Should have found resource now that we registered it:"
            << nameSpace << "/" << name);
}


static void
doTest
(
void
)
{
        DPRINTF("Walking registry...");
        int nNamespaces = getResourceNamespaceCount();
        DPRINTF("Found %d namespaces", nNamespaces);

        for (int i = 0; i < nNamespaces; ++i) {
                const char * nameSpace = getResourceNamespaceName(i);
                DPRINTF("namespace[%d] = '%s'", i, nameSpace);
                ASSERT_THROW(nameSpace, "null");

                int nStrings = getResourceCount(nameSpace);
                DPRINTF("  namespace '%s' contains %d resources",
                    nameSpace, nStrings);

                for (int j = 0; j < nStrings; ++j) {
                        const char * name = getResourceName(nameSpace, j);
                        ASSERT_THROW(name, "Failed to look up resource: " << j);
                        DPRINTF("    string resource name %d: '%s'",
                            j, name);
                        const byte_t * raw_bytes =
                            getResourceData(nameSpace, name);
                        ASSERT_THROW(raw_bytes, "null resource value");
                        const char * value = (const char *) raw_bytes;
                        DPRINTF("      %s: '%s'", name, value);
                }
        }

        // example of hard-coded constants that the code expects to be there
        DPRINTF("Verifying hard-coded lookups...");
        ASSERT_THROW(getResourceData("foo", "example1.txt"),
            "Should have found registered string");
        ASSERT_THROW(getResourceData("foo", "example2.txt"),
            "Should have found registered string");
        ASSERT_THROW(getResourceData("bar", "example1.txt"),
            "Should have found registered string");

        DPRINTF("Verifying lookup failures...");
        ASSERT_THROW(!getResourceData("bar", "example2.txt"),
            "Only namespace 'foo' should have resource 'example2.txt'");

        // shouldn't find this one
        const char * nameSpace = "baz";
        const char * name = "example3";
        ASSERT_THROW(!getResourceData(nameSpace, name),
            "Expected null result for unregistered string");

        DPRINTF("Verifying runtime registration...");
        registerString(nameSpace, name, "bogus string example");

        // try a binary object
        DPRINTF("Verifying binary resources...");
        const int nLongs = 1024;
        long data[nLongs];
        for (int i = 0; i < nLongs; ++i) {
                data[i] = rand();
        }

        int bytes = nLongs * sizeof(long);
        registerResource(nameSpace, name, (const byte_t *) data, bytes);

        const byte_t * rawData = getResourceData(nameSpace, name);
        ASSERT_THROW(rawData,
            "Should have found binary resource since we just registered it");

        int outBytes = getResourceSize(nameSpace, name);
        ASSERT_THROW(outBytes == bytes,
            "registered resource bytes (" << outBytes << ") don't match " <<
            "what we registered (" << bytes << ")");

        // verify
        const long * out = (const long *) rawData;
        for (int i = 0; i < nLongs; ++i) {
                ASSERT_THROW(data[i] == out[i],
                    "Data mismatch at element " << i);
        }
}



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

int
main
(
IN int argc,
IN const char * argv[]
)
{
        int result = 0;

        try {
                doTest();

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

        return result;
}