/home/laradmin/lar/utils/wrapper_collada/src/mytest.cpp

Go to the documentation of this file.

/**************************************************************************************************
 Software License Agreement (BSD License)

 Copyright (c) 2011-2013, LAR toolkit developers - University of Aveiro - http://lars.mec.ua.pt
 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 University of Aveiro 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 THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 THE COPYRIGHT HOLDER OR
 CONTRIBUTORS 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.
***************************************************************************************************/
#include <cstdarg>
#include <iostream>
#include <iomanip>
#include <string>
#include <sstream>
#include <memory>
#include <map>
#include <vector>
#include <set>
#include <dae.h>
#include <dom/domConstants.h>
#include <dom/domCOLLADA.h>
#include <dom/domProfile_common.h>
#include <dae/daeSIDResolver.h>
#include <dom/domInstance_controller.h>
#include <dae/domAny.h>
#include <dae/daeErrorHandler.h>
#include <dae/daeUtils.h>
#include <dom/domImage.h>
#include <modules/stdErrPlugin.h>
#include <dom/domEllipsoid.h>
#include <dom/domInput_global.h>
#include <dom/domAsset.h>
#include <dom/domLimits_sub.h>
#include "domTest.h"

#define PFLN {printf("DEBUG PRINT FILE %s LINE %d\n",__FILE__,__LINE__);}
using namespace ColladaDOM150;
using namespace cdom;

void my_addGeometry(daeElement* root);
void my_addVisualScene(daeElement* root);
void my_addEffect(daeElement* root);
void my_addMaterial(daeElement* root); 
void my_addImage(daeElement* root);
void my_addSource(daeElement* mesh,
                     const std::string& srcID,
                     const std::string& paramNames,
                     domFloat values[],
                     int valueCount);

template<typename T>
daeTArray<T> rawArrayToDaeArray(T rawArray[], size_t count) {
        daeTArray<T> result;
        for (size_t i = 0; i < count; i++)
                result.append(rawArray[i]);
        return result;
}

namespace fs = boost::filesystem;
using namespace std;
using namespace cdom;

float toFloat(const string& s) {
        istringstream stream(s);
        float f;
        stream >> f;
        return f;
}

#define CheckResultWithMsg(val, msg) \
        if (!(val)) { \
                return testResult(false, __FILE__, __LINE__, msg); \
        }

#define CompareDocs(dae, file1, file2) \
{ \
        domCOLLADA *root1 = (dae).getRoot(file1), \
        *root2 = (dae).getRoot(file2); \
        daeElement::compareResult result = daeElement::compareWithFullResult(*root1, *root2); \
        if (result.compareValue != 0) { \
                return testResult(false, __FILE__, __LINE__, result.format()); \
        } \
}

map<string, domTest*>& registeredTests() {
        static map<string, domTest*> tests;
        return tests;
}

fs::path& dataPath() {
        static fs::path dataPath_;
        return dataPath_;
}

fs::path& tmpPath() {
        static fs::path tmpPath_;
        return tmpPath_;
}

#define RunTest(testName) \
{ \
        map<string, domTest*>::iterator iter = registeredTests().find(#testName); \
        CheckResult(iter != registeredTests().end()); \
        CheckResult(iter->second->run()); \
}


string lookupTestFile(const string& fileName) {
        return (dataPath() / fileName).native_file_string();
}

string getTmpFile(const string& fileName) {
        return (tmpPath() / fileName).native_file_string();
}


string chopWS(const string& s) {
        string ws = " \t\n\r";
        size_t beginPos = s.find_first_not_of(ws);
        size_t endPos = s.find_last_not_of(ws);
        if (beginPos == string::npos)
                return "";
        return s.substr(beginPos, endPos-beginPos+1);
}

DefineTest(chopWS) {
        CheckResult(chopWS("") == "");
        CheckResult(chopWS("") == "");
        CheckResult(chopWS(" ") == "");
        CheckResult(chopWS(" test") == "test");
        CheckResult(chopWS("test ") == "test");
        CheckResult(chopWS(" test ") == "test");
        CheckResult(chopWS(" a ") == "a");
        return testResult(true);
}


DefineTest(utils) {
        CheckResult(replace("abc", "abc", "def") == "def");
        CheckResult(replace("abc", "a", "1") == "1bc");
        CheckResult(replace("abc", "c", "1") == "ab1");
        CheckResult(replace("abc123", "bc12", "b") == "ab3");
        CheckResult(replace("abracadabra", "a", "") == "brcdbr");

        CheckResult(tokenize("1|2|3|4", "|")   == makeStringList("1", "2", "3", "4", 0));
        CheckResult(tokenize("|1|", "|")       == makeStringList("1", 0));
        CheckResult(tokenize("1|||2||3|", "|") == makeStringList("1", "2", "3", 0));
        CheckResult(tokenize("1|||2||3|", "|", true) ==
                        makeStringList("1", "|", "|", "|", "2", "|", "|", "3", "|", 0));
        CheckResult(tokenize("this/is some#text", "/#", true) ==
                        makeStringList("this", "/", "is some", "#", "text", 0));
        CheckResult(tokenize("this/is some#text", "/# ", false) ==
                        makeStringList("this", "is", "some", "text", 0));

        CheckResult(toString(5) == "5");
        CheckResult(toFloat(toString(4.0f)) == 4.0f);

        return testResult(true);
}


DefineTest(elementAddFunctions) {
        DAE dae;
        const char* uri = "file.dae";

        // Test the new 'add' functions
        daeElement* root = dae.add(uri);
        CheckResult(root);
        daeElement* geomLib = root->add("library_geometries");
        CheckResult(geomLib);
        daeElement* effectLib = root->add("library_effects", 0);
        CheckResult(effectLib && root->getChildren()[0] == effectLib);
        root->addBefore(geomLib, effectLib);
        CheckResult(root->getChildren()[0] == geomLib);
        CheckResult(root->removeChildElement(geomLib));
        root->addAfter(geomLib, effectLib);
        CheckResult(root->getChildren()[1] == geomLib);
        CheckResult(root->removeChildElement(geomLib));
        root->add(geomLib);
        CheckResult(root->getDescendant("library_geometries"));
        daeElement* instanceGeom = root->add("library_nodes node instance_geometry");
        CheckResult(instanceGeom && instanceGeom->typeID() == domInstance_geometry::ID());
        CheckResult(root->add("library_materials material blah") == NULL);
        CheckResult(root->getDescendant("library_materials") == NULL);

        // Test the deprecated functions
        dae.close(uri);
        root = dae.add(uri);
        CheckResult(root);
        geomLib = root->createAndPlace("library_geometries");
        CheckResult(geomLib);
        effectLib = root->createAndPlaceAt(0, "library_effects");
        CheckResult(effectLib && root->getChildren()[0] == effectLib);
        root->placeElementBefore(effectLib, geomLib);
        CheckResult(root->getChildren()[0] == geomLib);
        CheckResult(root->removeChildElement(geomLib));
        root->placeElementAfter(effectLib, geomLib);
        CheckResult(root->getChildren()[1] == geomLib);
        CheckResult(root->removeChildElement(geomLib));
        root->placeElement(geomLib);
        CheckResult(root->getDescendant("library_geometries"));

        return testResult(true);
}


DefineTest(loadClipPlane) {
        DAE dae;
        CheckResult(dae.open(lookupTestFile("clipPlane.dae")));
        return testResult(true);
}


DefineTest(renderStates) {
        string memoryUri = "renderStates_create.dae";
        string file = getTmpFile("renderStates.dae");

        DAE dae;
        daeElement* root = dae.add(memoryUri);
        CheckResult(root);
        daeElement* pass = root->add("library_effects effect profile_CG technique pass");
        CheckResult(pass);

        domCg_pass::domEvaluate* evaluate = daeSafeCast<domCg_pass::domEvaluate>(pass->add("evaluate"));
        evaluate->add("color_clear")->setCharData("0 0 0 0");

        domCg_pass::domStates* states = daeSafeCast<domCg_pass::domStates>(pass->add("states"));
        states->add("depth_mask")->setAttribute("value", "true");
        states->add("cull_face_enable")->setAttribute("value", "true");
        states->add("blend_enable")->setAttribute("value", "true");
        states->add("blend_func_separate")->setAttribute("value", "true");
        states->add("cull_face")->setAttribute("value", "FRONT");
        states->add("polygon_offset_fill_enable")->setAttribute("value", "true");

        // Write the document to disk
        CheckResult(dae.writeTo(memoryUri, file));

        // Load up the saved document and see if it's the same as our in-memory document
        root = dae.open(file);
        CheckResult(root);
        CompareDocs(dae, memoryUri, file);

        // Check default attribute value suppression
        CheckResult(root->getDescendant("depth_mask")->isAttributeSet("value") == false);
        CheckResult(root->getDescendant("color_clear")->getCharData() != "");
        CheckResult(root->getDescendant("polygon_offset_fill_enable")->isAttributeSet("value"));

        return testResult(true);
}


DefineTest(compareElements) {
        string memoryUri = "file.dae";

        DAE dae;
        daeElement* root = dae.add(memoryUri);
        CheckResult(root);

        daeElement* technique = root->add("extra technique");
        CheckResult(technique);

        // Make sure attribute order doesn't matter
        daeElement* elt1 = technique->add("elt");
        daeElement* elt2 = technique->add("elt");
        CheckResult(elt1 && elt2);

        elt1->setAttribute("attr1", "val1");
        elt1->setAttribute("attr2", "val2");
        elt2->setAttribute("attr2", "val2");
        elt2->setAttribute("attr1", "val1");

        CheckResult(daeElement::compare(*elt1, *elt2) == 0);

        // Make sure that element comparison fails when appropriate
        elt2->setAttribute("attr3", "val3");
        CheckResult(daeElement::compare(*elt1, *elt2) < 0);

        return testResult(true);
}


DefineTest(writeCamera) {
        string memoryUri = "camera_create.dae";
        string file = getTmpFile("camera.dae");

        DAE dae;
        daeElement* elt = dae.add(memoryUri);
        CheckResult(elt);
        elt = elt->add("library_cameras camera optics technique_common perspective xfov");
        CheckResult(elt);
        elt->setCharData("1.0");

        CheckResult(dae.writeTo(memoryUri, file));
        domCOLLADA* root = dae.open(file);
        CheckResult(root);
        CompareDocs(dae, memoryUri, file);
        CheckResult(toFloat(root->getDescendant("xfov")->getCharData()) == 1.0f);

        return testResult(true);
}


string getRoundTripFile(const string& name) {
        return getTmpFile(fs::basename(fs::path(name)) + "_roundTrip.dae");
}

bool roundTrip(const string& file) {
        DAE dae;
        if (!dae.open(file))
                return false;
        return dae.writeTo(file, getRoundTripFile(file));
}

DefineTest(roundTripSeymour) {
        string file1 = lookupTestFile("Seymour.dae"),
                   file2 = getRoundTripFile(file1);
        DAE dae;
        CheckResult(dae.open(file1));
        CheckResult(dae.writeTo(file1, file2));
        CheckResult(dae.open(file2));
        CompareDocs(dae, file1, file2);
        return testResult(true);
}


DefineTest(rawSupport) {
        string seymourOrig = lookupTestFile("Seymour.dae"),
                   seymourRaw  = getTmpFile("Seymour_raw.dae");
        DAE dae;

        CheckResult(dae.open(seymourOrig));
        dae.getIOPlugin()->setOption("saveRawBinary", "true");
        CheckResult(dae.writeTo(seymourOrig, seymourRaw));
        dae.clear();

        // Make sure the .raw file is there
        CheckResult(fs::exists(fs::path(seymourRaw + ".raw")));

        daeElement* seymourRawRoot = dae.open(seymourRaw);
        CheckResult(seymourRawRoot);
        CheckResult(dae.getDatabase()->idLookup("l_hip_rotateY_l_hip_rotateY_ANGLE-input",
                                seymourRawRoot->getDocument()));
        domAccessor* accessor = dae.getDatabase()->typeLookup<domAccessor>().at(0);
        daeURI& uri = accessor->getSource();
        CheckResult(uri.pathExt().find(".raw") != string::npos);
        CheckResult(uri.getElement());

        return testResult(true);
}

DefineTest(extraTypeTest) {
        DAE dae;
        string file = lookupTestFile("extraTest.dae");
        daeElement* root = dae.open(file);
        CheckResult(root);

        daeElement *technique = root->getDescendant("technique"),
                           *expectedTypesElt = root->getDescendant("expected_types");
        CheckResult(technique && expectedTypesElt);

        // read expected type names from <expected_types> element
        istringstream expectedTypesStream(expectedTypesElt->getCharData());
        vector<string> expectedTypes;
        string tmp;
        while (expectedTypesStream >> tmp)
                expectedTypes.push_back(tmp);

        daeElementRefArray elements = technique->getChildren();

        // compare expected types with direct children of technique
        CheckResult(expectedTypes.size() == elements.getCount()-1);
        for (size_t i = 0; i < elements.getCount()-1; i++) {
                ostringstream msg;
                msg << "Actual type - " << elements[i]->getTypeName() << ", Expected type - " << expectedTypes[i];
                CheckResultWithMsg(expectedTypes[i] == elements[i]->getTypeName(), msg.str());
        }

        return testResult(true);
}

#if defined(TINYXML)
#include <dae/daeTinyXMLPlugin.h>
DefineTest(tinyXmlLoad) {
        string seymourOrig = lookupTestFile("Seymour.dae"),
                   seymourTinyXml = getTmpFile("Seymour_tinyXml.dae");

        // Plan: Load Seymour with libxml, then save with TinyXml and immediately reload the
        // saved document, and make sure the results are the same.
        DAE dae;
        CheckResult(dae.open(seymourOrig));
        auto_ptr<daeTinyXMLPlugin> tinyXmlPlugin(new daeTinyXMLPlugin);
        dae.setIOPlugin(tinyXmlPlugin.get());
        CheckResult(dae.writeTo(seymourOrig, seymourTinyXml));
        CheckResult(dae.open(seymourTinyXml));
        CompareDocs(dae, seymourOrig, seymourTinyXml);

        return testResult(true);
}
#endif


string resolveResultToString(const string& sidRef, daeElement* refElt) {
        daeSidRef::resolveData rd = daeSidRef(sidRef, refElt).resolve();
        if (rd.scalar) return "scalar";
        else if (rd.array) return "array";
        else if (rd.elt) return "element";
        else return "failed";
}

DefineTest(sidResolve) {
        DAE dae;
        daeElement* root = dae.open(lookupTestFile("sidResolveTest.dae"));
        CheckResult(root);
        daeDatabase& database = *dae.getDatabase();
        daeDocument* doc = root->getDocument();

        daeElement *effect = database.idLookup("myEffect", doc),
                           *effectExtra = database.idLookup("effectExtra", doc);
        CheckResult(effect && effectExtra);

        istringstream stream(effectExtra->getCharData());
        string sidRef, expectedResult;
        while (stream >> sidRef >> expectedResult) {
                string result = resolveResultToString(sidRef, effect);
                CheckResultWithMsg(result == expectedResult,
                                string("sid ref=") + sidRef + ", expectedResult=" + expectedResult + ", actualResult=" + result);
        }

        daeElement* nodeSidRefExtra = database.idLookup("nodeSidRefExtra", doc);
        CheckResult(nodeSidRefExtra);

        stream.clear();
        stream.str(nodeSidRefExtra->getCharData());
        while (stream >> sidRef >> expectedResult) {
                string result = resolveResultToString(sidRef, root);
                CheckResultWithMsg(result == expectedResult,
                                string("sid ref=") + sidRef + ", expectedResult=" + expectedResult + ", actualResult=" + result);
        }

        nodeSidRefExtra = database.idLookup("nodeSidRefExtra2", doc);
        CheckResult(nodeSidRefExtra);

        stream.clear();
        stream.str(nodeSidRefExtra->getCharData());
        while (stream >> sidRef >> expectedResult) {
                daeElement* elt = daeSidRef(sidRef, root).resolve().elt;
                string result = elt ? elt->getAttribute("id") : "failed";
                CheckResultWithMsg(result == expectedResult,
                                string("sid ref=") + sidRef + ", expectedResult=" + expectedResult + ", actualResult=" + result);
        }

        nodeSidRefExtra = database.idLookup("nodeSidRefExtra3", doc);
        CheckResult(nodeSidRefExtra);

        stream.clear();
        stream.str(nodeSidRefExtra->getCharData());
        string profile;
        while (stream >> sidRef >> profile >> expectedResult) {
                daeElement* elt = daeSidRef(sidRef, root, profile).resolve().elt;
                string result = elt ? elt->getAttribute("id") : "failed";
                CheckResultWithMsg(result == expectedResult,
                                string("sid ref=") + sidRef + ", profile=" + profile +
                                ", expectedResult=" + expectedResult + ", actualResult=" + result);
        }


        return testResult(true);
}

        daeElement* findChildByName(daeElement* el, daeString name) {
                if (!el)
                        return 0;

                daeElementRefArray children = el->getChildren();
                for (size_t i = 0; i < children.getCount(); i++)
                        if (strcmp(children[i]->getElementName(), name) == 0)
                                return children[i];

                return 0;
        }

        daeElement* findAncestorByType(daeElement* el, daeString type) {
                if (el == 0  ||  strcmp(el->getTypeName(), type) == 0)
                        return el;
                return findAncestorByType(el->getParentElement(), type);
        }

daeElement* resolveID(daeString id, daeDocument& document) {
        return document.getDatabase()->idLookup(id, &document);
}

daeElement* resolveSid(const string& sid, daeElement& refElt) {
        return daeSidRef(sid, &refElt).resolve().elt;
}

string getCharData(daeElement* el) {
        return el ? el->getCharData() : "";
}

daeURI* getTextureUri(const string& samplerSid, daeElement& effect) {
        daeElement* sampler = findChildByName(resolveSid(samplerSid, effect), "sampler2D");
        daeElement* instanceImage = findChildByName(sampler, "instance_image");
        xsAnyURI imageUrl = daeSafeCast<domInstance_image>(instanceImage)->getUrl();
        domImage* image = daeSafeCast<domImage>(imageUrl.getElement());
        if (image && image->getInit_from() && image->getInit_from()->getRef())
                return &image->getInit_from()->getRef()->getValue();
        return 0;
}

DefineTest(getTexture) {
        DAE dae;
        CheckResult(dae.open(lookupTestFile("Seymour.dae")));

        daeElement* effect = dae.getDatabase()->idLookup("face-fx").at(0);
        daeElement* texture = effect->getDescendant("texture");
        CheckResult(texture);

        daeURI* uri = getTextureUri(texture->getAttribute("texture"), *effect);
        CheckResult(uri);
        CheckResult(uri->pathFile() == "boy_10.tga");

        return testResult(true);
}


DefineTest(removeElement) {
        DAE dae;
        daeElement* collada = dae.open(lookupTestFile("Seymour.dae"));
        CheckResult(collada);

        daeElement *animLib = dae.getDatabase()->typeLookup(domLibrary_animations::ID()).at(0),
                           *asset = dae.getDatabase()->typeLookup(domAsset::ID()).at(0);

        collada->removeChildElement(asset);
        daeElement::removeFromParent(animLib);

        CheckResult(collada->getDescendant("asset") == NULL);
        CheckResult(collada->getDescendant("library_animations") == NULL);

        CheckResult(dae.writeTo(lookupTestFile("Seymour.dae"),
                                getTmpFile("Seymour_removeElements.dae")));
        return testResult(true);
}

void nameArraySet(domList_of_names& names, size_t index, const char* name) {
        *(daeStringRef*)&names[index] = name;
}

void nameArrayAppend(domList_of_names& names, const char* name) {
        names.append(NULL);
        nameArraySet(names, names.getCount()-1, name);
}

DefineTest(nameArray) {
        domList_of_names names;
        for (int i = 0; i < 10; i++)
                nameArrayAppend(names, (string("name") + toString(i)).c_str());
        for (int i = 0; i < 10; i++) {
                CheckResult(string("name") + toString(i) == string(names[i]));
        }

        return testResult(true);
}

daeTArray<int> makeIntArray(int i, ...) {
        va_list args;
        va_start(args, i);
        daeTArray<int> result;
        while (i != INT_MAX) {
                result.append(i);
                i = va_arg(args, int);
        }
        va_end(args);
        return result;
}

DefineTest(arrayOps) {
        daeTArray<int> zeroToFour = makeIntArray(0, 1, 2, 3, 4, INT_MAX);

        // Test removeIndex
        daeTArray<int> array = zeroToFour;
        array.removeIndex(2);
        CheckResult(array == makeIntArray(0, 1, 3, 4, INT_MAX));

        // Insert several values into the middle of an array
        array = zeroToFour;
        array.insert(3, 5, 9); // Insert five copies of '9' at the third element of the array
        CheckResult(array == makeIntArray(0, 1, 2, 9, 9, 9, 9, 9, 3, 4, INT_MAX));

        // Insert several values beyond the end of an array
        array = zeroToFour;
        array.insert(7, 2, 5);
        CheckResult(array == makeIntArray(0, 1, 2, 3, 4, 5, 5, 5, 5, INT_MAX));

        return testResult(true);
}


void printMemoryToStringResult(daeAtomicType& type, daeMemoryRef value) {
        ostringstream buffer;
        type.memoryToString(value, buffer);
        cout << buffer.str() << endl;
}

string toString(daeAtomicType& type, daeMemoryRef value) {
        ostringstream buffer;
        type.memoryToString(value, buffer);
        return buffer.str();
}

DefineTest(atomicTypeOps) {
        DAE dae;
        daeUIntType UIntType(dae);
        daeIntType IntType(dae);
        daeLongType LongType(dae);
        daeShortType ShortType(dae);
        daeULongType ULongType(dae);
        daeFloatType FloatType(dae);
        daeDoubleType DoubleType(dae);
        daeStringRefType StringRefType(dae);
        daeElementRefType ElementRefType(dae);
        daeEnumType EnumType(dae);
        daeResolverType ResolverType(dae);
        daeIDResolverType IDResolverType(dae);
        daeBoolType BoolType(dae);
        daeTokenType TokenType(dae);

        EnumType._values = new daeEnumArray;
        EnumType._strings = new daeStringRefArray;
        EnumType._values->append(0);
        EnumType._strings->append("myEnumValue");

        daeUInt UInt(1);
        daeInt Int(2);
        daeLong Long(3);
        daeShort Short(4);
        daeULong ULong(5);
        daeFloat Float(6.123f);
        daeDouble Double(7.456);
        daeStringRef StringRef("StringRef");
        //      daeElementRef ElementRef(0x12345678);
        daeEnum Enum(0);
        daeURI uri(dae, "http://www.example.com/#fragment");
        daeIDRef IDRef("sampleID");
        daeBool Bool(false);
        daeStringRef Token("token");


        CheckResult(toString(UIntType, (daeMemoryRef)&UInt) == "1");
        CheckResult(toString(IntType, (daeMemoryRef)&Int) == "2");
        CheckResult(toString(LongType, (daeMemoryRef)&Long) == "3");
        CheckResult(toString(ShortType, (daeMemoryRef)&Short) == "4");
        CheckResult(toString(ULongType, (daeMemoryRef)&ULong) == "5");
        CheckResult(toString(FloatType, (daeMemoryRef)&Float) == "6.123");
        CheckResult(toString(DoubleType, (daeMemoryRef)&Double) == "7.456");
        CheckResult(toString(StringRefType, (daeMemoryRef)&StringRef) == "StringRef");
        //      CheckResult(toString(ElementRefType, (daeMemoryRef)&ElementRef) == "");
        CheckResult(toString(EnumType, (daeMemoryRef)&Enum) == "myEnumValue");
        CheckResult(toString(ResolverType, (daeMemoryRef)&uri) == "http://www.example.com/#fragment");
        CheckResult(toString(IDResolverType, (daeMemoryRef)&IDRef) == "sampleID");
        CheckResult(toString(BoolType, (daeMemoryRef)&Bool) == "false");
        CheckResult(toString(TokenType, (daeMemoryRef)&Token) == "token");

        return testResult(true);
}


DefineTest(clone) {
        DAE dae;
        CheckResult(dae.open(lookupTestFile("Seymour.dae")));

        daeElement* el = dae.getDatabase()->idLookup("l_ulna").at(0);
        daeElementRef clone = el->clone("-foo", "-bar");
        el->getParentElement()->placeElement(clone);

        CheckResult(dae.writeTo(lookupTestFile("Seymour.dae"), getTmpFile("cloneTest.dae")));

        return testResult(true);
}


DefineTest(genericOps) {
        string file = lookupTestFile("cube.dae");
        DAE dae;
        CheckResult(dae.open(file));
        daeDatabase& database = *dae.getDatabase();

        // Attribute getter/setter tests
        daeElement* el = database.idLookup("box-lib-positions-array").at(0);

        CheckResult(el->hasAttribute("digits"));
        CheckResult(el->getAttribute("count") == "24");
        CheckResult(el->setAttribute("blah", "hey") == false);
        CheckResult(el->setAttribute("magnitude", "30"));

        el = database.idLookup("Blue-fx").at(0);
        CheckResult(el->hasAttribute("name"));
        CheckResult(el->isAttributeSet("name") == false);
        CheckResult(el->isAttributeSet("hello") == false);

        // Character data getter/setter tests
        el = database.typeLookup(domAsset::domUp_axis::ID()).at(0);

        CheckResult(el->getCharData() == "Y_UP");
        el->setCharData("X_UP");

        el = database.idLookup("PerspCamera").at(0);
        CheckResult(!el->hasCharData());

        // <extra> tests using daeElement interface
        el = database.idLookup("my_test_element").at(0);
        daeElementRef clone = el->clone("-clone", "-clone");

        CheckResult(el->getAttribute("attr1") == "value1" &&
                        el->getAttribute("attr2") == "value2");
        CheckResult(el->setAttribute("attr1", "value_1"));
        CheckResult(el->setAttribute("attr3", "value3"));

        CheckResult(chopWS(el->getCharData()) == "this is some text");
        el->setCharData("reset text");

        // <extra> tests using domAny interface
        el->getParentElement()->placeElementAfter(el, clone);
        domAny* any = (domAny*)clone.cast();
        CheckResult(any);
        CheckResult(any->getAttributeCount() == 3);
        CheckResult(string(any->getAttributeName(0)) == "id");
        CheckResult(string(any->getAttributeValue(1)) == "value1");
        CheckResult(chopWS(any->getValue()) == "this is some text");
        any->setValue("reset text 2");

        // Test for lots of attributes
        for (size_t i = 0; i < 50; i++) {
                ostringstream name, value;
                name << "attr" << static_cast<unsigned int>(i);
                value << "value" << static_cast<unsigned int>(i);
                any->setAttribute(name.str().c_str(), value.str().c_str());
        }

        CheckResult(dae.writeTo(file, getTmpFile(fs::basename(fs::path(file)) + "_genericOps.dae")));

        return testResult(true);
}


        daeArray* getSkewArray(daeElement* node, const string& sid) {
                if (!node)
                        return NULL;

                daeElement* skew = resolveSid(sid, *node);
                if (!skew || skew->getElementType() != COLLADA_TYPE::SKEW)
                        return NULL;

                return (daeArray*)skew->getCharDataObject()->get(skew);
        }

DefineTest(badSkew) {
        DAE dae;
        CheckResult(dae.open(lookupTestFile("badSkew.dae")));

        daeElement* node = dae.getDatabase()->idLookup("my-node").at(0);

        daeArray* array1 = getSkewArray(node, "tooFew");
        daeArray* array2 = getSkewArray(node, "justRight");
        daeArray* array3 = getSkewArray(node, "tooMany");
        CheckResult(array1 && array2 && array3);

        CheckResult(array1->getCount() == 4);
        CheckResult(array2->getCount() == 7);
        CheckResult(array3->getCount() == 11);

        return testResult(true);
}


DefineTest(stringTable) {
        daeStringTable stringTable;
        stringTable.allocString("hello");
        // These next two lines used to cause an abort
        stringTable.clear(); 
        stringTable.allocString("goodbye");
        return testResult(true);
}


// We can only do this test if we have breps
#if 0
DefineTest(sidResolveSpeed) {
        DAE dae;
        string file = lookupTestFile("crankarm.dae");
        domCOLLADA* root = dae.open(file);
        CheckResult(root);

        vector<domSIDREF_array*> sidRefArrays = dae.getDatabase()->typeLookup<domSIDREF_array>();
        for (size_t i = 0; i < sidRefArrays.size(); i++) {
                domListOfNames& sidRefs = sidRefArrays[i]->getValue();
                for (size_t j = 0; j < sidRefs.getCount(); j++) {
                        CheckResult(resolveSid(sidRefs[i], root));
                }
        }

        return testResult(true);
}
#endif


DefineTest(seymourSidResolve) {
        DAE dae;
        string file = lookupTestFile("Seymour.dae");
        CheckResult(dae.open(file));

        vector<daeElement*> nodes = dae.getDatabase()->typeLookup(domNode::ID());
        for (size_t i = 0; i < nodes.size(); i++) {
                daeElementRefArray children = nodes[i]->getChildren();
                for (size_t j = 0; j < children.getCount(); j++) {
                        string sid = children[j]->getAttribute("sid");
                        if (!sid.empty()) {
                                CheckResult(daeSidRef(sid, nodes[i]).resolve().elt);
                        }
                }
        }

        return testResult(true);
}


vector<string> getChildNames(daeElement* elt) {
        vector<string> result;
        if (!elt)
                return result;

        daeElementRefArray children = elt->getChildren();
        for (size_t i = 0; i < children.getCount(); i++)
                result.push_back(children[i]->getElementName());

        return result;
}

DefineTest(placeElement) {
        DAE dae;
        CheckResult(dae.open(lookupTestFile("cube.dae")));

        daeElement* node = dae.getDatabase()->idLookup("Box").at(0);

        CheckResult(getChildNames(node) == makeStringArray(
                                "rotate", "rotate", "rotate", "instance_geometry", 0));

        // Place a new <translate> after the first <rotate> using placeElementAfter, and
        // make sure the <translate> shows up in the right spot.
        node->placeElementAfter(node->getChildren()[0], node->createElement("translate"));
        CheckResult(getChildNames(node) == makeStringArray(
                                "rotate", "translate", "rotate", "rotate", "instance_geometry", 0));

        node->placeElementBefore(node->getChildren()[0], node->createElement("scale"));
        CheckResult(getChildNames(node) == makeStringArray(
                                "scale", "rotate", "translate", "rotate", "rotate", "instance_geometry", 0));

        return testResult(true);
};


DefineTest(nativePathConversion) {
        // Windows file path to URI
        CheckResult(cdom::nativePathToUri("C:\\myFolder\\myFile.dae", cdom::Windows) == "/C:/myFolder/myFile.dae");
        CheckResult(cdom::nativePathToUri("\\myFolder\\myFile.dae", cdom::Windows) == "/myFolder/myFile.dae");
        CheckResult(cdom::nativePathToUri("..\\myFolder\\myFile.dae", cdom::Windows) == "../myFolder/myFile.dae");
        CheckResult(cdom::nativePathToUri("\\\\otherComputer\\myFile.dae", cdom::Windows) == "//otherComputer/myFile.dae");

        // Linux/Mac file path to URI
        CheckResult(cdom::nativePathToUri("/myFolder/myFile.dae", cdom::Posix) == "/myFolder/myFile.dae");
        CheckResult(cdom::nativePathToUri("../myFolder/myFile.dae", cdom::Posix) == "../myFolder/myFile.dae");
        CheckResult(cdom::nativePathToUri("/my folder/my file.dae", cdom::Posix) == "/my%20folder/my%20file.dae");

        // URI to Windows file path
        CheckResult(cdom::uriToNativePath("../folder/file.dae", cdom::Windows) == "..\\folder\\file.dae");
        CheckResult(cdom::uriToNativePath("/C:/folder/file.dae", cdom::Windows) == "C:\\folder\\file.dae");
        CheckResult(cdom::uriToNativePath("file:///C:/folder/file.dae", cdom::Windows) == "C:\\folder\\file.dae");
        CheckResult(cdom::uriToNativePath("//otherComputer/file.dae", cdom::Windows) == "\\\\otherComputer\\file.dae");
        CheckResult(cdom::uriToNativePath("file://///otherComputer/file.dae", cdom::Windows) == "\\\\otherComputer\\file.dae");
        CheckResult(cdom::uriToNativePath("http://www.slashdot.org", cdom::Windows) == "");

        // URI to Linux/Mac file path
        CheckResult(cdom::uriToNativePath("../folder/file.dae", cdom::Posix) == "../folder/file.dae");
        CheckResult(cdom::uriToNativePath("/folder/file.dae", cdom::Posix) == "/folder/file.dae");
        CheckResult(cdom::uriToNativePath("file:///folder/file.dae", cdom::Posix) == "/folder/file.dae");
        CheckResult(cdom::uriToNativePath("http://www.slashdot.org", cdom::Posix) == "");

        return testResult(true);
}


DefineTest(libxmlUriBugWorkaround) {
        if (cdom::getSystemType() == cdom::Posix) {
                // libxml doesn't like file scheme uris that don't have an authority component
                CheckResult(cdom::fixUriForLibxml("file:/folder/file.dae") == "file:///folder/file.dae");
        }
        else if (cdom::getSystemType() == cdom::Windows) {
                // libxml doesn't like file scheme uris that don't have an authority component
                CheckResult(cdom::fixUriForLibxml("file:/c:/folder/file.dae") == "file:///c:/folder/file.dae");
                // libxml wants UNC paths that contain an empty authority followed by three slashes
                CheckResult(cdom::fixUriForLibxml("file://otherComputer/file.dae") == "file://///otherComputer/file.dae");
                // libxml wants absolute paths that don't contain a drive letter to have an
                // empty authority followed by two slashes.
                CheckResult(cdom::fixUriForLibxml("file:/folder/file.dae") == "file:////folder/file.dae");
        }

        return testResult(true);
}


// !!!steveT I want this to be a test of the DOM's ability to open files
// using all the various ways of referencing files: relative paths, absolute
// paths, absolute paths with no drive letter (Windows), UNC paths (Windows),
// http scheme URIs, zipped files, etc.
#if 0
DefineTest(uriOpen) {
        DAE dae;
        CheckResult(dae.open("file:/c:/models/cube.dae"));
        CheckResult(dae.open("/c:/models/cube.dae"));
        CheckResult(dae.open("/models/cube.dae"));
        CheckResult(dae.open("file:////models/cube.dae"));
        CheckResult(dae.open("file://isis/sceard/COLLADA/forsteve/cube.dae"));
        CheckResult(dae.open("file://///isis/sceard/COLLADA/forsteve/cube.dae"));
        return testResult(true);
}
#endif


DefineTest(uriOps) {
        DAE dae;

        // Check construction of absolute uris
        CheckResult(daeURI(dae, "file:///home/sthomas/file.txt").str() == "file:/home/sthomas/file.txt");
        CheckResult(daeURI(dae, "http://www.example.com/path").str() == "http://www.example.com/path");
        CheckResult(daeURI(dae, "file:home/sthomas/file.txt").str() == "file:home/sthomas/file.txt");
        CheckResult(daeURI(dae, "file:file.txt#fragment", true).str() == "file:file.txt");

        // Check construction of relative uri references
        {
                daeURI base(dae, "file:/home/sthomas/file.txt?baseQuery#baseFragment");
                CheckResult(base.str() == "file:/home/sthomas/file.txt?baseQuery#baseFragment");
                CheckResult(daeURI(base, "file:/home/sthomas").str() == "file:/home/sthomas");
                CheckResult(daeURI(base, "//authority").str() == "file://authority");
                CheckResult(daeURI(base, "//authority/path").str() == "file://authority/path");
                CheckResult(daeURI(base, "/home/johnny").str() == "file:/home/johnny");
                CheckResult(daeURI(base, "myFile.txt").str() == "file:/home/sthomas/myFile.txt");
                CheckResult(daeURI(base, "?query#fragment").str() == "file:/home/sthomas/file.txt?query#fragment");
                CheckResult(daeURI(base, "?query").str() == "file:/home/sthomas/file.txt?query");
                CheckResult(daeURI(base, "").str() == "file:/home/sthomas/file.txt?baseQuery");
                CheckResult(daeURI(daeURI(dae, "http://www.example.com/path"), "myFolder/file.txt").str() == "http://www.example.com/myFolder/file.txt");
                CheckResult(daeURI(daeURI(dae, "http://www.example.com/path/"), "myFolder/file.txt").str() == "http://www.example.com/path/myFolder/file.txt");
                CheckResult(daeURI(daeURI(dae, "http://www.example.com"), "myFolder/file.txt").str() == "http://www.example.com/myFolder/file.txt");
        }

        // More reference resolution tests. These are taken from http://tools.ietf.org/html/rfc3986#section-5.4
        {
                daeURI base(dae, "http://a/b/c/d;p?q");

                CheckResult(daeURI(base, "g:h").str() == "g:h");
                CheckResult(daeURI(base, "g").str() == "http://a/b/c/g");
                CheckResult(daeURI(base, "./g").str() == "http://a/b/c/g");
                CheckResult(daeURI(base, "g/").str() == "http://a/b/c/g/");
                CheckResult(daeURI(base, "/g").str() == "http://a/g");
                CheckResult(daeURI(base, "//g").str() == "http://g");
                CheckResult(daeURI(base, "?y").str() == "http://a/b/c/d;p?y");
                CheckResult(daeURI(base, "g?y").str() == "http://a/b/c/g?y");
                CheckResult(daeURI(base, "#s").str() == "http://a/b/c/d;p?q#s");
                CheckResult(daeURI(base, "g#s").str() == "http://a/b/c/g#s");
                CheckResult(daeURI(base, "g?y#s").str() == "http://a/b/c/g?y#s");
                CheckResult(daeURI(base, ";x").str() == "http://a/b/c/;x");
                CheckResult(daeURI(base, "g;x").str() == "http://a/b/c/g;x");
                CheckResult(daeURI(base, "g;x?y#s").str() == "http://a/b/c/g;x?y#s");
                CheckResult(daeURI(base, "").str() == "http://a/b/c/d;p?q");
                CheckResult(daeURI(base, ".").str() == "http://a/b/c/");
                CheckResult(daeURI(base, "./").str() == "http://a/b/c/");
                CheckResult(daeURI(base, "..").str() == "http://a/b/");
                CheckResult(daeURI(base, "../").str() == "http://a/b/");
                CheckResult(daeURI(base, "../g").str() == "http://a/b/g");
                CheckResult(daeURI(base, "../..").str() == "http://a/");
                CheckResult(daeURI(base, "../../").str() == "http://a/");
                CheckResult(daeURI(base, "../../g").str() == "http://a/g");

                CheckResult(daeURI(base, "../../../g").str() == "http://a/g");
                CheckResult(daeURI(base, "../../../../g").str() == "http://a/g");
                CheckResult(daeURI(base, "/./g").str() == "http://a/g");
                CheckResult(daeURI(base, "/../g").str() == "http://a/g");
                CheckResult(daeURI(base, "g.").str() == "http://a/b/c/g.");
                CheckResult(daeURI(base, ".g").str() == "http://a/b/c/.g");
                CheckResult(daeURI(base, "g..").str() == "http://a/b/c/g..");
                CheckResult(daeURI(base, "..g").str() == "http://a/b/c/..g");

                CheckResult(daeURI(base, "./../g").str() == "http://a/b/g");
                CheckResult(daeURI(base, "./g/.").str() == "http://a/b/c/g/");
                CheckResult(daeURI(base, "g/./h").str() == "http://a/b/c/g/h");
                CheckResult(daeURI(base, "g/../h").str() == "http://a/b/c/h");
                CheckResult(daeURI(base, "g;x=1/./y").str() == "http://a/b/c/g;x=1/y");
                CheckResult(daeURI(base, "g;x=1/../y").str() == "http://a/b/c/y");


                CheckResult(daeURI(base, "g?y/./x").str() == "http://a/b/c/g?y/./x");
                CheckResult(daeURI(base, "g?y/../x").str() == "http://a/b/c/g?y/../x");
                CheckResult(daeURI(base, "g#s/./x").str() == "http://a/b/c/g#s/./x");
                CheckResult(daeURI(base, "g#s/../x").str() == "http://a/b/c/g#s/../x");

                CheckResult(daeURI(base, "http:g").str() == "http:g");
        }

        // Check originalStr
        CheckResult(daeURI(dae, "relPath/file.txt").originalStr() == "relPath/file.txt");

        // Check main setters
        {
                daeURI uri(dae);
                uri.set("file:/path/file.txt");
                CheckResult(uri.str() == "file:/path/file.txt");
                uri.set("http", "www.example.com", "/path", "q", "f");
                CheckResult(uri.str() == "http://www.example.com/path?q#f");
        }

        // Check component accessors
        CheckResult(daeURI(dae, "file:/home/sthomas/file.txt").scheme() == "file");
        CheckResult(daeURI(dae, "http://www.example.com").authority() == "www.example.com");
        CheckResult(daeURI(dae, "file:/home/sthomas/file.txt").path() == "/home/sthomas/file.txt");
        CheckResult(daeURI(dae, "file:/home/sthomas/file.txt?query").query() == "query");
        CheckResult(daeURI(dae, "file:/home/sthomas/file.txt?query#fragment").fragment() == "fragment");
        CheckResult(daeURI(dae, "file:/home/sthomas/file.txt?query#fragment").id() == "fragment");

        // Check component setters
        {
                daeURI uri(dae);
                uri.scheme("file");
                uri.authority("myAuth");
                uri.path("/home/sthomas/file.txt");
                uri.query("q");
                uri.fragment("f");
                CheckResult(uri.str() == "file://myAuth/home/sthomas/file.txt?q#f");
                uri.id("id");
                CheckResult(uri.str() == "file://myAuth/home/sthomas/file.txt?q#id");
        }

        // Check path component accessors
        {
                daeURI uri(dae, "file:/home/sthomas/file.txt");
                CheckResult(uri.str() == "file:/home/sthomas/file.txt");
                string dir, base, ext;
                uri.pathComponents(dir, base, ext);
                CheckResult(dir == "/home/sthomas/");
                CheckResult(base == "file");
                CheckResult(ext == ".txt");
                CheckResult(uri.pathDir() == "/home/sthomas/");
                CheckResult(uri.pathFileBase() == "file");
                CheckResult(uri.pathExt() == ".txt");
                CheckResult(uri.pathFile() == "file.txt");
        }

        // Check path component setters
        {
                daeURI uri(dae, "file:");
                CheckResult(uri.str() == "file:");
                uri.path("/home/sthomas/", "file", ".txt");
                CheckResult(uri.str() == "file:/home/sthomas/file.txt");
                uri.pathDir("/home/johnny"); // A / should automatically be added to the end for us
                uri.pathFileBase("otherFile");
                uri.pathExt(".dae");
                CheckResult(uri.str() == "file:/home/johnny/otherFile.dae");
                uri.pathFile("file.txt");
                CheckResult(uri.str() == "file:/home/johnny/file.txt");
        }

        // Check path normalization
        CheckResult(daeURI(dae, "file:/d1/d2/d3/../../d4/./file.txt").str() == "file:/d1/d4/file.txt");

        // Check old C string methods
        CheckResult(strcmp(daeURI(dae, "file:/dir/file.txt").getURI(), "file:/dir/file.txt") == 0);
        CheckResult(strcmp(daeURI(dae, "dir/file.txt").getOriginalURI(), "dir/file.txt") == 0);
        {
                daeURI uri(dae), base(dae);
                base.setURI("http://www.example.com");
                uri.setURI("dir/file.txt", &base);
                CheckResult(uri.str() == "http://www.example.com/dir/file.txt");
                uri.setURI("http://www.example.com/dir/file.txt?q#f");
                CheckResult(strcmp(uri.getScheme(), "http") == 0);
                CheckResult(strcmp(uri.getProtocol(), "http") == 0);
                CheckResult(strcmp(uri.getAuthority(), "www.example.com") == 0);
                CheckResult(strcmp(uri.getPath(), "/dir/file.txt") == 0);
                CheckResult(strcmp(uri.getQuery(), "q") == 0);
                CheckResult(strcmp(uri.getFragment(), "f") == 0);
                CheckResult(strcmp(uri.getID(), "f") == 0);
                char buffer1[4], buffer2[32];
                CheckResult(!uri.getPath(buffer1, sizeof(buffer1)));
                CheckResult(uri.getPath(buffer2, sizeof(buffer2)));
                CheckResult(strcmp(buffer2, "/dir/file.txt") == 0);
        }

        // Check makeRelativeTo
        {
                daeURI base(dae, "file:/home/sthomas/");
                daeURI uri1(base, "folder1/file.dae");
                daeURI uri2(base, "folder2/file.dae");
                uri2.makeRelativeTo(&uri1);
                CheckResult(uri2.originalStr() == "../folder2/file.dae");
                CheckResult(uri2.str() == "file:/home/sthomas/folder2/file.dae");
        }

        // Make sure we can handle paths that start with '//'. Libxml uses such paths
        // to represent UNC paths and absolute paths without a drive letter on Windows.
        {
                string scheme, authority, path, query, fragment;
                cdom::parseUriRef("file:////models/cube.dae", scheme, authority, path, query, fragment);
                CheckResult(cdom::assembleUri(scheme, authority, path, query, fragment) == "file:////models/cube.dae");
        }

        return testResult(true);
}


DefineTest(uriBase) {
        DAE dae;
        daeURI uri(dae, cdom::nativePathToUri(lookupTestFile("uri.dae")));
        CheckResult(dae.open(uri.str()));
        domImage::domInit_from* initFrom = dae.getDatabase()->typeLookup<domImage::domInit_from>().at(0);
        CheckResult(initFrom->getRef()->getValue().pathDir() == uri.pathDir());
        return testResult(true);
}


DefineTest(xmlNavigation) {
        DAE dae;
        string file = lookupTestFile("cube.dae");
        domCOLLADA* root = dae.open(file);
        CheckResult(root);

        CheckResult(root->getChild("library_cameras"));
        CheckResult(root->getChild("contributor") == 0);
        CheckResult(root->getDescendant("steveT") == 0);
        daeElement* upAxis = root->getDescendant("up_axis");
        CheckResult(upAxis);
        CheckResult(upAxis->getParent());
        CheckResult(upAxis->getAncestor("asset"));
        CheckResult(upAxis->getAncestor("library_geometries") == 0);

        CheckResult(root->getChild(daeElement::matchType(domLibrary_cameras::ID())));
        CheckResult(root->getChild(daeElement::matchType(domAsset::domContributor::ID())) == 0);
        CheckResult(root->getDescendant(daeElement::matchType(-10)) == 0);
        upAxis = root->getDescendant(daeElement::matchType(domAsset::domUp_axis::ID()));
        CheckResult(upAxis);
        CheckResult(upAxis->getParent());
        CheckResult(upAxis->getAncestor(daeElement::matchType(domAsset::ID())));
        CheckResult(upAxis->getAncestor(daeElement::matchType(domLibrary_geometries::ID())) == 0);

        return testResult(true);
}


DefineTest(multipleDae) {
        // Basically we just want to make sure that having multiple DAE objects doesn't
        // crash the DOM.
        DAE dae1;
        DAE dae2;
        CheckResult(dae2.open(lookupTestFile("cube.dae")));
        CheckResult(dae1.open(lookupTestFile("duck.dae")));
        return testResult(true);
}


DefineTest(unusedTypeCheck) {
        DAE dae;

        // The following types are defined in the schema but aren't used anywhere in
        // Collada, so they should have a null meta entry:
        //   ellipsoid
        //   ellipsoid/size
        //   InputGlobal
        // Also, <any> doesn't use a single global meta, so it'll also show up in the
        // set of elements that don't have metas.
        //
        // That was the situation for 1.4.
        set<int> expectedUnusedTypes;
        expectedUnusedTypes.insert(domEllipsoid::ID());
        expectedUnusedTypes.insert(domEllipsoid::domSize::ID());
        expectedUnusedTypes.insert(domInput_global::ID());
        expectedUnusedTypes.insert(domAny::ID());

        // In 1.5 these unused elements have been introduced:
        expectedUnusedTypes.insert(domImage_source::ID());
        expectedUnusedTypes.insert(domFx_sampler::ID());
        expectedUnusedTypes.insert(domFx_rendertarget::ID());
        expectedUnusedTypes.insert(domGles2_newparam::ID());
        expectedUnusedTypes.insert(domLimits_sub::ID());
        expectedUnusedTypes.insert(domTargetable_float4::ID());
        expectedUnusedTypes.insert(domCommon_int_or_param::ID());

        // Collect the list of types that don't have a corresponding meta defined
        set<int> actualUnusedTypes;
        const daeMetaElementRefArray &metas = dae.getAllMetas();
        for (size_t i = 0; i < metas.getCount(); i++)
                if (!metas[i])
                        actualUnusedTypes.insert((int)i);

        // Make sure the set of unused types matches what we expect
        return testResult(expectedUnusedTypes == actualUnusedTypes);
}


DefineTest(domFx_common_transparent) {

        DAE dae;
        CheckResult(dae.open(lookupTestFile("cube.dae")));

        domFx_common_transparent* transparent =
                dae.getDatabase()->typeLookup<domFx_common_transparent>().at(0);

        CheckResult(transparent->getColor() != NULL);
        CheckResult(transparent->getParam() == NULL);
        CheckResult(transparent->getTexture() == NULL);
        CheckResult(transparent->getOpaque() == FX_OPAQUE_A_ONE);

        return testResult(true);
};


DefineTest(autoResolve) {
        // When you load a document, daeIDRefs, xsIDREFS, and daeURIs should resolve automatically.
        // Make sure that works properly.
        DAE dae;
        daeDatabase& database = *dae.getDatabase();
        CheckResult(dae.open(lookupTestFile("Seymour.dae")));

        {
                // Make sure the IDREF_array element had all its daeIDRef objects resolved
                xsIDREFS& idRefs = database.typeLookup<domIdref_array>().at(0)->getValue();
                for (size_t i = 0; i < idRefs.getCount(); i++) {
                        CheckResult(idRefs[i].getElement());
                }

                domInstance_controller& ic = *database.typeLookup<domInstance_controller>().at(0);
                CheckResult(ic.getUrl().getElement());

                // In COLLADA 1.5 there is no xsIDREF anymore
                //domImage::domInit_from & initFrom =
                //    *database.typeLookup<domImage::domInit_from>().at(0);
                //if (initFrom.getRef())
                //{
                //    CheckResult(initFrom.getRef()->getValue().getElement());
                //}
                //else
                //{
                //    CheckResult(false);
                //}
        }

        // When you're modifying a new document or creating a new one and you create some
        // new ID or URI refs, they should resolve automatically.
        dae.clear();
        domCOLLADA* root = dae.add("tmp.dae");
        CheckResult(root);

        // Create a <geometry> with an <IDREF_array>
        CheckResult(root->add("library_geometries geometry mesh source IDREF_array"));
        daeElement* geom = root->getDescendant("geometry");
        geom->setAttribute("id", "myGeom");
        xsIDREFS& idRefs = database.typeLookup<domIdref_array>().at(0)->getValue();
        idRefs.append(daeIDRef("myGeom"));

        // Create a <library_nodes> with a <node> that we'll instantiate via <instance_node>
        daeElement* node1 = root->add("library_nodes node");
        node1->setAttribute("id", "myNode");

        // Create a <node> with an <instance_geometry> and <instance_node> to test URIs
        daeElement* node2 = root->getDescendant("library_nodes")->add("node");
        domInstance_node& instanceNode = *daeSafeCast<domInstance_node>(node2->add("instance_node"));
        domInstance_geometry& instanceGeom = *daeSafeCast<domInstance_geometry>(
                        node2->add("instance_geometry"));
        instanceNode.setUrl("#myNode");
        instanceGeom.setUrl("#myGeom");

        // Create a <surface> with an <init_from> to test ID refs
        domImage_source::domRef* ref = daeSafeCast<domImage_source::domRef>(
                        root->add("library_images image init_from ref"));
        ref->setValue("myGeom");

        // Make sure everything resolves automatically
        CheckResult(idRefs[0].getElement() == geom);
        CheckResult(instanceGeom.getUrl().getElement() == geom);
        // In COLLADA 1.5 there is no xsIDREF anymore
        //CheckResult(ref->getValue().getElement() == geom);
        CheckResult(instanceNode.getUrl().getElement() == node1);

        return testResult(true);
}


DefineTest(baseURI) {
        DAE dae1, dae2;
        dae1.setBaseURI("http://www.example.com/");
        daeURI uri1(dae1, "myFolder/myFile.dae");
        daeURI uri2(dae2, "myFolder/myFile.dae");
        CheckResult(uri1.str() != uri2.str());
        CheckResult(uri1.str() == "http://www.example.com/myFolder/myFile.dae");
        return testResult(true);
}


DefineTest(databaseLookup) {
        DAE dae;
        CheckResult(dae.open(lookupTestFile("cube.dae")));
        daeDatabase& database = *dae.getDatabase();
        daeDocument* doc = database.getDoc(0);
        CheckResult(doc);

        // Test the new functions
        CheckResult(database.idLookup("light-lib").size() == 1);
        CheckResult(database.idLookup("light-lib", doc));
        CheckResult(database.typeLookup(domNode::ID()).size() == 5);
        vector<daeElement*> elts;
        database.typeLookup(domRotate::ID(), elts, doc);
        CheckResult(elts.size() == 15);
        CheckResult(database.typeLookup<domNode>().size() == 5);
        vector<domRotate*> rotateElts;
        database.typeLookup(rotateElts);
        CheckResult(rotateElts.size() == 15);

        // Test the old functions
        CheckResult(database.getElementCount("light-lib") == 1);
        daeElement* elt = NULL;
        database.getElement(&elt, 0, "light-lib", NULL, doc->getDocumentURI()->getURI());
        CheckResult(elt);
        CheckResult(database.getElementCount(NULL, "node") == 5);
        database.getElement(&elt, 8, NULL, "rotate");
        CheckResult(elt);

        return testResult(true);
}


DefineTest(fileExtension) {
        // The DOM used to have a bug where it couldn't resolve URIs or ID refs of
        // documents with extensions other than .dae or .xml. This test ensures that
        // the DOM is extension-agnostic.
        DAE dae;
        CheckResult(dae.open(lookupTestFile("cube.cstm")));
        CheckResult(dae.getDatabase()->typeLookup<domAccessor>().at(0)->getSource().getElement());
        CheckResult(dae.writeTo(lookupTestFile("cube.cstm"), getTmpFile("cube_roundTrip.cstm")));
        return testResult(true);
}


DefineTest(zipFile) {
        // The DOM should be able to load a gzip/zlib-compressed dae via libxml.
        DAE dae;
        CheckResult(dae.open(lookupTestFile("cube.dae.gz")));
        CheckResult(dae.getDatabase()->typeLookup(domAsset::ID()).size() == 1);
        return testResult(true);
}


DefineTest(charEncoding) {
        // Basically we're just looking for crashes or memory leaks here.
        string file = getTmpFile("charEncoding.dae");
        DAE dae;
        dae.setCharEncoding(DAE::Latin1);
        daeElement* elt = dae.add(file)->add("asset contributor comments");
        CheckResult(elt);
        elt->setCharData("æ ø å ü ä ö");
        CheckResult(dae.writeAll());
        dae.clear();
        CheckResult(dae.open(file));
        return testResult(true);
}


DefineTest(getElementBug) {
        DAE dae;
        CheckResult(dae.open(lookupTestFile("cube.dae")));

        // Check daeURI::getElement
        domInstance_geometry* geomInst = dae.getDatabase()->typeLookup<domInstance_geometry>().at(0);
        CheckResult(geomInst->getUrl().getElement());
        daeElement::removeFromParent(geomInst->getUrl().getElement());
        CheckResult(geomInst->getUrl().getElement() == 0);

        // Check daeIDRef::getElement
        daeIDRef idRef(*geomInst);
        idRef.setID("PerspCamera");
        CheckResult(idRef.getElement());
        daeElement::removeFromParent(idRef.getElement());
        CheckResult(idRef.getElement() == 0);

        // Check daeSidRef::resolve
        daeSidRefCache& cache = dae.getSidRefCache();
        daeElement* effect = dae.getDatabase()->typeLookup(domEffect::ID()).at(0);
        daeSidRef sidRef("common", effect);

        CheckResult(cache.empty() && cache.hits() == 0 && cache.misses() == 0);
        daeElement* technique = sidRef.resolve().elt;
        CheckResult(technique && cache.misses() == 1 && !cache.empty());
        sidRef.resolve();
        CheckResult(cache.misses() == 1 && cache.hits() == 1);
        daeElement::removeFromParent(technique);
        CheckResult(cache.empty() && cache.misses() == 0 && cache.hits() == 0);
        CheckResult(sidRef.resolve().elt == NULL);
        CheckResult(cache.empty() && cache.misses() == 1);

        return testResult(true);
}


DefineTest(externalRef) {
        DAE dae;
        CheckResult(dae.open(lookupTestFile("externalRef.dae")));
        domInstance_geometry* geomInst = dae.getDatabase()->typeLookup<domInstance_geometry>().at(0);
        daeURI& uri = geomInst->getUrl();
        CheckResult(uri.isExternalReference() == true);
        CheckResult(uri.getReferencedDocument() == NULL);
        CheckResult(uri.getElement());
        CheckResult(uri.getReferencedDocument());
        return testResult(true);
}


DefineTest(charEncodingSetting) {
        DAE dae;
        dae.setGlobalCharEncoding(DAE::Utf8);
        CheckResult(dae.getCharEncoding() == DAE::Utf8);
        dae.setCharEncoding(DAE::Latin1);
        CheckResult(dae.getCharEncoding() == DAE::Latin1);
        DAE dae2;
        CheckResult(dae2.getCharEncoding() == DAE::Utf8);
        return testResult(true);
}


DefineTest(uriCopy) {
        DAE dae;
        CheckResult(dae.open(lookupTestFile("cube.dae")));
        domInstance_geometry* geomInst = dae.getDatabase()->typeLookup<domInstance_geometry>().at(0);
        daeURI& uri = geomInst->getUrl();
        CheckResult(uri.getElement());
        daeURI uriCopy = geomInst->getUrl();
        CheckResult(uriCopy.getElement());
        return testResult(true);
}


DefineTest(badFileLoad) {
        DAE dae;
        CheckResult(!dae.open(lookupTestFile("badFile.dae")));
        return testResult(true);
}


DefineTest(spuriousQuotes) {
        DAE dae;
        CheckResult(!dae.open(lookupTestFile("quotesProblem.dae")));
        return testResult(true);
}


DefineTest(zaeLoading) {
        DAE dae;

        // check if root document is loaded
        std::string testFile = lookupTestFile("duck.zae");
        domCOLLADA* root = dae.open(testFile);
        CheckResult(root);

        // load sibling doc to root doc
        domInstance_with_extra* instanceVisualScene = daeSafeCast<domInstance_with_extra>(root->getDescendant("instance_visual_scene"));
        CheckResult(instanceVisualScene);
        daeURI visualSceneURI = instanceVisualScene->getUrl();
        domVisual_scene* visualScene = daeSafeCast<domVisual_scene>(visualSceneURI.getElement());
        CheckResult(visualScene);

        // load doc from internal archive
        domInstance_image* instanceImage = daeSafeCast<domInstance_image>(visualScene->getDocument()->getDomRoot()->getDescendant("instance_image"));
        CheckResult(instanceImage);
        daeURI imageURI = instanceImage->getUrl();
        domImage* image = daeSafeCast<domImage>(imageURI.getElement());
        CheckResult(image);

        // check for file in sub dir
        domImage_source::domRef* ref = daeSafeCast<domImage_source::domRef>(image->getDescendant("ref"));
        xsAnyURI imageFileURI = ref->getValue();
        bool imageFileExists = boost::filesystem::exists( cdom::uriToNativePath( imageFileURI.str() ) );
        CheckResult(imageFileExists);

        // load doc from sub dir in internal archive
        domInstance_geometry* instanceGeometry = daeSafeCast<domInstance_geometry>(visualScene->getDocument()->getDomRoot()->getDescendant("instance_geometry"));
        CheckResult(instanceGeometry);
        daeURI geometryURI = instanceGeometry->getUrl();
        domGeometry* geometry = daeSafeCast<domGeometry>(geometryURI.getElement());
        CheckResult(geometry);

        return testResult(true);
}

DefineTest(zaeIllegalArchive) {
        DAE dae;

        // check if root document is loaded
        std::string testFile = lookupTestFile("illegal_archive.zae");
        domCOLLADA* root = dae.open(testFile);
        CheckResult(!root);

        return testResult(true);
}

// DefineTest(hauntedHouse) {
//      DAE dae;
//      CheckResult(dae.open("/home/sthomas/models/hauntedHouse.dae"));
//      return testResult(true);
// }


// Returns true if all test names are valid
bool checkTests(const set<string>& tests) {
        bool invalidTestFound = false;
        for (set<string>::const_iterator iter = tests.begin(); iter != tests.end(); iter++) {
                if (registeredTests().find(*iter) == registeredTests().end()) {
                        if (!invalidTestFound)
                                cout << "Invalid arguments:\n";
                        cout << "  " << *iter << endl;
                        invalidTestFound = true;
                }
        }

        return !invalidTestFound;
}

// Returns the set of tests that failed
map<string, testResult> runTests(const set<string>& tests) {
        map<string, testResult> failedTests;
        for (set<string>::const_iterator iter = tests.begin(); iter != tests.end(); iter++) {
                testResult result = registeredTests()[*iter]->run();
                if (!result.passed)
                        failedTests[*iter] = result;
        }
        return failedTests;
}

// Prints test results to the console.
// Returns true if all tests passed, false otherwise.
bool printTestResults(const map<string, testResult>& failedTests) {
        if (!failedTests.empty()) {
                cout << "Failed tests:\n";
                for (map<string, testResult>::const_iterator iter = failedTests.begin();
                                iter != failedTests.end();
                                iter++) {
                        cout << "    " << iter->first;
                        if (!iter->second.file.empty()) {
                                cout << " (file " << fs::path(iter->second.file).leaf();
                                if (iter->second.line != -1)
                                        cout << ", line " << iter->second.line << ")";
                                else
                                        cout << ")";
                        }
                        cout << endl;
                        if (!iter->second.msg.empty()) // Make sure to indent the message
                                cout << "        " << replace(iter->second.msg, "\n", "\n        ") << "\n";
                }
                return false;
        }
        else {
                cout << "All tests passed.\n";
                return true;
        }
}

struct tmpDir {
        fs::path path;
        bool deleteWhenDone;

        tmpDir(fs::path& path, bool deleteWhenDone)
                : path(path),
                deleteWhenDone(deleteWhenDone) {
                        fs::create_directories(path);
                }

        ~tmpDir() {
                if (deleteWhenDone)
                        fs::remove_all(path);
        }
};


int main(int argc, char* argv[]) {


        DAE dae;
        PFLN
        daeElement* root = dae.add("valid.dae");
        PFLN
        daeElement* asset = root->add("asset");
        daeElement* contributor = asset->add("contributor");
        daeElement* created = asset->add("created");
        daeElement* modified = asset->add("modified");
        const char* date = "2008-04-08T13:07:52-08:00";                                             
        daeBool res = created->setCharData(date);
        printf("result date %d\n", res);
        modified->setCharData(date);

        my_addGeometry(root);
        //my_addImage(root);
        //my_addMaterial(root); 
        //my_addEffect(root);
        //my_addVisualScene(root);

        
        daeElement* effectLib = root->add("library_effects");
        daeElement* effect = effectLib->add("effect");
        effect->setAttribute("id", "cubeEffect");
        daeElement* profile = effect->add("profile_COMMON");
        daeElement* technique = profile->add("technique");
        technique->setAttribute("sid", "phong1");
        daeElement* phong = technique->add("phong");
        daeElement* emission = phong->add("emission color");
        emission->setCharData("0.5 0.5 0.0 1.0");
        daeElement* ambient = phong->add("ambient color");
        ambient->setCharData("0.5 0.5 0.0 1.0");
        PFLN
        daeElement* diffuse = phong->add("diffuse color");
        diffuse->setCharData("0.5 0.5 0.0 1.0");
        PFLN
        daeElement* specular = phong->add("specular color");
        specular->setCharData("0.5 0.5 0.0 1.0");
        PFLN
        daeElement* shininess = phong->add("shininess float");
        PFLN
        shininess->setCharData("20.0");
        daeElement* reflective = phong->add("reflective color");
        PFLN
        reflective->setCharData("0.5 0.5 0.0 1.0");
PFLN
        daeElement* reflectivity = phong->add("reflectivity float");
        PFLN
        reflectivity->setCharData("0.5");
        PFLN
        daeElement* transparent = phong->add("transparent color");
        PFLN
        transparent->setCharData("1.0 1.0 1.0 1.0");
        PFLN
        daeElement* transparency = phong->add("transparency float");
        PFLN
        transparency->setCharData("1.0");
        PFLN


        //Material
        daeElement* materialLib = root->add("library_materials");
        daeElement* material = materialLib->add("material");
        material->setAttribute("id", "cubeMaterial");
        daeElement* instance_effect = material->add("instance_effect");
        instance_effect->setAttribute("url", "#cubeEffect");

        //Visual scene
        daeElement* visualSceneLib = root->add("library_visual_scenes");
        daeElement* visualScene = visualSceneLib->add("visual_scene");
        visualScene->setAttribute("id", "cubeScene");

        // Add a <node> with a simple transformation
        daeElement* node = visualScene->add("node");
        node->setAttribute("id", "cubeNode");
        node->add("rotate")->setCharData("1 0 0 45");
        node->add("translate")->setCharData("0 10 0");
        node->add("scale")->setCharData("1 1 1");

        // Instantiate the <geometry>
        daeElement* instanceGeom = node->add("instance_geometry");
        instanceGeom->setAttribute("url", makeUriRef("cubeGeom").c_str());

        // Bind material parameters
        daeElement* instanceMaterial = instanceGeom->add("bind_material technique_common instance_material");
        instanceMaterial->setAttribute("symbol", "mtl");
        instanceMaterial->setAttribute("target", makeUriRef("cubeMaterial").c_str());

        //daeElement* bindVertexInput = instanceMaterial->add("bind_vertex_input");
        //bindVertexInput->setAttribute("semantic", "uv0");
        //bindVertexInput->setAttribute("input_semantic", "TEXCOORD");
        //bindVertexInput->setAttribute("input_set", "0");

        // Add a <scene>
        root->add("scene instance_visual_scene")->setAttribute("url", makeUriRef("cubeScene").c_str());

        printf("write all\n");
        dae.writeAll();
        printf("returning\n");
        return 0;


        //printf("write all\n");
        //domFloat_array* fa = daeSafeCast<domFloat_array>(polygons->add("float_array"));
        //printf("write all\n");
        //fa->setId((mesh->getAttribute("id") + "-array").c_str());
        //printf("write all\n");
        //fa->setCount(count);
        //printf("write all\n");
        //fa->getValue() = rawArrayToDaeArray(values, valueCount);






        // Windows memory leak checking
#if defined _MSC_VER && defined _DEBUG
        _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF | _CRTDBG_CHECK_EVERY_1024_DF);
#endif

        if (argc == 1) {
                cout << "Usage:\n"
                        "  -printTests - Print the names of all available tests\n"
                        "  -all - Run all tests\n"
                        "  -leaveTmpFiles - Don't delete the tmp folder containing the generated test files\n"
                        "  test1 test2 ... - Run the named tests\n";
                return 0;
        }

        bool printTests = false;
        bool allTests = false;
        bool leaveTmpFiles = false;
        set<string> tests;
        for (int i = 1; i < argc; i++) {
                if (string(argv[i]) == "-printTests")
                        printTests = true;
                else if (string(argv[i]) == "-all")
                        allTests = true;
                else if (string(argv[i]) == "-leaveTmpFiles")
                        leaveTmpFiles = true;
                else
                        tests.insert(argv[i]);
        }

#ifdef __CELLOS_LV2__
        // The program crashes on PS3 if we try to delete the tmp directory when we're done.
        // That shouldn't be the case, but it's really not worth trying to fix it now.
        // Just leave the tmp folder.
        leaveTmpFiles = true;
#endif

        // Shut the DOM up
        daeErrorHandler::setErrorHandler(&quietErrorHandler::getInstance());

        dataPath() = (fs::path(argv[0]).branch_path()/"domTestData/").normalize();
        if (!fs::exists(dataPath()))
                dataPath() = (fs::path(argv[0]).branch_path()/"../../test/1.5/data/").normalize();
        tmpPath() = dataPath() / "tmp";
        tmpDir tmp(tmpPath(), !leaveTmpFiles);

        if (checkTests(tests) == false)
                return 0;

        // -printTest
        if (printTests) {
                map<string, domTest*>::iterator iter;
                for (iter = registeredTests().begin(); iter != registeredTests().end(); iter++)
                        cout << iter->second->name << endl;
                return 0;
        }

        // -all
        if (allTests) {
                map<string, domTest*>::iterator iter;
                for (iter = registeredTests().begin(); iter != registeredTests().end(); iter++)
                        tests.insert(iter->first);
        }

        // test1 test2 ...
        return printTestResults(runTests(tests)) ? 0 : 1;
}

---

wrapper_collada
Author(s): Miguel Oliveira
autogenerated on Wed Jul 23 04:34:51 2014