summaryrefslogtreecommitdiffstats
path: root/sca-cpp/tags/cpp-0.1.incubating-M1-final/sdo/runtime/core/test/sdotest2.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'sca-cpp/tags/cpp-0.1.incubating-M1-final/sdo/runtime/core/test/sdotest2.cpp')
-rw-r--r--sca-cpp/tags/cpp-0.1.incubating-M1-final/sdo/runtime/core/test/sdotest2.cpp1445
1 files changed, 1445 insertions, 0 deletions
diff --git a/sca-cpp/tags/cpp-0.1.incubating-M1-final/sdo/runtime/core/test/sdotest2.cpp b/sca-cpp/tags/cpp-0.1.incubating-M1-final/sdo/runtime/core/test/sdotest2.cpp
new file mode 100644
index 0000000000..28892994cc
--- /dev/null
+++ b/sca-cpp/tags/cpp-0.1.incubating-M1-final/sdo/runtime/core/test/sdotest2.cpp
@@ -0,0 +1,1445 @@
+/*
+ *
+ * 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;
+ }
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-05-29 06:04:20 +0000