/*
 *
 *  Copyright 2006 The Apache Software Foundation or its licensors, as applicable.
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */

/* $Id: SdoTest2.cpp,v 1.2 2006/03/16 12:53:57 slattery Exp $ */

#include <stdio.h>

#pragma warning(disable:4786)

#include <iostream>
#include <fstream>
using namespace std;



#include "sdotest.h"



using namespace commonj::sdo;

DataObjectPtr sdotest::scopetest2()
{

    DataFactoryPtr mdg  = DataFactory::getDataFactory();

    mdg->addType("myspace","Root");

    mdg->addType("myspace","Company");

    mdg->addPropertyToType("myspace","Company","name",
                       "commonj.sdo","String", false, false, false);

    mdg->addPropertyToType("myspace","Company","id",
                       "commonj.sdo","String", false, false, false);

    mdg->addPropertyToType("myspace","Root","company",
                       "myspace","Company", false, false, true);

    const Type& tcc = mdg->getType("myspace","Root");

    DataObjectPtr dop = mdg->create((Type&)tcc);

    DataObjectPtr co = dop->createDataObject("company");

    return dop;
}

int sdotest::scopetest()
{
    DataObjectPtr dob;
    dob = scopetest2();

    // fails on close?
    return 1;
}

int sdotest::xsdtosdo()
{
const char* value;

value = SDOUtils::XSDToSDO("string");
if (!silent)cout << "XSDToSDO(string)=" << value << endl;
if (strcmp(value,"String")) return 0;

value = SDOUtils::XSDToSDO("int");
if (!silent)cout << "XSDToSDO(int)="<< value << endl;
if (strcmp(value,"Integer")) return 0;

value = SDOUtils::XSDToSDO("notinlist");
if (!silent)cout << "XSDToSDO(notinlist)="<< value << endl;
if (strcmp(value,"String")) return 0;

value = SDOUtils::XSDToSDO("");
if (!silent)cout << "XSDToSDO(\"\")="<< value << endl;
if (strcmp(value,"String")) return 0;

value = SDOUtils::XSDToSDO(0);
if (!silent)cout << "XSDToSDO(0)="<< value << endl;
if (strcmp(value,"String")) return 0;

value = SDOUtils::SDOToXSD("String");
if (!silent)cout << "SDOToXSD(String)="<< value << endl;
if (strcmp(value,"string")) return 0;

value = SDOUtils::SDOToXSD("Long");
if (!silent)cout << "SDOToXSD(Long)="<< value << endl;
if (strcmp(value,"unsignedLong")) return 0;

value = SDOUtils::SDOToXSD("notinlist");
if (!silent)cout << "SDOToXSD(notinlist)="<< value << endl;
if (strcmp(value,"string")) return 0;

value = SDOUtils::SDOToXSD("");
if (!silent)cout << "SDOToXSD(\"\")="<< value << endl;
if (strcmp(value,"string")) return 0;

value = SDOUtils::SDOToXSD(0);
if (!silent)cout << "SDOToXSD(0)="<< value << endl;
if (strcmp(value,"string")) return 0;

return 1;

}

int sdotest::compatiblefactory()
{
    DataFactoryPtr f1 = DataFactory::getDataFactory();

    f1->addType("Namespace","Project");
    f1->addType("Namespace","WorkPackage");
    f1->addType("Namespace","LineItem");
    f1->addType("Namespace","StringHolder");
 
    f1->addType("Namespace","Root");
    f1->addPropertyToType("Namespace","Root","project",
                           "Namespace","Project", false, false, true);

    f1->addPropertyToType("Namespace","StringHolder","value",
                           "commonj.sdo","String", false, false, false);
   
    f1->addPropertyToType("Namespace","Project","id",
                           "commonj.sdo","String", false, false, false);
    
    f1->addPropertyToType("Namespace","Project","string",
                           "Namespace","StringHolder", false, false, true);
 
    f1->addPropertyToType("Namespace","WorkPackage","name",
                           "commonj.sdo","String", false, false, false);
    

    f1->addPropertyToType("Namespace","WorkPackage","string",
                           "Namespace","StringHolder", false, false, true);

    f1->addPropertyToType("Namespace","LineItem","itemname",
                           "commonj.sdo","String", false, false, false);

    f1->addPropertyToType("Namespace","LineItem","string",
                           "Namespace","StringHolder", false, false, true);

    f1->addPropertyToType("Namespace","Project","packages",
                           "Namespace","WorkPackage", true, false, true);

    f1->addPropertyToType("Namespace","WorkPackage","lineitems",
                           "Namespace","LineItem", true, false, true);

  
    // project
    //    id (string)
    //    string (StringHolder)
    //    workpackages (WorkPackage)
    
    // workpackage
    //     name (string)
    //     string (StringHolder)
    //     lineitems (LineItem)

    // lineitem
    //     itemname (string)
    

    // factories 1 and 2 are compatible

    DataFactoryPtr f2 = DataFactory::getDataFactory();
    
    f2->addType("Namespace","Project");
    f2->addType("Namespace","WorkPackage");
    f2->addType("Namespace","LineItem");
    f2->addType("Namespace","StringHolder");
 
    f2->addType("Namespace","Root");
    f2->addPropertyToType("Namespace","Root","project",
                           "Namespace","Project", false, false, true);

 
    f2->addPropertyToType("Namespace","StringHolder","value",
                           "commonj.sdo","String", false, false, false);
   
    f2->addPropertyToType("Namespace","Project","id",
                           "commonj.sdo","String", false, false, false);
    
    f2->addPropertyToType("Namespace","Project","string",
                           "Namespace","StringHolder", false, false, true);
 
    f2->addPropertyToType("Namespace","WorkPackage","name",
                           "commonj.sdo","String", false, false, false);
    

    f2->addPropertyToType("Namespace","WorkPackage","string",
                           "Namespace","StringHolder", false, false, true);

    f2->addPropertyToType("Namespace","LineItem","itemname",
                           "commonj.sdo","String", false, false, false);

    f2->addPropertyToType("Namespace","LineItem","string",
                           "Namespace","StringHolder", false, false, true);

    f2->addPropertyToType("Namespace","Project","packages",
                           "Namespace","WorkPackage", true, false, true);

    f2->addPropertyToType("Namespace","WorkPackage","lineitems",
                           "Namespace","LineItem", true, false, true);


    // factory 3 has no project type

    DataFactoryPtr f3 = DataFactory::getDataFactory();

    f3->addType("Namespace","WorkPackage");
    f3->addType("Namespace","LineItem");
    f3->addType("Namespace","StringHolder");
 
    f3->addType("Namespace","Root");
    f3->addPropertyToType("Namespace","Root","project",
                           "Namespace","WorkPackage", false, false, true);

 
    f3->addPropertyToType("Namespace","StringHolder","value",
                           "commonj.sdo","String", false, false, false);
   
    f3->addPropertyToType("Namespace","WorkPackage","name",
                           "commonj.sdo","String", false, false, false);
    

    f3->addPropertyToType("Namespace","WorkPackage","string",
                           "Namespace","StringHolder", false, false, true);

    f3->addPropertyToType("Namespace","LineItem","itemname",
                           "commonj.sdo","String", false, false, false);

    f3->addPropertyToType("Namespace","LineItem","string",
                           "Namespace","StringHolder", false, false, true);


    f3->addPropertyToType("Namespace","WorkPackage","lineitems",
                           "Namespace","LineItem", true, false, true);


    // factory 4 looks compatible - but stringholder is missing

    DataFactoryPtr f4 = DataFactory::getDataFactory();
    
    f4->addType("Namespace","Project");
    f4->addType("Namespace","WorkPackage");
    f4->addType("Namespace","LineItem");
 
    f4->addType("Namespace","Root");
    f4->addPropertyToType("Namespace","Root","project",
                           "Namespace","Project", false, false, true);

 
    f4->addPropertyToType("Namespace","Project","id",
                           "commonj.sdo","String", false, false, false);
    
 
    f4->addPropertyToType("Namespace","WorkPackage","name",
                           "commonj.sdo","String", false, false, false);
    

    f4->addPropertyToType("Namespace","LineItem","itemname",
                           "commonj.sdo","String", false, false, false);

    f4->addPropertyToType("Namespace","Project","packages",
                           "Namespace","WorkPackage", true, false, true);

    f4->addPropertyToType("Namespace","WorkPackage","lineitems",
                           "Namespace","LineItem", true, false, true);


    // factory 5 looks compatible, but the lists are not lists

    DataFactoryPtr f5 = DataFactory::getDataFactory();
    
    f5->addType("Namespace","Project");
    f5->addType("Namespace","WorkPackage");
    f5->addType("Namespace","LineItem");
    f5->addType("Namespace","StringHolder");
 
    f5->addType("Namespace","Root");
    f5->addPropertyToType("Namespace","Root","project",
                           "Namespace","Project", false, false, true);

 
    f5->addPropertyToType("Namespace","StringHolder","value",
                           "commonj.sdo","String", false, false, false);
   
    f5->addPropertyToType("Namespace","Project","id",
                           "commonj.sdo","String", false, false, false);
    
    f5->addPropertyToType("Namespace","Project","string",
                           "Namespace","StringHolder", false, false, true);
 
    f5->addPropertyToType("Namespace","WorkPackage","name",
                           "commonj.sdo","String", false, false, false);
    

    f5->addPropertyToType("Namespace","WorkPackage","string",
                           "Namespace","StringHolder", false, false, true);

    f5->addPropertyToType("Namespace","LineItem","itemname",
                           "commonj.sdo","String", false, false, false);

    f5->addPropertyToType("Namespace","LineItem","string",
                           "Namespace","StringHolder", false, false, true);

    f5->addPropertyToType("Namespace","Project","packages",
                           "Namespace","WorkPackage", false, false, true);

    f5->addPropertyToType("Namespace","WorkPackage","lineitems",
                           "Namespace","LineItem", false, false, true);

    // factory 6 looks OK, but the lineitems have no itemname field

    DataFactoryPtr f6 = DataFactory::getDataFactory();
    
    f6->addType("Namespace","Project");
    f6->addType("Namespace","WorkPackage");
    f6->addType("Namespace","LineItem");
    f6->addType("Namespace","StringHolder");
 
    f6->addType("Namespace","Root");
    f6->addPropertyToType("Namespace","Root","project",
                           "Namespace","Project", false, false, true);

 
    f6->addPropertyToType("Namespace","StringHolder","value",
                           "commonj.sdo","String", false, false, false);
   
    f6->addPropertyToType("Namespace","Project","id",
                           "commonj.sdo","String", false, false, false);
    
    f6->addPropertyToType("Namespace","Project","string",
                           "Namespace","StringHolder", false, false, true);
 
    f6->addPropertyToType("Namespace","WorkPackage","name",
                           "commonj.sdo","String", false, false, false);
    

    f6->addPropertyToType("Namespace","WorkPackage","string",
                           "Namespace","StringHolder", false, false, true);

    f6->addPropertyToType("Namespace","LineItem","string",
                           "Namespace","StringHolder", false, false, true);

    f6->addPropertyToType("Namespace","Project","packages",
                           "Namespace","WorkPackage", true, false, true);

    f6->addPropertyToType("Namespace","WorkPackage","lineitems",
                           "Namespace","LineItem", true, false, true);


    // factory 7 looks OK, but the identifiers are ints
    
    
    DataFactoryPtr f7 = DataFactory::getDataFactory();

    f7->addType("Namespace","Project");
    f7->addType("Namespace","WorkPackage");
    f7->addType("Namespace","LineItem");
    f7->addType("Namespace","StringHolder");
 
    f7->addType("Namespace","Root");
    f7->addPropertyToType("Namespace","Root","project",
                           "Namespace","Project", false, false, true);

    f7->addPropertyToType("Namespace","StringHolder","value",
                           "commonj.sdo","String", false, false, true);
   
    f7->addPropertyToType("Namespace","Project","id",
                           "commonj.sdo","Integer", false, false, false);
    
    f7->addPropertyToType("Namespace","Project","string",
                           "Namespace","StringHolder", false, false, true);
 
    f7->addPropertyToType("Namespace","WorkPackage","name",
                           "commonj.sdo","String", false, false, false);
    

    f7->addPropertyToType("Namespace","WorkPackage","string",
                           "Namespace","StringHolder", false, false, true);

    f7->addPropertyToType("Namespace","LineItem","itemname",
                           "commonj.sdo","Integer", false, false, false);

    f7->addPropertyToType("Namespace","LineItem","string",
                           "Namespace","StringHolder", false, false, true);

    f7->addPropertyToType("Namespace","Project","packages",
                           "Namespace","WorkPackage", true, false, true);

    f7->addPropertyToType("Namespace","WorkPackage","lineitems",
                           "Namespace","LineItem", true, false, true);


    // create a tree from Root in factory 1

    DataObjectPtr root = f1->create("Namespace","Root");
    DataObjectPtr project = root->createDataObject("project");
    project->setCString("id","The TTP Project");
    DataObjectPtr str = project->createDataObject("string");
    str->setCString("value","The Recursive Acronym Project");
    DataObjectPtr wp1 = project->createDataObject("packages");
    DataObjectPtr wp2 = project->createDataObject("packages");
    wp1->setCString("name","Work Package 1");
    wp2->setCString("name","Work Package 2");
    DataObjectPtr li1 = wp1->createDataObject("lineitems");
    DataObjectPtr li2 = wp1->createDataObject("lineitems");
    DataObjectPtr li3 = wp2->createDataObject("lineitems");
    DataObjectPtr li4 = wp2->createDataObject("lineitems");
    li1->setCString("itemname","LineItem 1");
    li2->setCString("itemname","LineItem 2");
    li3->setCString("itemname","LineItem 3");
    li4->setCString("itemname","LineItem 4");
    DataObjectPtr str1 = li1->createDataObject("string");
    DataObjectPtr str2 = li2->createDataObject("string");
    DataObjectPtr str3 = li3->createDataObject("string");
    DataObjectPtr str4 = li4->createDataObject("string");
    str1->setCString("value","String1");
    str2->setCString("value","String2");
    str3->setCString("value","String3");
    str4->setCString("value","String4");


//    cout << "DATA OBJECTS FROM FACTORY 1" << endl;
//    printDataObject(root);

    if (!transferto(root,f2, false)) return 0;
    if (!transferto(root,f3, true)) return 0;
    if (!transferto(root,f4, true)) return 0;
    if (!transferto(root,f5, true)) return 0;
    if (!transferto(root,f6, true)) return 0;
    if (!transferto(root,f7, true)) return 0;

    // finally, lets move one which has a parent and cant be moved.

    try {
        DataObjectPtr project = root->getDataObject("project");

        DataObjectPtr root2 = f2->create("Namespace","Root");
    
        root2->setDataObject("project", project);
        return 0;
    }
    catch (SDORuntimeException e)
    {
        //cout << "Compatibility test correctly returned an error :" ;
        //cout << e.getMessageText() << endl;
        return 1;
    }
  
}

int sdotest::transferto(DataObjectPtr root, DataFactoryPtr f2, bool expecterror)
{
    try {

        // transfer the tree to factory 2...
        DataObjectPtr rproject = root->getDataObject("project");

        DataObjectPtr project = CopyHelper::copy(rproject);

        DataObjectPtr root2 = f2->create("Namespace","Root");
    
        root2->setDataObject("project", project);

        //cout << "DATA OBJECTS TRANSFERRED" << endl;

        //printDataObject(root2);
        
        if (expecterror)
        {
            return 0;
        }
        return 1;
    }
    catch (SDORuntimeException e)
    {
        if (expecterror){
            //cout << "Compatibility test correctly returned an error :" ;
            //cout << e.getMessageText() << endl;
            return 1;
        }
        else
        {
            if (!silent)cout << "Compatibility test failed whilst transferring " << e << endl;
            return 0;
        }
    }
}


int sdotest::b48602()
{


    int i,j;

    try {


        DataFactoryPtr mdg  = DataFactory::getDataFactory();

        XSDHelperPtr xsh = HelperProvider::getXSDHelper(mdg);
    
        xsh->defineFile("b48602.xsd");

        if ((i = xsh->getErrorCount()) > 0)
        {
            if (!silent)
            {
                cout << "PROBLEM: b48602 XSD reported some errors:" << endl;
                for (j=0;j<i;j++)
                {
                    const char *m = xsh->getErrorMessage(j);
                    if (m != 0) cout << m;
                    cout << endl;
                }
            }
            return 0;
        }
        return 0;
    }
    catch (SDOTypeNotFoundException e)
    {
        return 1;
    }
    catch (SDORuntimeException e)
    {
        return 1;
    }

}

int sdotest::testany(const char* xsd, 
                     const char* acceptedxsderror,
                     const char* xml,
                     const char* acceptedxmlerror)
{


    int i,j,rc;

    try {

        char *c;
        

 
        DataFactoryPtr mdg  = DataFactory::getDataFactory();

        XSDHelperPtr xsh = HelperProvider::getXSDHelper(mdg);
    
        if (xsd)
        {
            char * name1 = new char[strlen(xsd)+5];
            char * name3 = new char[strlen(xsd)+5];
            strcpy(name1,xsd);
            while ((c = strchr(name1,'.')) != 0)*c = '_';
            strcpy(name3,name1);
            strcat(name1,".dat");
            strcat(name3,".txt");


            FILE *f1 = fopen(name1,"w+");
            if (f1 == 0)
            {
                if (!silent)cout << "Unable to open " << name1 << endl;
                delete name1;
                delete name3;
                return 0;
            }

            xsh->defineFile(xsd);

            if ((i = xsh->getErrorCount()) > 0)
            {
                if (acceptedxsderror != 0)
                {
                    for (j=0;j<i;j++)
                    {
                        if (!strcmp(acceptedxsderror,xsh->getErrorMessage(j)))
                        {
                            fclose(f1);
                            delete name1;
                            delete name3;
                            return 1;
                        }
                    }
                }
                if (!silent)
                {
                    cout << "PROBLEM: Testany XSD reported some errors:" << endl;
                    for (j=0;j<i;j++)
                    {
                        const char *m = xsh->getErrorMessage(j);
                        if (m != 0) cout << m;
                        cout << endl;
                    }
                }
                fclose(f1);
                delete name1;
                delete name3;
                return 0;
            }


            TypeList tl = mdg->getTypes();

            fprintf(f1, "***** TYPES BEFORE RESOLVE **********************************\n");

            for (i=0;i<tl.size();i++)
            {
                fprintf(f1,"Type:%s#%s\n",tl[i].getURI(),tl[i].getName());
                PropertyList pl = tl[i].getProperties();
                for (int j=0;j<pl.size();j++)
                {
                    fprintf(f1,"Property:%s ",pl[j].getName());
                    if (pl[j].isMany())
                         fprintf(f1, "(many) ");
                    fprintf(f1,  " of type %s\n",pl[j].getType().getName());
                }
            }

            fprintf(f1, "*******************************END TYPES******************\n");

            fclose(f1);
        

            rc = comparefiles(name1,name3);
            
            delete name1;
            delete name3;
            
            if (rc == 0)return rc;
    
        }

        if (xml == 0 || strlen(xml) == 0) return 1;

        char * name2 = new char[strlen(xml)+5];
        char * name4 = new char[strlen(xml)+5];
        strcpy(name2,xml);
        while ((c = strchr(name2,'.')) != 0)*c = '_';
        strcpy(name4,name2);
      
        strcat(name2,".dat");
        strcat(name4,".txt");

        FILE *f2 = fopen(name2,"w+");
        if (f2 == 0)
        {
            if (!silent)cout << "Unable to open " << name2 << endl;
            delete name2;
            delete name4;
            return 0;
        }

        XMLHelperPtr xmh = HelperProvider::getXMLHelper(mdg);
 
        XMLDocumentPtr doc = xmh->loadFile(xml);

        if ((i = xmh->getErrorCount()) > 0)
        {
            if (acceptedxmlerror != 0)
            {
                for (j=0;j<i;j++)
                {
                    if (!strcmp(acceptedxmlerror,xmh->getErrorMessage(j)))
                    {
                        fclose(f2);
                        delete name2;
                        delete name4;
                        return 1;
                    }
                }
            }
            if (!silent)
            {
                cout << "TestAny XML found errors:" << endl;
                for (j=0;j<i;j++)
                {
                    const char *m = xmh->getErrorMessage(j);
                    if (m != 0) cout << m;
                    cout << endl;
                }
            }
            fclose(f2);
            delete name2;
            delete name4;
            return 0;
        }

        else {
            TypeList tl = mdg->getTypes();

            fprintf(f2, "***** TYPES AFTER RESOLVE*********************************\n");

            for (i=0;i<tl.size();i++)
            {
                fprintf(f2,"Type:%s#%s\n",tl[i].getURI(),tl[i].getName());
                PropertyList pl = tl[i].getProperties();
                for (int j=0;j<pl.size();j++)
                {
                    fprintf(f2, "Property:%s ",pl[j].getName());
                    if (pl[j].isMany())
                        fprintf(f2, "(many) ");
                    fprintf(f2,  " of type %s\n",pl[j].getType().getName());
                }
            }

            fprintf(f2, "*******************************END TYPES******************\n");
    

            DataObjectPtr dob = doc->getRootDataObject();
            printDataObject(f2, dob);

            fclose(f2);

            rc = comparefiles(name2,name4);

            delete name2;
            delete name4;

            return rc;
        }

    }
    catch (SDORuntimeException e)
    {
        if (!silent)cout << "Exception in TestAny" << e << endl;
        return 0;
    }
}



int sdotest::testanytwo(const char* xsd, const char* xsd2,
                         const char* xml)
{


    int i,j;

    try {

    char * name1 = new char[strlen(xsd)+5];
    char * name2 = new char[strlen(xml)+5];
    char * name3 = new char[strlen(xsd)+5];
    char * name4 = new char[strlen(xml)+5];
    strcpy(name1,xsd);
    strcpy(name2,xml);
    char *c;
    while ((c = strchr(name1,'.')) != 0)*c = '_';
    while ((c = strchr(name2,'.')) != 0)*c = '_';
    strcpy(name3,name1);
    strcpy(name4,name2);
    
    strcat(name1,".dat");
    strcat(name2,".dat");
    strcat(name3,".txt");
    strcat(name4,".txt");

    DataFactoryPtr mdg  = DataFactory::getDataFactory();

    XSDHelperPtr xsh = HelperProvider::getXSDHelper(mdg);
    
    if (xsd)
    {
        xsh->defineFile(xsd);

        if ((i = xsh->getErrorCount()) > 0)
        {
            if (!silent)
            {
                cout << "PROBLEM: Testany XSD reported some errors:" << endl;
                for (j=0;j<i;j++)
                {
                    const char *m = xsh->getErrorMessage(j);
                    if (m != 0) cout << m;
                    cout << endl;
                }
            }
            return 0;
        }

    }

    if (xsd2)
    {
        xsh->defineFile(xsd2);

        if ((i = xsh->getErrorCount()) > 0)
        {
            if (!silent)
            {
                cout << "PROBLEM: Testany XSD2 reported some errors:" << endl;
                for (j=0;j<i;j++)
                {
                    const char *m = xsh->getErrorMessage(j);
                    if (m != 0) cout << m;
                    cout << endl;
                }
            }
            return 0;
        }
    }

    if (xsd)
    {


        FILE *f1 = fopen(name1,"w+");
        if (f1 == 0)
        {
            if (!silent)cout << "Unable to open " << name1 << endl;
            return 0;
        }

        TypeList tl = mdg->getTypes();

        fprintf(f1,"***** TESTANY ******************************************\n");

        for (i=0;i<tl.size();i++)
        {
            fprintf(f1,"Type:%s#%s\n",tl[i].getURI(),tl[i].getName());
            PropertyList pl = tl[i].getProperties();
            for (int j=0;j<pl.size();j++)
            {
                fprintf(f1,"Property:%s ",pl[j].getName());
                if (pl[j].isMany())
                     fprintf(f1, "(many) ");
                fprintf(f1,  " of type %s\n",pl[j].getType().getName());
            }
        }

        fprintf(f1,"*******************************END TYPES******************\n");
    
        fclose(f1);

        if (!comparefiles(name1,name3)) return 0;

    }
    

    if (xml == 0 || strlen(xml) == 0) return 1;


    FILE *f2 = fopen(name2,"w+");
    if (f2 == 0)
    {
        if (!silent)cout << "Unable to open " << name2 << endl;
        return 0;
    }

    XMLHelperPtr xmh = HelperProvider::getXMLHelper(mdg);
 
    XMLDocumentPtr doc = xmh->loadFile(xml);

    if ((i = xmh->getErrorCount()) > 0)
    {
        if (!silent)
        {
            cout << "TestAny XML found errors:" << endl;
            for (j=0;j<i;j++)
            {
                const char *m = xmh->getErrorMessage(j);
                if (m != 0) cout << m;
                cout << endl;
            }
        }
        return 0;
    }
    else 
    {
        DataObjectPtr dob = doc->getRootDataObject();
        printDataObject(f2, dob);
    }

    fclose(f2);
    return comparefiles(name2,name4);

    }
    catch (SDORuntimeException e)
    {
        if (!silent)cout << "Exception in TestAnyTwo" << e << endl;
        return 0;
    }
}

int sdotest::openseq()

{

    DataFactoryPtr mdg  = DataFactory::getDataFactory();

    FILE *f = fopen("openseq.dat","w+");
    if (f == 0)
    {
        if (!silent)cout << "Unable to open openseq.dat" << endl;
        return 0;
    }


    mdg->addType("companyNS","CompanyType");
    // employee will be an open sequenced type...
    mdg->addType("companyNS","EmployeeType", /*seq*/true, 
                                             /*open*/true, 
                                             /*abs */ false, 
                                             /*data*/ false);


    /* Now add the properties to the types...*/

    
    const Type& tstring  = mdg->getType("commonj.sdo","String");
    const Type& tcomp    = mdg->getType("companyNS","CompanyType");
    const Type& temp     = mdg->getType("companyNS","EmployeeType");

    
    mdg->addPropertyToType(tcomp,"name",tstring);

    mdg->addPropertyToType(tcomp,"employees",temp,true);
    
    mdg->addPropertyToType(temp, "name",tstring);
 
    DataObjectPtr comp = mdg->create((Type&)tcomp);
    comp->setCString("name","ACME");

    DataObjectPtr emp = mdg->create(temp);

    emp->setCString("name","Albert");
 
    emp->setCString("openstring","Value Of Open String");

    /* now do the same with the employee seq...*/

    SequencePtr seq = emp->getSequence();

    seq->addCString("opensequencedstring","Value of sequenced string");

    const char* c = emp->getCString("openstring");

    fprintf(f, "Open Type string value: %s\n",c);

    c = emp->getCString("opensequencedstring");

    fprintf(f, "Open Sequenced string value: %s\n",c);

    c = seq->getCStringValue(0);

    fprintf(f, "Open Sequenced string value from seq: %s\n",c);

    //cout << "END TEST: OpenSeq ======================================" << endl;
    fclose(f);
    return comparefiles("openseq.dat","openseq.txt");
}

int sdotest::b48601()
{
    return testany("48601.xsd",
        "Schema contains a union which is not yet implemented",0,0);
}

int sdotest::b48686()
{
    return testany("48686.xsd",0,"48686.xml",0);
}

int sdotest::b48736()
{
    return testany("48736.xsd",0,"48736.xml",0);
}


int sdotest::testgenerate(const char* xsd, const char* output)
{

    int i,j;

    try {

        char * name1 = new char[strlen(output) + 5];
        char * name2 = new char[strlen(output) + 5];
        char * c;
        strcpy(name1,output);
        while ((c = strchr(name1,'.')) != 0)*c='_';
        strcpy(name2,name1); 
        strcat(name1,".dat");
        strcat(name2,".txt");


        DataFactoryPtr mdg  = DataFactory::getDataFactory();

        XSDHelperPtr xsh = HelperProvider::getXSDHelper(mdg);
    
        if (xsd)
        {
            xsh->defineFile(xsd);

            if ((i = xsh->getErrorCount()) > 0)
            {

                if (!silent)
                {
                    cout << "PROBLEM: generation XSD reported some errors:" << endl;
                    for (j=0;j<i;j++)
                    {
                        const char *m = xsh->getErrorMessage(j);
                        if (m != 0) cout << m;
                        cout << endl;
                    }
                }
                return 0;
            }
            else
            {
                mdg->generateInterface(name1,"Test");
                return comparefiles(name1,name2);
            }
        }
        return 0;
    }
    catch (SDORuntimeException e)
    {
        if (!silent)cout << "Exception in TestGenerate" << e << endl;
        return 0;
    }
}


int sdotest::emptycs()
{
try {
    DataFactoryPtr mdg  = DataFactory::getDataFactory();

    XSDHelperPtr xsh = HelperProvider::getXSDHelper(mdg);
    xsh->defineFile("company.xsd");

   
    const Type& tstring  = mdg->getType("commonj.sdo","String");
    const Type& tbool    = mdg->getType("commonj.sdo","Boolean");
    const Type& tcs      = mdg->getType("commonj.sdo","ChangeSummary");
    const Type& tcomp    = mdg->getType("companyNS","CompanyType");
    const Type& tdept    = mdg->getType("companyNS","DepartmentType");
    const Type& temp     = mdg->getType("companyNS","EmployeeType");

    
    // create a graph, then save it

    DataObjectPtr comp = mdg->create((Type&)tcomp);
    comp->setCString("name","ACME");

    DataObjectPtr dept = mdg->create((Type&)tdept);
    DataObjectList& dol = comp->getList("departments");
    dol.append(dept);

    dept->setCString("name","Advanced Technologies");
    dept->setCString("location","NY");
    dept->setCString("number","123");

    DataObjectPtr emp1 = mdg->create(temp);
    DataObjectPtr emp2 = mdg->create(temp);
    DataObjectPtr emp3 = mdg->create(temp);

    emp1->setCString("name","John Jones");
    emp1->setCString("SN","E0001");

    emp2->setCString("name","Mary Smith");
    emp2->setCString("SN","E0002");
    emp2->setBoolean("manager",true);

    emp3->setCString("name","Jane Doe");
    emp3->setCString("SN","E0003");

    DataObjectList& dol2 = dept->getList("employees");
    dol2.append(emp1);
    dol2.append(emp2);
    dol2.append(emp3);

    comp->setDataObject("employeeOfTheMonth",emp2);

    // right now, there is no change summary, and logging is
    // off - we expect an empty change summary element

    XMLHelperPtr xmh = HelperProvider::getXMLHelper(mdg);
    XMLDocumentPtr doc = xmh->createDocument(comp,"companyNS","company");
    
    xmh->save(doc,"emptycs1.xml");

    if (!comparefiles("emptycs1.xml","emptycs1.txt"))return 0;

    ChangeSummaryPtr cs = comp->getChangeSummary();

    cs->beginLogging();

    xmh->save(doc,"emptycs2.xml");

    if (!comparefiles("emptycs2.xml","emptycs2.txt"))return 0;

    // now we expect and empty change summary with logging true

    DataObjectPtr emp4 = mdg->create(temp);
    emp4->setCString("name","Al Smith");
    emp4->setCString("SN","E0004");
    emp4->setBoolean("manager",true);

    // first change - create employee 4
    dol2.append(emp4);

    cs->endLogging();

    //serializeChangeSummary(cs);

    xmh->save(doc,"emptycs3.xml");

    if (!comparefiles("emptycs3.xml","emptycs3.txt"))return 0;

    return 1;

    }
    catch (SDORuntimeException e)
    {
        if (!silent)cout << "empty change summary save failed" << e << endl;
        return 0;
    }
}


int sdotest::definetest()
{
    try {

        DataFactoryPtr mdg  = DataFactory::getDataFactory();

        XSDHelperPtr xsh = HelperProvider::getXSDHelper(mdg);
        
        TypeDefinitions* ts = new TypeDefinitions();
        if (ts) delete ts;
        ts = new TypeDefinitions();


        TypeDefinition* td = new TypeDefinition();

        td->setName("MySmallObject");
        td->setUri("MyNameSpace");
        td->setIsDataType(false);

        TypeDefinition* td2 = new TypeDefinition();
        td2->setName("MyOtherObject");
        td2->setUri("MyNameSpace");
        td2->setIsDataType(false);


        PropertyDefinition* pd = new PropertyDefinition();
        pd->setName("MyIntegerProperty");
        pd->setType("commonj.sdo","Integer");

        PropertyDefinition* pd2 = new PropertyDefinition();
        pd2->setName("MyObjectProperty");
        pd2->setType("MyNameSpace","MyOtherObject");
        pd2->setIsMany(true);

        td->addPropertyDefinition(*pd);

        td->addPropertyDefinition(*pd2); 

        ts->addTypeDefinition(*td);
        ts->addTypeDefinition(*td2);

        // should have an object of type MySmallObject, containing
        // a single integer called MyIntegerProperty, and a list of
        // objects called MyObjectProperty - of type MyOtherObject

        xsh->defineTypes(*ts);

        delete td;
        delete td2;
        delete ts;
        delete pd;
        delete pd2;

        DataObjectPtr dob = mdg->create("MyNameSpace","MySmallObject");
        dob->setInteger("MyIntegerProperty",43);

        dob->createDataObject("MyObjectProperty");
        dob->createDataObject("MyObjectProperty");
        DataObjectList& dl = dob->getList("MyObjectProperty");

        if (dl.size() != 2)
        {
            if (!silent) cout << "Define test list size is wrong" << endl;
            return 0;
        }
        int value = dob->getInteger("MyIntegerProperty");
        if (value != 43)
        {
            if (!silent) cout << "Define test integer value is wrong" << endl;
            return 0;
        }

        return 1;
    }
    catch (SDORuntimeException e)
    {
        if (!silent)cout << "define test failed" << endl << e << endl;
        return 0;
    }

}


int sdotest::stocktest()
{
    return sdotest::testany("stock.wsdl",0,"stock.xml",0);
}


/******************************************************
int sdotest::stocktest()
{
    int i,j;

    try {

        DataFactoryPtr mdg  = DataFactory::getDataFactory();

        XSDHelperPtr xsh = HelperProvider::getXSDHelper(mdg);
    
        xsh->defineFile("stock.wsdl");

        if ((i = xsh->getErrorCount()) > 0)
        {
            cout << "PROBLEM: Testany XSD reported some errors:" << endl;
            for (j=0;j<i;j++)
            {
                const char *m = xsh->getErrorMessage(j);
                if (m != 0) cout << m;
                cout << endl;
            }
        }
 
        TypeList tl = mdg->getTypes();

        printf("***** TYPES BEFORE RESOLVE **********************************\n");

        for (i=0;i<tl.size();i++)
        {
            printf("Type:%s#%s\n",tl[i].getURI(),tl[i].getName());
            PropertyList pl = tl[i].getProperties();
            for (int j=0;j<pl.size();j++)
            {
                printf("Property:%s ",pl[j].getName());
                if (pl[j].isMany())
                     printf("(many) ");
                printf(" of type %s\n",pl[j].getType().getName());
            }
        }

        printf("*******************************END TYPES******************\n");

 
        
        XMLHelperPtr xmh = HelperProvider::getXMLHelper(mdg);
 
        XMLDocumentPtr doc = xmh->loadFile("stock.xml");

        if ((i = xmh->getErrorCount()) > 0)
        {
            cout << "TestAny XML found errors:" << endl;
            for (j=0;j<i;j++)
            {
                const char *m = xmh->getErrorMessage(j);
                if (m != 0) cout << m;
                cout << endl;
            }
        }
   

        DataObjectPtr dob = doc->getRootDataObject();
        printDataObject(stdout, dob);

        return 1;

    }
    catch (SDORuntimeException e)
    {
        if (!silent)cout << "Exception in TestAny" << e << endl;
        return 0;
    }
}
**************************************************/


int sdotest::pete()
{


    int i,j;

    try {

 
        DataFactoryPtr mdg  = DataFactory::getDataFactory();

        XSDHelperPtr xsh = HelperProvider::getXSDHelper(mdg);
 
        xsh->defineFile("pete.xsd");

        if ((i = xsh->getErrorCount()) > 0)
        {
            for (j=0;j<i;j++)
            {
                const char *m = xsh->getErrorMessage(j);
                if (m != 0) cout << m;
                cout << endl;
            }
            return 0;
        }



        XMLHelperPtr xmh = HelperProvider::getXMLHelper(mdg);
 
        XMLDocumentPtr doc = xmh->loadFile("pete.xml");

        if ((i = xmh->getErrorCount()) > 0)
        {
            for (j=0;j<i;j++)
            {
                const char *m = xmh->getErrorMessage(j);
                if (m != 0) cout << m;
                cout << endl;
            }
            return 0;
        }

        TypeList tl = mdg->getTypes();

        //printf("***** TYPES **********************************************\n");

        for (i=0;i<tl.size();i++)
        {
            //printf("Type:%s#%s\n",tl[i].getURI(),tl[i].getName());
            PropertyList pl = tl[i].getProperties();
            for (int j=0;j<pl.size();j++)
            {
                //printf("Property:%s ",pl[j].getName());
                //if (pl[j].isMany())
                    //printf( "(many) ");
                //printf( " of type %s\n",pl[j].getType().getName());
            }
        }

        //printf( "*******************************END TYPES******************\n");
    

        DataObjectPtr dob = doc->getRootDataObject();
        float f = dob->getFloat("Stock[1]/Last");
        //printf("Float is %2.3f \r\n",f);
        return 1;

    }
    catch (SDORuntimeException e)
    {
        cout << "Exception in Pete" << e << endl;
        return 0;
    }
}

int sdotest::xhtml1()
{


    int i,j;

    try {

 
        DataFactoryPtr mdg  = DataFactory::getDataFactory();

        XSDHelperPtr xsh = HelperProvider::getXSDHelper(mdg);
 
        xsh->defineFile("Atom1.0.xsd");

        if ((i = xsh->getErrorCount()) > 0)
        {
            for (j=0;j<i;j++)
            {
                const char *m = xsh->getErrorMessage(j);
                if (m != 0) cout << m;
                cout << endl;
            }
            return 0;
        }



        XMLHelperPtr xmh = HelperProvider::getXMLHelper(mdg);
 
        XMLDocumentPtr doc = xmh->loadFile("xhtml_in.xml");

        if ((i = xmh->getErrorCount()) > 0)
        {
           for (j=0;j<i;j++)
            {
                const char *m = xmh->getErrorMessage(j);
                if (m != 0) cout << m;
                cout << endl;
            }
            return 0;
        }

 
        //DataObjectPtr dob = doc->getRootDataObject();

        //ofstream myout("myfile");

        //if (dob)SDOUtils::printDataObject(myout , dob);

        xmh->save(doc,"xhtml_out.xml");

        return comparefiles("xhtml_out.xml" ,"xhtml_out.txt");


    }
    catch (SDORuntimeException e)
    {
        cout << "Exception in xhtml1" << e << endl;
        return 0;
    }
}