diff options
Diffstat (limited to 'sca-cpp/tags/cpp-stable-20060304/sdo/runtime/core/test/sdotest2.cpp')
| -rw-r--r-- | sca-cpp/tags/cpp-stable-20060304/sdo/runtime/core/test/sdotest2.cpp | 3937 |
1 files changed, 3937 insertions, 0 deletions
diff --git a/sca-cpp/tags/cpp-stable-20060304/sdo/runtime/core/test/sdotest2.cpp b/sca-cpp/tags/cpp-stable-20060304/sdo/runtime/core/test/sdotest2.cpp new file mode 100644 index 0000000000..9f547af4eb --- /dev/null +++ b/sca-cpp/tags/cpp-stable-20060304/sdo/runtime/core/test/sdotest2.cpp @@ -0,0 +1,3937 @@ +/* + * + * Copyright 2005 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. + */ + +/* $Rev$ $Date: 2005/12/22 16:54:31 $ */ + +#include <stdio.h> + +#pragma warning(disable:4786) + +#include <iostream> +using namespace std; + +// #include "TypeImpl.h" + +#include "sdotest.h" + + + +using namespace commonj::sdo; + +void sdotest::eqhelpertest() +{ + + // copy and equality helpers + + DataFactoryPtr mdg = DataFactory::getDataFactory(); + + mdg->addType("myspace","Assembly"); + mdg->addType("myspace","SubAssembly"); + mdg->addType("myspace","Part"); + + /* Now add the properties to the types...*/ + + + const Type& tstring = mdg->getType("commonj.sdo","String"); + const Type& tint = mdg->getType("commonj.sdo","Integer"); + const Type& tassy = mdg->getType("myspace","Assembly"); + const Type& tsubassy = mdg->getType("myspace","SubAssembly"); + const Type& tpart = mdg->getType("myspace","Part"); + + + mdg->addPropertyToType(tassy,"name",tstring); + mdg->addPropertyToType(tsubassy,"name",tstring); + mdg->addPropertyToType(tpart,"name",tstring); + + mdg->addPropertyToType(tassy,"number",tint); + mdg->addPropertyToType(tsubassy,"number",tint); + mdg->addPropertyToType(tpart,"number",tint); + + mdg->addPropertyToType(tassy,"subassemblies", tsubassy,true); + mdg->addPropertyToType(tsubassy,"parts", tpart,true); + + + // assy 1 + + DataObjectPtr assy1 = mdg->create((Type&)tassy); + + DataObjectPtr subassy1 = assy1->createDataObject("subassemblies"); + DataObjectPtr subassy2 = assy1->createDataObject("subassemblies"); + + DataObjectPtr part1 = subassy1->createDataObject("parts"); + DataObjectPtr part2 = subassy1->createDataObject("parts"); + DataObjectPtr part3 = subassy1->createDataObject("parts"); + + DataObjectPtr part4 = subassy2->createDataObject("parts"); + DataObjectPtr part5 = subassy2->createDataObject("parts"); + DataObjectPtr part6 = subassy2->createDataObject("parts"); + + + assy1->setCString("name","MicroFrame"); + assy1->setInteger("number",32768); + + subassy1->setCString("name","Legs"); + subassy2->setCString("name","Body"); + subassy1->setInteger("number",1); + subassy2->setInteger("number",2); + + part1->setCString("name","Leg1"); + part2->setCString("name","Leg2"); + part3->setCString("name","Leg3"); + part1->setInteger("number",10001); + part2->setInteger("number",10002); + part3->setInteger("number",10003); + + + part4->setCString("name","MainStrut"); + part5->setCString("name","Brace1"); + part6->setCString("name","Brace2"); + part4->setInteger("number",20001); + part5->setInteger("number",20002); + part6->setInteger("number",20003); + + // assy2 - shallow equal to assy, but not deep equal + + DataObjectPtr assy2 = mdg->create((Type&)tassy); + + DataObjectPtr subassy3 = assy2->createDataObject("subassemblies"); + DataObjectPtr subassy4 = assy2->createDataObject("subassemblies"); + + DataObjectPtr part7 = subassy3->createDataObject("parts"); + DataObjectPtr part8 = subassy3->createDataObject("parts"); + DataObjectPtr part9 = subassy3->createDataObject("parts"); + + DataObjectPtr part10 = subassy4->createDataObject("parts"); + DataObjectPtr part11 = subassy4->createDataObject("parts"); + DataObjectPtr part12 = subassy4->createDataObject("parts"); + + + assy2->setCString("name","MicroFrame"); + assy2->setInteger("number",32768); + + subassy3->setCString("name","Legs"); + subassy4->setCString("name","Body"); + subassy3->setInteger("number",1); + subassy4->setInteger("number",2); + + part7->setCString("name","Leg1"); + part8->setCString("name","Leg2"); + part9->setCString("name","Leg3"); + part7->setInteger("number",10001); + part8->setInteger("number",10002); + part9->setInteger("number",10003); + + + part10->setCString("name","MainStrut"); + part11->setCString("name","Brace1"); + part12->setCString("name","OddBrace2"); + part10->setInteger("number",20001); + part11->setInteger("number",20002); + part12->setInteger("number",20003); + + if (!EqualityHelper::equalShallow(assy1, assy2)) + { + cout << "EQUALITY HELPER TEST - failure at first test" << endl; + } + else + { + cout << "Equality Helper test 1 passed" << endl; + } + if (EqualityHelper::equal(assy1, assy2)) + { + cout << "EQUALITY HELPER TEST - failure at second test" << endl; + } + else + { + cout << "Equality Helper test 2 passed" << endl; + } + + // Now alter assy2 to be deep equal... + + + part12->setCString("name","Brace2"); + + if (!EqualityHelper::equalShallow(assy1, assy2)) + { + cout << "EQUALITY HELPER TEST - failure at third test" << endl; + } + else + { + cout << "Equality Helper test 3 passed" << endl; + } + if (!EqualityHelper::equal(assy1, assy2)) + { + cout << "EQUALITY HELPER TEST - failure at fourth test" << endl; + } + else + { + cout << "Equality Helper test 4 passed" << endl; + } + + // now add a part, so its not deep equal again + DataObjectPtr part13 = subassy4->createDataObject("parts"); + + if (!EqualityHelper::equalShallow(assy1, assy2)) + { + cout << "EQUALITY HELPER TEST - failure at fifth test" << endl; + } + else + { + cout << "Equality Helper test 5 passed" << endl; + } + if (EqualityHelper::equal(assy1, assy2)) + { + cout << "EQUALITY HELPER TEST - failure at sixth test" << endl; + } + else + { + cout << "Equality Helper test 6 passed" << endl; + } + + // now remove that part again... + DataObjectList& dl = subassy4->getList("parts"); + dl.remove(3); + + // should be deep equal again... + + if (!EqualityHelper::equalShallow(assy1, assy2)) + { + cout << "EQUALITY HELPER TEST - failure at seventh test" << endl; + } + else + { + cout << "Equality Helper test 7 passed" << endl; + } + if (!EqualityHelper::equal(assy1, assy2)) + { + cout << "EQUALITY HELPER TEST - failure at eighth test" << endl; + } + else + { + cout << "Equality Helper test 8 passed" << endl; + } + // now make them not shallow equal + assy2->setInteger("number",32767); + + if (EqualityHelper::equalShallow(assy1, assy2)) + { + cout << "EQUALITY HELPER TEST - failure at nineth test" << endl; + } + else + { + cout << "Equality Helper test 9 passed" << endl; + } + if (EqualityHelper::equal(assy1, assy2)) + { + cout << "EQUALITY HELPER TEST - failure at tenth test" << endl; + } + else + { + cout << "Equality Helper test 10 passed" << endl; + } + +} + +void sdotest::cohelpertest() +{ + + // copy and equality helpers + + DataFactoryPtr mdg = DataFactory::getDataFactory(); + + mdg->addType("myspace","Assembly"); + mdg->addType("myspace","SubAssembly"); + mdg->addType("myspace","Part"); + + /* Now add the properties to the types...*/ + + + const Type& tstring = mdg->getType("commonj.sdo","String"); + const Type& tint = mdg->getType("commonj.sdo","Integer"); + const Type& tassy = mdg->getType("myspace","Assembly"); + const Type& tsubassy = mdg->getType("myspace","SubAssembly"); + const Type& tpart = mdg->getType("myspace","Part"); + + + mdg->addPropertyToType(tassy,"name",tstring); + mdg->addPropertyToType(tsubassy,"name",tstring); + mdg->addPropertyToType(tpart,"name",tstring); + + mdg->addPropertyToType(tassy,"number",tint); + mdg->addPropertyToType(tsubassy,"number",tint); + mdg->addPropertyToType(tpart,"number",tint); + + mdg->addPropertyToType(tassy,"subassemblies", tsubassy,true); + mdg->addPropertyToType(tsubassy,"parts", tpart,true); + + + // assy 1 + + DataObjectPtr assy1 = mdg->create((Type&)tassy); + + DataObjectPtr subassy1 = assy1->createDataObject("subassemblies"); + DataObjectPtr subassy2 = assy1->createDataObject("subassemblies"); + + DataObjectPtr part1 = subassy1->createDataObject("parts"); + DataObjectPtr part2 = subassy1->createDataObject("parts"); + DataObjectPtr part3 = subassy1->createDataObject("parts"); + + DataObjectPtr part4 = subassy2->createDataObject("parts"); + DataObjectPtr part5 = subassy2->createDataObject("parts"); + DataObjectPtr part6 = subassy2->createDataObject("parts"); + + + assy1->setCString("name","MicroFrame"); + assy1->setInteger("number",32768); + + subassy1->setCString("name","Legs"); + subassy2->setCString("name","Body"); + subassy1->setInteger("number",1); + subassy2->setInteger("number",2); + + part1->setCString("name","Leg1"); + part2->setCString("name","Leg2"); + part3->setCString("name","Leg3"); + part1->setInteger("number",10001); + part2->setInteger("number",10002); + part3->setInteger("number",10003); + + + part4->setCString("name","MainStrut"); + part5->setCString("name","Brace1"); + part6->setCString("name","Brace2"); + part4->setInteger("number",20001); + part5->setInteger("number",20002); + part6->setInteger("number",20003); + + // first lets shallow copy assy1: + + DataObjectPtr assy2 = CopyHelper::copyShallow(assy1); + + if (strcmp(assy2->getCString("name"),"MicroFrame")) + { + cout << "COPYHELPER shallow copy failed(1)" << endl; + } + else if (assy2->getInteger("number") != 32768) + { + cout << "COPYHELPER shallow copy 1 failed(2)" << endl; + } + else if (assy2->getList("subassemblies").size() != 0) + { + cout << "COPYHELPER shallow copy 1 failed(3)" << endl; + } + else if (assy2->getContainer() != 0) + { + cout << "COPYHELPER shallow copy failed(4)" << endl; + } + else + { + cout << "CopyHelper test1 passed" << endl; + } + + // now deep copy it + + DataObjectPtr assy3 = CopyHelper::copy(assy1); + + if (!EqualityHelper::equal(assy1, assy3)) + { + cout << "COPYHELPER deep copy failed(1)" << endl; + } + else if (assy3->getContainer() != 0) + { + cout << "COPYHELPER deep copy failed(2)" << endl; + } + else + { + cout << "CopyHelper test 2 passed" << endl; + } + +} + + +///////////////////////////////////////////////////////////////////////////// +///test code for serialization........... +///////////////////////////////////////////////////////////////////////////// +// +//bool sdotest::serializeOldSingleValues(int indent, ChangeSummaryPtr cs, DataObjectPtr dol) +//{ +// bool onlySingle = true; +// SettingList& sl = cs->getOldValues(dol); +// if (sl.size() == 0) +// { +// return onlySingle; +// } +// +// for (int k=0;k<indent;k++)cout << " "; +// +// for (int j=0;j< sl.size(); j++) +// { +// if (sl[j].getProperty().isMany()) +// { +// onlySingle = false; +// continue; +// } +// +// cout << " " << sl[j].getProperty().getName() << "="; +// +// switch (sl[j].getProperty().getTypeEnum()) +// { +// case Type::BooleanType: +// cout << "\"" << sl[j].getBooleanValue() << "\""; +// break; +// case Type::ByteType: +// cout << "\"" << sl[j].getByteValue() << "\""; +// break; +// case Type::CharacterType: +// cout << "\"" << sl[j].getCharacterValue() << "\""; +// break; +// case Type::IntegerType: +// cout << "\"" << sl[j].getIntegerValue() << "\""; +// break; +// case Type::ShortType: +// cout << "\"" << sl[j].getShortValue() << "\""; +// break; +// case Type::DoubleType: +// cout << "\"" << sl[j].getDoubleValue() << "\""; +// break; +// case Type::FloatType: +// cout << "\"" << sl[j].getFloatValue() << "\""; +// break; +// case Type::LongType: +// cout << "\"!" << sl[j].getIntegerValue() << "\""; +// break; +// case Type::DateType: +// cout << "\"" << sl[j].getDateValue().ascTime() << "\""; +// break; +// case Type::BigDecimalType: +// case Type::BigIntegerType: +// case Type::StringType: +// case Type::UriType: +// cout << "\"" << sl[j].getCStringValue() << "\""; +// break; +// case Type::BytesType: +// cout << "\"" << sl[j].getCStringValue() << "\""; +// break; +// case Type::OtherTypes: +// case Type::DataObjectType: +// case Type::ChangeSummaryType: +// { +// DataObjectPtr dob = sl[j].getDataObjectValue(); +// if (!dob) +// { +// cout << ""; +// } +// else +// { +// if (cs->isDeleted(dob)) +// { +// cout << "\"" << cs->getOldXpath(dob) << "\""; +// } +// else +// { +// cout << "\"" << dob->objectToXPath() << "\""; +// } +// } +// } +// break; +// default: +// { +// } +// break; +// } +// } +// return onlySingle; +//} +// +// +// +// +//void sdotest::serializeOldManyValues(int indent, ChangeSummaryPtr cs, DataObjectPtr dol) +//{ +// SettingList& sl = cs->getOldValues(dol); +// if (sl.size() == 0) +// { +// return; +// } +// for (int j=0;j< sl.size(); j++) +// { +// if (!sl[j].getProperty().isMany()) continue; +// +// for (int k=0;k<indent;k++)cout << " "; +// +// cout << "<" ; +// cout << sl[j].getProperty().getName() << " "; +// +// switch (sl[j].getProperty().getTypeEnum()) +// { +// case Type::BooleanType: +// cout << " value=\"" << sl[j].getBooleanValue() << "\""; +// break; +// case Type::ByteType: +// cout << " value=\"" << sl[j].getByteValue() << "\""; +// break; +// case Type::CharacterType: +// cout << " value=\"" << sl[j].getCharacterValue() << "\""; +// break; +// case Type::IntegerType: +// cout << " value=\"" << sl[j].getIntegerValue() << "\""; +// break; +// case Type::ShortType: +// cout << " value=\"" << sl[j].getShortValue() << "\""; +// break; +// case Type::DoubleType: +// cout << " value=\"" << sl[j].getDoubleValue() << "\""; +// break; +// case Type::FloatType: +// cout << " value=\"" << sl[j].getFloatValue() << "\""; +// break; +// case Type::LongType: +// cout << " value=\"" << "!" << sl[j].getIntegerValue() << "\""; +// break; +// case Type::DateType: +// cout << " value=\"" << sl[j].getDateValue().getTime() << "\""; +// break; +// case Type::BigDecimalType: +// case Type::BigIntegerType: +// case Type::StringType: +// case Type::UriType: +// cout << " value=\"" << sl[j].getCStringValue() << "\""; +// break; +// case Type::BytesType: +// cout << " value=\"" << sl[j].getCStringValue() << "\""; +// break; +// case Type::OtherTypes: +// case Type::DataObjectType: +// case Type::ChangeSummaryType: +// { +// DataObjectPtr dob = sl[j].getDataObjectValue(); +// if (!dob) +// { +// // what to do?; +// } +// else +// { +// if (cs->isDeleted(dob)) +// { +// // TODO +// cout << " sdo:ref=\"" << "deleted" << "\""; +// } +// else +// { +// cout << " sdo:ref=\"" << dob->objectToXPath() << "\""; +// } +// } +// } +// break; +// default: +// { +// } +// break; +// } // switch +// cout << "/>" << endl; +// } // for +//} +// +// +// +//void sdotest::serializechangesummary(ChangeSummaryPtr cs) +//{ +// changeSummaryHeader(cs); +// +// ChangedDataObjectList& cdol = cs->getChangedDataObjects(); +// +// for (i=0;i< cdol.size();i++) +// { +// if (cs->isModified(cdol[i])) +// { +// changeSummaryChange(cs,cdol[i]); +// } +// } +// +// changeSummaryFooter(); +// +//} +// +/////////////////////////////////////////////////////////////////////////////// +/////end code for serialization........... +/////////////////////////////////////////////////////////////////////////////// +// +// + + +bool sdotest::changeSummaryAttributes(ChangeSummaryPtr cs, DataObjectPtr dol) +{ + bool onlySingle = true; + SettingList& sl = cs->getOldValues(dol); + if (sl.size() == 0) + { + return onlySingle; + } + + for (int j=0;j< sl.size(); j++) + { + if (sl[j].getProperty().isMany()) + { + onlySingle = false; + continue; + } + + cout << " " << sl[j].getProperty().getName() << "=\""; + + if (sl[j].getProperty().getType().isDataType()) + { + changeSummarySetting(sl[j]); + } + else + { + DataObjectPtr dob = sl[j].getDataObjectValue(); + if (dob) + { + if (cs->isDeleted(dob)) + { + cout << cs->getOldXpath(dob); + } + else + { + cout << dob->objectToXPath(); + } + } + } + cout << "\" "; + } + return onlySingle; +} + + +void sdotest::changeSummarySetting(Setting& s) +{ + + switch (s.getProperty().getTypeEnum()) + { + case Type::BooleanType: + cout << s.getCStringValue(); + break; + case Type::ByteType: + cout << s.getByteValue(); + break; + case Type::CharacterType: + cout << s.getCharacterValue(); + break; + case Type::IntegerType: + cout << s.getIntegerValue(); + break; + case Type::ShortType: + cout << s.getShortValue(); + break; + case Type::DoubleType: + cout << s.getDoubleValue(); + break; + case Type::FloatType: + cout << s.getFloatValue(); + break; + case Type::LongType: + cout << s.getIntegerValue(); + break; + case Type::DateType: + cout << s.getDateValue().getTime(); + break; + case Type::BigDecimalType: + case Type::BigIntegerType: + case Type::StringType: + case Type::UriType: + cout << s.getCStringValue(); + break; + case Type::BytesType: + cout << s.getCStringValue(); + break; + default: + break; + } // switch +} + + +void sdotest::changeSummaryElements(int indent, ChangeSummaryPtr cs, DataObjectPtr dob) +{ + SettingList& sl = cs->getOldValues(dob); + + if (sl.size() == 0) + { + // there are no setting for this element. + return; + } + + for (int j=0;j< sl.size(); j++) + { + // single values will have been covered by the attributes. + if (!sl[j].getProperty().isMany()) continue; + + if (sl[j].getProperty().getType().isDataType()) + { + + // indent the line + for (int k=0;k<indent;k++)cout << " "; + + cout << "<" << sl[j].getProperty().getName() << ">\""; + + changeSummarySetting(sl[j]); + + cout << "\"</" << sl[j].getProperty().getName() << ">" << endl; + } // if datatype + else + { + DataObjectPtr dob2 = sl[j].getDataObjectValue(); + if (!dob2) + { + return; + } + if (cs->isDeleted(dob2)) + { + changeSummaryDeletedObject(indent,sl[j].getProperty().getName(), cs,dob2); + } + else + { + // indent the line + for (int k=0;k<indent;k++)cout << " "; + cout << "<" << sl[j].getProperty().getName(); + cout << " sdo:ref=\"" << dob2->objectToXPath() << "\"/>" << endl; + } + } + } // for +} + + + +void sdotest::changeSummaryDeletedObject(int indent, const char* name, ChangeSummaryPtr cs, DataObjectPtr dob) +{ + + bool elements = false; // are there any elements to process? + int ind; + + // indent the line + for (ind=0;ind<indent;ind++)cout << " "; + + cout << "<" << name; + + SettingList& sl = cs->getOldValues(dob); + + if (sl.size() == 0) + { + // there are no setting for this element. + cout << "/>"; + return; + } + + cout << " "; + + // print single valued datatypes as attributes + + for (int j=0;j< sl.size(); j++) + { + // single values will have been covered by the attributes. + if ( sl[j].getProperty().isMany()) + { + elements = true; + continue; + } + if (!sl[j].getProperty().getType().isDataType()) + { + elements = true; + continue; + } + + cout << sl[j].getProperty().getName() << "=\""; + + changeSummarySetting(sl[j]); + + cout << "\" "; + } // for attributes + + if (!elements) + { + cout << "/>" << endl; + return; + } + + // now we are onto the many-values, and dataobject single values. + for (int k=0;k< sl.size(); k++) + { + if ( !sl[k].getProperty().getType().isDataType()) + { + // its a dataobject type + DataObjectPtr dob2 = sl[k].getDataObjectValue(); + if (!dob2) continue; + if (!cs->isDeleted(dob2)) continue; + changeSummaryDeletedObject(indent+1,sl[k].getProperty().getName(),cs,dob2); + } + else + { + // could only be many valued data type + + for (ind=0;ind<indent;ind++)cout << " "; + cout << "<" << sl[k].getProperty().getName() << ">\""; + + changeSummarySetting(sl[k]); + + cout << "</" << sl[k].getProperty().getName() << ">" << endl; + } + } // for attributes + + // indent the line + for (ind=0;ind<indent;ind++)cout << " "; + cout << "</" << name << ">" << endl; +} + + + +void sdotest::changeSummaryHeader(ChangeSummaryPtr cs) +{ + int i; + + ChangedDataObjectList& cdol = cs->getChangedDataObjects(); + + cout << "<changeSummary "; + + if (cs->isLogging()) + { + cout << " logging=\"true\" "; + } + + cout << ">" << endl; + + + for (i=0;i< cdol.size();i++) + { + if (cs->isCreated(cdol[i]) && cdol.getType(i) == ChangedDataObjectList::Change) + { + cout << " <create>"; + // TODO is there an IDREF for this created/deleted object? + DataObject* temp = cdol[i]; + cout << ((DataObject*)temp)->objectToXPath(); + cout << "</create>" << endl; + } + if (cs->isDeleted(cdol[i]) && cdol.getType(i) == ChangedDataObjectList::Delete) + { + cout << " <delete>"; + // TODO is there an IDREF for this created/deleted object? + const char* path = cs->getOldXpath(cdol[i]); + if (path != 0) + { + cout << path; + } + cout << "</delete>" << endl; + } + } +} + +void sdotest::changeSummaryFooter() +{ + cout << "</changeSummary>" << endl; +} + + +void sdotest::changeSummaryChange(int level, ChangeSummaryPtr cs, DataObjectPtr dob) +{ + DataObject* temp = dob; + + // indent by level. + for (int l=0;l<level;l++)cout << " "; + + cout << "<"; + + try + { + cout << temp->getContainmentProperty().getName(); + } + catch (SDORuntimeException e) + { + // the object which was changed has no name, + // so its the root object of a data object tree. + cout << "root"; + } + + cout << " "; + + try + { + cout << "sdo:ref=\"" << temp->objectToXPath() << "\" "; + } + catch (SDORuntimeException e) + { + // TODO there was no xpath - thats not good + } + + // returns true if there were only single values - attributes only. + if (changeSummaryAttributes(cs, temp)) + { + cout << "/>" << endl; + return; + } + + // there are some elements + cout << ">" << endl; + + + changeSummaryElements(level+1, cs, temp); + + + // indent by level. + + for (int m=0;m<level;m++)cout << " "; + cout << "</"; + + try + { + cout << temp->getContainmentProperty().getName(); + } + catch (SDORuntimeException e) + { + // the object which was changed has no name, + // so its the root object of a data object tree. + cout << "root"; + } + + cout << ">" << endl; + +} + + + +void sdotest::serializeChangeSummary(ChangeSummaryPtr cs) +{ + changeSummaryHeader(cs); + + ChangedDataObjectList& cdol = cs->getChangedDataObjects(); + + for (int i=0;i< cdol.size();i++) + { + if (cs->isModified(cdol[i])) + { + changeSummaryChange(1, cs,cdol[i]); + } + } + + changeSummaryFooter(); +} + + +void sdotest::cssave() +{ + + try { + DataFactoryPtr mdg = DataFactory::getDataFactory(); + + XSDHelperPtr xsh = HelperProvider::getXSDHelper(mdg); + xsh->defineFile("company.xsd"); + + //mdg->addType("companyNS","CompanyType"); + //mdg->addType("companyNS","EmployeeType"); + //mdg->addType("companyNS","DepartmentType"); + + /* Now add the properties to the types...*/ + + + 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"); + + + //mdg->addPropertyToType(tcomp,"name",tstring); + // not containment... + //mdg->addPropertyToType(tcomp,"employeeOfTheMonth",temp, false,false,false); + //mdg->addPropertyToType(tcomp,"departments",tdept, true); + //mdg->addPropertyToType(tcomp,"cs",tcs); + + //mdg->addPropertyToType(tdept,"name",tstring); + //mdg->addPropertyToType(tdept,"location",tstring); + //mdg->addPropertyToType(tdept,"number",tstring); + //mdg->addPropertyToType(tdept,"employees",temp,true); + + //mdg->addPropertyToType(temp, "name",tstring); + //mdg->addPropertyToType(temp, "SN", tstring); + //mdg->addPropertyToType(temp, "manager", tbool); + + + // 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); + + ChangeSummaryPtr cs = comp->getChangeSummary(); + + cs->beginLogging(); + + 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); + + dol2.remove(1); // element 1 is Mary + + DataObjectPtr emp5 = mdg->create(temp); + emp5->setCString("name","Bill Withers"); + emp5->setCString("SN","E0005"); + + dol2.append(emp5); + + + comp->setCString("name","MegaCorp"); + comp->setDataObject("employeeOfTheMonth",emp4); + + // silly test - add mary back again + dol2.append(emp2); + + // and why not delete her again? + //dol2.remove(4); + + + + cs->endLogging(); + + //serializeChangeSummary(cs); + + XMLHelperPtr xmh = HelperProvider::getXMLHelper(mdg); + XMLDocumentPtr doc = xmh->createDocument(comp,"companyNS","company"); + xmh->save(doc,"cssave-output.xml"); + } + catch (SDORuntimeException e) + { + cout << "CSSAVE FAILED" << e << endl; + } +} + +void sdotest::cssave2() +{ + + 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","Eastleigh Borough Council"); + + DataObjectPtr dept = mdg->create((Type&)tdept); + DataObjectList& dol = comp->getList("departments"); + dol.append(dept); + + dept->setCString("name","Waste Disposal"); + dept->setCString("location","Botley"); + dept->setCString("number","123"); + + DataObjectPtr emp1 = mdg->create(temp); + DataObjectPtr emp2 = mdg->create(temp); + DataObjectPtr emp3 = mdg->create(temp); + DataObjectPtr emp4 = mdg->create(temp); + DataObjectPtr emp5 = mdg->create(temp); + + emp1->setCString("name","Alphonse Dodet"); + emp1->setCString("SN","E0001"); + + emp2->setCString("name","Bridget Jones"); + emp2->setCString("SN","E0002"); + emp2->setBoolean("manager",true); + + emp3->setCString("name","Colin Thorne"); + emp3->setCString("SN","E0003"); + + emp4->setCString("name","Donald Trump"); + emp4->setCString("SN","E0004"); + + emp5->setCString("name","Eddy the eagle"); + emp5->setCString("SN","E0005"); + + DataObjectList& dol2 = dept->getList("employees"); + dol2.append(emp1); + dol2.append(emp2); + dol2.append(emp3); + dol2.append(emp4); + dol2.append(emp5); + + //comp->setDataObject("employeeOfTheMonth",emp2); + + DataObjectPtr dept2 = mdg->create((Type&)tdept); + dol.append(dept2); + + dept2->setCString("name","Tax Collection"); + dept2->setCString("location","Winchester"); + dept2->setCString("number","666"); + + DataObjectPtr empb1 = mdg->create(temp); + DataObjectPtr empb2 = mdg->create(temp); + DataObjectPtr empb3 = mdg->create(temp); + DataObjectPtr empb4 = mdg->create(temp); + DataObjectPtr empb5 = mdg->create(temp); + + empb1->setCString("name","Arch Meanie"); + empb1->setCString("SN","D0001"); + + empb2->setCString("name","Boris the Spider"); + empb2->setCString("SN","D0002"); + empb2->setBoolean("manager",true); + + empb3->setCString("name","Cash Hoarder"); + empb3->setCString("SN","D0003"); + + empb4->setCString("name","Dean Giyatoss"); + empb4->setCString("SN","D0004"); + + empb5->setCString("name","Ebenezer Scrooge"); + empb5->setCString("SN","D0005"); + + DataObjectList& dol3 = dept2->getList("employees"); + dol3.append(empb1); + dol3.append(empb2); + dol3.append(empb3); + dol3.append(empb4); + dol3.append(empb5); + + ChangeSummaryPtr cs = comp->getChangeSummary(); + + cs->beginLogging(); + + // start by deleting a few employees from dept 1 + + dol2.remove(1); // B + dol2.remove(1); // C + dol2.remove(1); // D + + // Now delete the tax collectors as a whole + + dol.remove(1); + + // now perhaps add back one of the employees + + dol2.append(emp3); // C + + comp->setCString("name","MegaCorp"); + + try { + comp->setDataObject("employeeOfTheMonth",emp4); + cout << "THIS ISNT RIGHT - emp4 was nolt in the tree" << endl; + } + catch (SDORuntimeException e) + { + } + + comp->setDataObject("employeeOfTheMonth",emp5); + + cs->endLogging(); + + + XMLHelperPtr xmh = HelperProvider::getXMLHelper(mdg); + XMLDocumentPtr doc = xmh->createDocument(comp,"companyNS","company"); + xmh->save(doc,"cssave2-output.xml"); + } + catch (SDORuntimeException e) + { + cout << "CSSAVE FAILED" << e << endl; + } +} + +void sdotest::bug45933() +{ + + try { + DataFactoryPtr mdg = DataFactory::getDataFactory(); + + + mdg->addType("companyNS","CompanyType"); + mdg->addType("companyNS","WombatType"); + + /* Now add the properties to the types...*/ + + + 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& twom = mdg->getType("companyNS","WombatType"); + + + mdg->addPropertyToType(tcomp,"name",tstring); + mdg->addPropertyToType(tcomp,"bools",tbool, true); + mdg->addPropertyToType(tcomp,"woms",twom, true); + mdg->addPropertyToType(tcomp,"cs",tcs); + + + // create a graph, then save it + + DataObjectPtr comp = mdg->create((Type&)tcomp); + comp->setCString("name","Bug45933"); + + ChangeSummaryPtr cs = comp->getChangeSummary(); + + cs->beginLogging(); + + DataObjectList& dol = comp->getList("bools"); + dol.append(false); + dol.remove(0); + DataObjectPtr awom = mdg->create((Type&)twom); + DataObjectList& dol2 = comp->getList("woms"); + dol2.append(awom); + dol2.remove(0); + + cs->endLogging(); + + dumpchangesummary(cs); + + XMLHelperPtr xmh = HelperProvider::getXMLHelper(mdg); + XMLDocumentPtr doc = xmh->createDocument(comp,"companyNS","company"); + xmh->save(doc,"bug45933-output.xml"); + } + catch (SDORuntimeException e) + { + cout << "BUG45933 FAILED" << endl << e << endl; + } +} + +void sdotest::b46617() +{ + + try { + DataFactoryPtr mdg = DataFactory::getDataFactory(); + + //XSDHelperPtr xsh = HelperProvider::getXSDHelper(mdg); + //xsh->defineFile("b46617.xsd"); + mdg->addType("companyNS","CompanyType"); + mdg->addType("companyNS","DepartmentType"); + mdg->addType("companyNS","EmployeeType"); + + + + 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"); + + mdg->addPropertyToType(tcomp,"name",tstring); + mdg->addPropertyToType(tcomp,"departments",tdept,true,false,true); + mdg->addPropertyToType(tcomp,"employeeOfTheMonth",temp,false,false,false); + mdg->addPropertyToType(tcomp,"CEO",temp,false,false,true); + + mdg->addPropertyToType(tdept,"employees",temp,true,false,true); + mdg->addPropertyToType(tdept,"name",tstring,false,false,true); + mdg->addPropertyToType(tdept,"location",tstring,false,false,true); + mdg->addPropertyToType(tdept,"number",tstring,false,false,true); + + mdg->addPropertyToType(temp,"name",tstring,false,false,true); + mdg->addPropertyToType(temp,"SN",tstring,false,false,true); + mdg->addPropertyToType(temp,"manager",tbool,false,false,true); + + // create a graph, then save it + + DataObjectPtr comp = mdg->create((Type&)tcomp); + comp->setCString("name","Eastleigh Borough Council"); + + DataObjectPtr dept = mdg->create((Type&)tdept); + DataObjectList& dol = comp->getList("departments"); + dol.append(dept); + + dept->setCString("name","Waste Disposal"); + dept->setCString("location","Botley"); + dept->setCString("number","123"); + + DataObjectPtr emp1 = mdg->create(temp); + DataObjectPtr emp2 = mdg->create(temp); + DataObjectPtr emp3 = mdg->create(temp); + + emp1->setCString("name","Alphonse Dodet"); + emp1->setCString("SN","E0001"); + + emp2->setCString("name","Bridget Jones"); + emp2->setCString("SN","E0002"); + emp2->setBoolean("manager",true); + + emp3->setCString("name","Carl Marx"); + emp3->setCString("SN","E0003"); + + comp->setDataObject("CEO",emp2); + + DataObjectList& dol2 = dept->getList("employees"); + dol2.append(emp1); + //dol2.append(emp2); + dol2.append(emp3); + + comp->setDataObject("employeeOfTheMonth",emp2); + + XSDHelperPtr xmd = HelperProvider::getXSDHelper(mdg); + xmd->generateFile(mdg->getTypes(), + "b46617.xsd","companyNS"); + + + XMLHelperPtr xmh = HelperProvider::getXMLHelper(mdg); + XMLDocumentPtr doc = xmh->createDocument(comp,"companyNS","company"); + xmh->save(doc,"b46617.xml"); + + // now try loading the xml, using the same schema, and see if we get the + // same answer + + XMLHelperPtr myXMLHelper = HelperProvider::getXMLHelper(mdg); + XMLDocumentPtr myXMLDocument = myXMLHelper->loadFile("b46617.xml", "companyNS"); + DataObjectPtr newdob = myXMLDocument->getRootDataObject(); + + cout << "EOMS name is " + << newdob->getDataObject("employeeOfTheMonth")->getCString("name") + << endl; + + + } + catch (SDORuntimeException e) + { + cout << "b46617 failed" << e << endl; + } +} + +void sdotest::b46617b() +{ + + try { + DataFactoryPtr mdg = DataFactory::getDataFactory(); + + XSDHelperPtr xsh = HelperProvider::getXSDHelper(mdg); + xsh->defineFile("b46617b.xsd"); + + XMLHelperPtr myXMLHelper = HelperProvider::getXMLHelper(mdg); + XMLDocumentPtr myXMLDocument = myXMLHelper->loadFile("b46617b.xml", "companyNS"); + DataObjectPtr newdob = myXMLDocument->getRootDataObject(); + + cout << "EOMS name is " + << newdob->getDataObject("employeeOfTheMonth")->getCString("name") + << endl; + + + } + catch (SDORuntimeException e) + { + cout << "b46617b failed" << e << endl; + } +} + +void sdotest::notfound() +{ + + DataFactoryPtr mdg = DataFactory::getDataFactory(); + try { + + XSDHelperPtr xsh = HelperProvider::getXSDHelper(mdg); + xsh->defineFile("not_present.xsd"); + } + catch (SDOFileNotFoundException e) + { + cout << "NotFound threw correct exception " << endl; + } + + catch (SDORuntimeException e) + { + cout << "NOTFOUND THREW THE WRONG EXCEPTION" << e << endl; + } + + try { + XMLHelperPtr myXMLHelper = HelperProvider::getXMLHelper(mdg); + XMLDocumentPtr myXMLDocument = myXMLHelper->loadFile("not-present.xml", "companyNS"); + + } + catch (SDOFileNotFoundException ee) + { + cout << "NotFound threw the correct exception" << endl; + } + + catch (SDORuntimeException e) + { + cout << "NOTFOUND THREW THE WRONG EXCEPTION" << e << endl; + } +} + +void sdotest::csload() +{ + try + { + + DataFactoryPtr mdg = DataFactory::getDataFactory(); + XSDHelperPtr xsh = HelperProvider::getXSDHelper(mdg); + xsh->defineFile("company.xsd"); + + cout << "TYPES LOADED FROM COMPANY XSD" << endl; + + TypeList tl = mdg->getTypes(); + for (int i=0;i< tl.size(); i++) + { + cout << tl[i].getURI() << ":" << tl[i].getName() << endl; + } + + XMLHelperPtr myXMLHelper = HelperProvider::getXMLHelper(mdg); + XMLDocumentPtr myXMLDocument = myXMLHelper->loadFile("cssave-output.xml", "companyNS"); + //myXMLDocument->setRootElementName("company"); + //myXMLHelper->save(myXMLDocument,"csload-output.xml"); + myXMLHelper->save(myXMLDocument->getRootDataObject(), + 0, "company", "csload-output.xml"); + } + catch (SDORuntimeException e) + { + cout << "CSLOAD FAILED" << e << endl; + } + +} + +void sdotest::testsubsload() +{ + cout << "TEST: TestSubsLoad ==========================================" << endl; + try + { + + DataFactoryPtr mdg = DataFactory::getDataFactory(); + XSDHelperPtr xsh = HelperProvider::getXSDHelper(mdg); + xsh->defineFile("companysubs.xsd"); + + //cout << "TYPES LOADED FROM COMPANYSUBS XSD" << endl; + + //TypeList tl = mdg->getTypes(); + //for (int i=0;i< tl.size(); i++) + //{ + // cout << tl[i].getURI() << ":" << tl[i].getName() << endl; + //} + + // so now we should be able to put book or a magazine into + // the publication under company... + + const Type& tstring = mdg->getType("commonj.sdo","String"); + const Type& tcomp = mdg->getType("companyNS","CompanyType"); + const Type& book = mdg->getType("companyNS","BookType"); + const Type& mag = mdg->getType("companyNS","MagazineType"); + const Type& pub = mdg->getType("companyNS","PublicationType"); + + + // create a graph, then save it + + DataObjectPtr comp = mdg->create((Type&)tcomp); + comp->setCString("name","Puflet Publishing"); + + + DataObjectPtr book1 = mdg->create(book); + book1->setCString("author","Mr P B Writer"); + // inherted from publication + book1->setCString("title","Nowhere Man"); + + DataObjectPtr mag1 = mdg->create(mag); + mag1->setCString("editor","Mr B Picky"); + // inherited from publication + mag1->setCString("title","Bionicle Weekly"); + + DataObjectPtr pub1 = mdg->create(pub); + pub1->setCString("title","Noddy In Toyland"); + + + // publication should accept any of them... + + comp->setDataObject("Publication",pub1); + const Type& tpub1 = comp->getDataObject("Publication")->getType(); + cout << "Publication is of type " << tpub1.getName() << endl; + + comp->setDataObject("Publication",book1); + const Type& tpub2 = comp->getDataObject("Publication")->getType(); + cout << "Publication is of type " << tpub2.getName() << endl; + + comp->setDataObject("Publication",mag1); + const Type& tpub3 = comp->getDataObject("Publication")->getType(); + cout << "Publication is of type " << tpub3.getName() << endl; + + // should be able to address publication as book or magazine + + comp->setDataObject("Book",book1); + const Type& tpub4 = comp->getDataObject("Book")->getType(); + cout << "Book is of type " << tpub4.getName() << endl; + + comp->setDataObject("Magazine",mag1); + const Type& tpub5 = comp->getDataObject("Magazine")->getType(); + cout << "Magazine is of type " << tpub5.getName() << endl; + + } + catch (SDORuntimeException e) + { + cout << "ERROR in TeseSubsLoad" << e << endl; + } + cout << "END TEST: TestSubsLoad ======================================" << endl; +} + +void sdotest::testSCA() +{ + cout << "TEST: TestSCA ==========================================" << endl; + try + { + + DataFactoryPtr mdg = DataFactory::getDataFactory(); + XSDHelperPtr xsh = HelperProvider::getXSDHelper(mdg); + xsh->defineFile("sca.xsd"); + + } + catch (SDORuntimeException e) + { + cout << "ERROR in TeseSCA" << e << endl; + } + cout << "END TEST: TestSCA ======================================" << endl; +} + +void sdotest::testabstract() +{ + cout << "TEST: TestAbstract ==========================================" << endl; + try + { + + DataFactoryPtr mdg = DataFactory::getDataFactory(); + XSDHelperPtr xsh = HelperProvider::getXSDHelper(mdg); + xsh->defineFile("companyabs.xsd"); + + //cout << "TYPES LOADED FROM COMPANYABS XSD" << endl; + + //TypeList tl = mdg->getTypes(); + //for (int i=0;i< tl.size(); i++) + //{ + // cout << tl[i].getURI() << ":" << tl[i].getName() << endl; + //} + + // so now we should be able to put book or a magazine into + // the publication under company... + + const Type& tstring = mdg->getType("commonj.sdo","String"); + const Type& tcomp = mdg->getType("companyNS","CompanyType"); + const Type& book = mdg->getType("companyNS","BookType"); + const Type& mag = mdg->getType("companyNS","MagazineType"); + const Type& pub = mdg->getType("companyNS","PublicationType"); + + + // create a graph, then save it + + DataObjectPtr comp = mdg->create((Type&)tcomp); + comp->setCString("name","Puflet Publishing"); + + // should be allowed... + DataObjectPtr book1 = mdg->create(book); + book1->setCString("author","Mr P B Writer"); + // inherted from publication + book1->setCString("title","Nowhere Man"); + + DataObjectPtr mag1 = mdg->create(mag); + mag1->setCString("editor","Mr B Picky"); + // inherited from publication + mag1->setCString("title","Bionicle Weekly"); + + try { + DataObjectPtr pub1 = mdg->create(pub); + pub1->setCString("title","Noddy In Toyland"); + } + catch (SDOUnsupportedOperationException e) + { + cout << "Normal unsupportedoperation for creation of abstract type" << endl; + } + + + // publication should accept books and magazines... + + comp->setDataObject("Publication",book1); + const Type& tpub2 = comp->getDataObject("Publication")->getType(); + cout << "Publication is of type " << tpub2.getName() << endl; + + comp->setDataObject("Publication",mag1); + const Type& tpub3 = comp->getDataObject("Publication")->getType(); + cout << "Publication is of type " << tpub3.getName() << endl; + + // should be able to address publication as book or magazine + + comp->setDataObject("Book",book1); + const Type& tpub4 = comp->getDataObject("Book")->getType(); + cout << "Book is of type " << tpub4.getName() << endl; + + comp->setDataObject("Magazine",mag1); + const Type& tpub5 = comp->getDataObject("Magazine")->getType(); + cout << "Magazine is of type " << tpub5.getName() << endl; + + } + catch (SDORuntimeException e) + { + cout << "ERROR in TestAbstract" << e << endl; + } + cout << "END TEST: TestAbstract ======================================" << endl; +} + +void sdotest::testOpen() +{ + cout << "TEST: TestOpen ==========================================" << endl; + //try + //{ + + DataFactoryPtr mdg = DataFactory::getDataFactory(); + + + mdg->addType("companyNS","CompanyType"); + // employee will be an open type... + mdg->addType("companyNS","EmployeeType", /*seq*/false, + /*open*/true, + /*abs */ false, + /*data*/ false); + + mdg->addType("companyNS","DepartmentType"); + + /* Now add the properties to the types...*/ + + + 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"); + + + mdg->addPropertyToType(tcomp,"name",tstring); + // not containment... + mdg->addPropertyToType(tcomp,"employeeOfTheMonth",temp, false,false,false); + mdg->addPropertyToType(tcomp,"departments",tdept, true); + mdg->addPropertyToType(tcomp,"cs",tcs); + + mdg->addPropertyToType(tdept,"name",tstring); + mdg->addPropertyToType(tdept,"location",tstring); + mdg->addPropertyToType(tdept,"number",tstring); + mdg->addPropertyToType(tdept,"employees",temp,true); + + mdg->addPropertyToType(temp, "name",tstring); + mdg->addPropertyToType(temp, "SN", tstring); + mdg->addPropertyToType(temp, "manager", tbool); + + + + 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","Albert"); + emp1->setCString("SN","E0001"); + + emp2->setCString("name","Boris"); + emp2->setCString("SN","E0002"); + emp2->setBoolean("manager",true); + + emp3->setCString("name","Carl"); + emp3->setCString("SN","E0003"); + + // now we should be able to add extra properties to employees, + // and get them back again... + + + emp1->setCString("openstring","Value Of Open String"); + emp1->setBoolean("openboolean",true); + + const char* c = emp1->getCString("openstring"); + + cout << "Open Type string value: " << c << endl; + + bool b = emp1->getBoolean("openboolean"); + + cout << "Open Type boolean value: " << b << endl; + + // unknown list type at present.. + DataObjectList& dl = emp1->getList("opentypelist"); + + int i = 45; + dl.append((short)i); // now the list must be primitive + + // we should now have instance properties + PropertyList pl = emp1->getType().getProperties(); + + for (i=0;i<pl.size();i++) + { + cout << "EMP1 type property: " << pl[i].getName() << "( many? " << + pl[i].isMany() << ")" << " of type " << + pl[i].getType().getName() << endl; + } + + PropertyList pli = emp1->getInstanceProperties(); + + for (i=0;i<pli.size();i++) + { + cout << "EMP1 inst property: " << pli[i].getName() << "( many? " << + pli[i].isMany() << ")" << " of type " << + pli[i].getType().getName() << endl; + } + + // now unset them and see them disappear - what happens to the indices? + + emp1->unset("openstring"); + + PropertyList plk = emp1->getInstanceProperties(); + + for (i=0;i<plk.size();i++) + { + cout << "EMP1 inst property: " << plk[i].getName() << "( many? " << + plk[i].isMany() << ")" << " of type " << + plk[i].getType().getName() << endl; + } + + emp1->unset("openboolean"); + + dl.remove(0); // so is this list gone, or empty - I vote for still there. + + PropertyList pll = emp1->getInstanceProperties(); + for (i=0;i<pll.size();i++) + { + cout << "EMP1 inst property: " << pll[i].getName() << "( many? " << + pll[i].isMany() << ")" << " of type " << + pll[i].getType().getName() << endl; + } + + emp1->unset("opentypelist"); + + // now I vote for gone... + + PropertyList plm = emp1->getInstanceProperties(); + for (i=0;i<plm.size();i++) + { + cout << "EMP1 inst property: " << plm[i].getName() << "( many? " << + plm[i].isMany() << ")" << " of type " << + plm[i].getType().getName() << endl; + } + + //} + //catch (SDORuntimeException e) + //{ + // cout << "ERROR in TestOpen" << e << endl; + //} + cout << "END TEST: TestOpen ======================================" << endl; +} + +void sdotest::saveOpen() +{ + cout << "TEST: SaveOpen ==========================================" << endl; + try + { + + DataFactoryPtr mdg = DataFactory::getDataFactory(); + + + mdg->addType("companyNS","CompanyType"); + // employee will be an open type... + mdg->addType("companyNS","EmployeeType", /*seq*/false, + /*open*/true, + /*abs */ false, + /*data*/ false); + + mdg->addType("companyNS","DepartmentType"); + + mdg->addType("companyNS","OpenType"); + + /* Now add the properties to the types...*/ + + + 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"); + const Type& topen = mdg->getType("companyNS","OpenType"); + + + mdg->addPropertyToType(tcomp,"name",tstring); + // not containment... + mdg->addPropertyToType(tcomp,"employeeOfTheMonth",temp, false,false,false); + mdg->addPropertyToType(tcomp,"departments",tdept, true); + mdg->addPropertyToType(tcomp,"cs",tcs); + + mdg->addPropertyToType(tdept,"name",tstring); + mdg->addPropertyToType(tdept,"location",tstring); + mdg->addPropertyToType(tdept,"number",tstring); + mdg->addPropertyToType(tdept,"employees",temp,true); + + mdg->addPropertyToType(temp, "name",tstring); + mdg->addPropertyToType(temp, "SN", tstring); + mdg->addPropertyToType(temp, "manager", tbool); + + mdg->setAlias("companyNS","CompanyType","TheFirm"); + mdg->setAlias("companyNS","CompanyType","departments","TheDepartments"); + mdg->setAlias("companyNS","CompanyType","departments","MYDepartments"); + mdg->setAlias("companyNS","CompanyType","TheBigFirm"); + + mdg->addPropertyToType(topen,"name",tstring); + + DataObjectPtr comp = mdg->create((Type&)tcomp); + comp->setCString("name","ACME"); + + DataObjectPtr dept = mdg->create((Type&)tdept); + DataObjectList& dol = comp->getList("departments"); + dol.append(dept); + + ChangeSummaryPtr cs = comp->getChangeSummary(); + + cs->beginLogging(); + + dept->setCString("name","Advanced Technologies"); + dept->setCString("location","NY"); + dept->setCString("number","123"); + + DataObjectList& emps = dept->getList("employees"); + + DataObjectPtr emp1 = mdg->create(temp); + DataObjectPtr emp2 = mdg->create(temp); + DataObjectPtr emp3 = mdg->create(temp); + + emps.append(emp1); + emps.append(emp2); + emps.append(emp3); + + emp1->setCString("name","Albert"); + emp1->setCString("SN","E0001"); + + emp2->setCString("name","Boris"); + emp2->setCString("SN","E0002"); + emp2->setBoolean("manager",true); + + emp3->setCString("name","Carl"); + emp3->setCString("SN","E0003"); + + // now we should be able to add extra properties to employees, + // and get them back again... + + + emp1->setCString("openstring","Value Of Open String"); + emp1->setBoolean("openboolean",true); + + const char* c = emp1->getCString("openstring"); + + cout << "Open Type string value: " << c << endl; + + bool b = emp1->getBoolean("openboolean"); + + cout << "Open Type boolean value: " << b << endl; + + // unknown list type at present.. + DataObjectList& dl = emp1->getList("openintlist"); + + int i = 45; + dl.append((short)i); // now the list must be primitive and short!! + + // unknown list type at present.. + DataObjectList& dl2 = emp1->getList("opendataobjectlist"); + + DataObjectPtr myopen = mdg->create("companyNS","OpenType"); + myopen->setCString("name","MyOpenName"); + dl2.append(myopen); // now the list must be of data objects + + + // now a single valued data object - should have an xsi:type + emp1->setDataObject("opendataobject", myopen); + + + cs->endLogging(); + + dumpchangesummary(cs); + + XSDHelperPtr xdh = HelperProvider::getXSDHelper(mdg); + + xdh->generateFile(mdg->getTypes(), + "saveopen-output.xsd","companyNS"); + + XMLHelperPtr xmh = HelperProvider::getXMLHelper(mdg); + XMLDocumentPtr doc = xmh->createDocument(comp,"companyNS","company"); + xmh->save(doc,"saveopen-output.xml"); + + } + catch (SDORuntimeException e) + { + cout << "ERROR in SaveOpen" << e << endl; + } + cout << "END TEST: SaveOpen ======================================" << endl; +} + +void sdotest::loadOpen() +{ + cout << "TEST: LoadOpen ==========================================" << endl; + try + { + + DataFactoryPtr mdg = DataFactory::getDataFactory(); + XSDHelperPtr xsh = HelperProvider::getXSDHelper(mdg); + xsh->defineFile("saveopen-output.xsd"); + + + //cout << "TYPES LOADED FROM COMPANY XSD" << endl; + //int i; + //TypeList tl = mdg->getTypes(); + //for (i=0;i< tl.size(); i++) + //{ + // cout << tl[i].getURI() << ":" << tl[i].getName() << endl; + //} + + XMLHelperPtr myXMLHelper = HelperProvider::getXMLHelper(mdg); + + + XMLDocumentPtr myXMLDocument = myXMLHelper->loadFile("partial.xml", "companyNS"); + + + + // so, we now expect that the openboolean and openstring props will + // be of type boolean and Bytes, and the openlist will be a list of integers. + // The dataobjectlist an dataobject will be of the correct OpenType + + // we need a test for data objects, and that we are writing out xsi:type + // correctly. + DataObjectPtr comp = myXMLDocument->getRootDataObject(); + DataObjectList& dl = comp->getList("departments"); + DataObjectPtr dept = dl[0]; + DataObjectList& dl2 = dept->getList("employees"); + DataObjectPtr emp = dl2[0]; + + if (strcmp(emp->getProperty("openboolean").getType().getName(), + "Boolean")) + { + cout << "OpenLoad failure - bool property not boolean" << endl; + + } + if (emp->getBoolean("openboolean") != true) + { + cout << "OpenLoad failure - bool property not true" << endl; + } + + if (strcmp(emp->getProperty("openstring").getType().getName(), + "Bytes")) + { + cout << "OpenLoad failure - bytes property not bytes" << endl; + + } + if (strcmp(emp->getCString("openstring"),"Value Of Open String")) + { + cout << "OpenLoad failure - string value is" << + emp->getCString("openstring") << endl; + } + + + DataObjectList& dl3 = emp->getList("openintlist"); + + if (strcmp(emp->getProperty("openintlist").getType().getName(), + "Short")) + { + cout << "OpenLoad failure - IntegerList not Short " << + emp->getProperty("openintlist").getType().getName() << endl; + } + + if (dl3.getInteger(0) != 45) + { + cout << "OpenLoad failure - Integer value is" << + dl.getInteger(0) << endl; + } + + if (strcmp(emp->getProperty("opendataobjectlist").getType().getName(), + "OpenType")) + { + cout << "OpenLoad failure - OpenTypeList not OpenType" << endl; + } + + DataObjectList& dl4 = emp->getList("opendataobjectlist"); + + if (strcmp(dl4[0]->getCString("name"),"MyOpenName")) + { + cout << "OpenLoad failure - list element name is " << + dl4[0]->getCString("name") << endl; + } + + if (strcmp(emp->getProperty("opendataobject").getType().getName(), + "OpenType")) + { + cout << "OpenLoad failure - OpenType not OpenType" << endl; + } + + DataObjectPtr dob2 = emp->getDataObject("opendataobject"); + + if (strcmp(dob2->getCString("name"),"MyOpenName")) + { + cout << "OpenLoad failure - open value name is " << + dob2->getCString("name") << endl; + } + + + myXMLHelper->save(myXMLDocument->getRootDataObject(), + 0, "company", "loadload-output.xml"); + + + } + catch (SDORuntimeException e) + { + cout << "LoadOpen FAILED" << e << endl; + } + +} + +void sdotest::loadOpenNS() +{ + cout << "TEST: LoadOpenNS ==========================================" << endl; + try + { + + DataFactoryPtr mdg = DataFactory::getDataFactory(); + XSDHelperPtr xsh = HelperProvider::getXSDHelper(mdg); + xsh->defineFile("openloadNS.xsd"); + xsh->defineFile("openloadNS2.xsd"); + + + //cout << "TYPES LOADED FROM COMPANY XSD" << endl; + //int i; + //TypeList tl = mdg->getTypes(); + //for (i=0;i< tl.size(); i++) + //{ + // cout << tl[i].getURI() << ":" << tl[i].getName() << endl; + //} + + XMLHelperPtr myXMLHelper = HelperProvider::getXMLHelper(mdg); + + + XMLDocumentPtr myXMLDocument = myXMLHelper->loadFile("openloadNS.xml", "companyNS"); + + + + // so, we now expect that the openboolean and openstring props will + // be of type boolean and Bytes, and the openlist will be a list of integers. + // The dataobjectlist an dataobject will be of the correct OpenType + + // we need a test for data objects, and that we are writing out xsi:type + // correctly. + DataObjectPtr comp = myXMLDocument->getRootDataObject(); + DataObjectList& dl = comp->getList("departments"); + DataObjectPtr dept = dl[0]; + DataObjectList& dl2 = dept->getList("employees"); + DataObjectPtr emp = dl2[0]; + + if (strcmp(emp->getProperty("openboolean").getType().getName(), + "Boolean")) + { + cout << "OpenLoadNS failure - bool property not boolean" << endl; + + } + if (emp->getBoolean("openboolean") != true) + { + cout << "OpenLoadNS failure - bool property not true" << endl; + } + + if (strcmp(emp->getProperty("openstring").getType().getName(), + "Bytes")) + { + cout << "OpenLoadNS failure - bytes property not bytes" << endl; + + } + if (strcmp(emp->getCString("openstring"),"Value Of Open String")) + { + cout << "OpenLoadNS failure - string value is" << + emp->getCString("openstring") << endl; + } + + + DataObjectList& dl3 = emp->getList("openintlist"); + + if (strcmp(emp->getProperty("openintlist").getType().getName(), + "Short")) + { + cout << "OpenLoadNS failure - IntegerList not Short " << + emp->getProperty("openintlist").getType().getName() << endl; + } + + if (dl3.getInteger(0) != 45) + { + cout << "OpenLoadNS failure - Integer value is" << + dl.getInteger(0) << endl; + } + + + + myXMLHelper->save(myXMLDocument->getRootDataObject(), + 0, "company", "openloadNSout.xml"); + + + // now try exactly the same, but with NS which doesnt exist + XMLDocumentPtr myXMLDocument2 = myXMLHelper->loadFile("openloadNS2.xml", "companyNS"); + + + + // so, we now expect that the openboolean and openstring props will + // be of type boolean and Bytes, and the openlist will be a list of integers. + // The dataobjectlist an dataobject will be of the correct OpenType + + // we need a test for data objects, and that we are writing out xsi:type + // correctly. + DataObjectPtr comp2 = myXMLDocument2->getRootDataObject(); + DataObjectList& dld = comp2->getList("departments"); + DataObjectPtr dept2 = dld[0]; + DataObjectList& dl22 = dept2->getList("employees"); + DataObjectPtr emp2 = dl22[0]; + + if (strcmp(emp2->getProperty("openboolean").getType().getName(), + "Bytes")) + { + cout << "OpenLoadNS2 failure - bool property not bytes" << endl; + + } + if (emp2->getBoolean("openboolean") != true) + { + cout << "OpenLoadNS2 failure - bool property not true" << endl; + } + + if (strcmp(emp2->getProperty("openstring").getType().getName(), + "Bytes")) + { + cout << "OpenLoadNS2 failure - bytes property not bytes" << endl; + + } + if (strcmp(emp2->getCString("openstring"),"Value Of Open String")) + { + cout << "OpenLoadNS failure - string value is" << + emp2->getCString("openstring") << endl; + } + + + DataObjectList& dl32 = emp2->getList("openintlist"); + + if (strcmp(emp2->getProperty("openintlist").getType().getName(), + "Bytes")) + { + cout << "OpenLoadNS2 failure - IntegerList not Bytes " << + emp2->getProperty("openintlist").getType().getName() << endl; + } + + if (dl32.getInteger(0) != 45) + { + cout << "OpenLoadNS2 failure - Integer value is" << + dl32.getInteger(0) << endl; + } + + + } + catch (SDORuntimeException e) + { + cout << "LoadOpenNS FAILED" << e << endl; + } + +} + +void sdotest::loadManyOpen() +{ + cout << "TEST: LoadManyOpen ==========================================" << endl; + try + { + + DataFactoryPtr mdg = DataFactory::getDataFactory(); + XSDHelperPtr xsh = HelperProvider::getXSDHelper(mdg); + xsh->defineFile("many.xsd"); + + + //cout << "TYPES LOADED FROM COMPANY XSD" << endl; + //int i; + //TypeList tl = mdg->getTypes(); + //for (i=0;i< tl.size(); i++) + //{ + // cout << tl[i].getURI() << ":" << tl[i].getName() << endl; + //} + + XMLHelperPtr myXMLHelper = HelperProvider::getXMLHelper(mdg); + + + XMLDocumentPtr myXMLDocument = myXMLHelper->loadFile("many.xml", "companyNS"); + + + + // so, we now expect that the openboolean and openstring props will + // be of type boolean and Bytes, and the openlist will be a list of integers. + // The dataobjectlist an dataobject will be of the correct OpenType + + // we need a test for data objects, and that we are writing out xsi:type + // correctly. + DataObjectPtr comp = myXMLDocument->getRootDataObject(); + DataObjectList& dl = comp->getList("departments"); + DataObjectPtr dept = dl[0]; + DataObjectList& dl2 = dept->getList("employees"); + DataObjectPtr emp = dl2[0]; + + + DataObjectList& dl3 = emp->getList("openlist"); + + if (strcmp(emp->getProperty("openlist").getType().getName(), + "Bytes")) + { + cout << "OpenManyLoad failure - BytesList not Bytes " << + emp->getProperty("openlist").getType().getName() << endl; + } + + if (dl3.size() != 3) + { + cout << "OpenManyLoad failure - size is " << + dl3.size() << endl; + } + + for (int i=0;i< dl3.size();i++) + { + cout << "Value:" << + dl3.getCString(i) << endl; + } + + } + catch (SDORuntimeException e) + { + cout << "LoadOpen FAILED" << e << endl; + } + +} + +void sdotest::csload2() +{ + cout << "TEST: CSLoad2 ===============================================" << endl; + try + { + + DataFactoryPtr mdg = DataFactory::getDataFactory(); + XSDHelperPtr xsh = HelperProvider::getXSDHelper(mdg); + xsh->defineFile("company.xsd"); + + //cout << "TYPES LOADED FROM COMPANY XSD" << endl; + + //TypeList tl = mdg->getTypes(); + //for (int i=0;i< tl.size(); i++) + //{ + // cout << tl[i].getURI() << ":" << tl[i].getName() << endl; + //} + + XMLHelperPtr myXMLHelper = HelperProvider::getXMLHelper(mdg); + XMLDocumentPtr myXMLDocument = myXMLHelper->loadFile("cssave2-output.xml", "companyNS"); + myXMLHelper->save(myXMLDocument->getRootDataObject(), + 0, "company", "csload2-output.xml"); + XMLDocumentPtr myXMLDocument2 = myXMLHelper->loadFile("csload2-output.xml", "companyNS"); + myXMLHelper->save(myXMLDocument2->getRootDataObject(), + 0, "company", "csload3-output.xml"); + } + catch (SDORuntimeException e) + { + cout << "ERROR in CsLoad2" << e << endl; + } + cout << "END TEST: CSLoad2 ===========================================" << endl; + +} + + + +void sdotest::setnull() +{ + +// try { + DataFactoryPtr mdg = DataFactory::getDataFactory(); + + mdg->addType("NullNS","NullMainType"); + mdg->addType("NullNS","NullSubType"); + + /* Now add the properties to the types...*/ + + const Type& tstring = mdg->getType("commonj.sdo","String"); + const Type& tint = mdg->getType("commonj.sdo","Integer"); + const Type& tbool = mdg->getType("commonj.sdo","Boolean"); + const Type& tcs = mdg->getType("commonj.sdo","ChangeSummary"); + const Type& tmain = mdg->getType("NullNS","NullMainType"); + const Type& tsub = mdg->getType("NullNS","NullSubType"); + + + mdg->addPropertyToType(tmain,"name",tstring); + mdg->addPropertyToType(tmain,"subs",tsub, true); // many + mdg->addPropertyToType(tmain,"asub",tsub, false); // single + mdg->addPropertyToType(tmain,"bsub",tsub, false); // single + + mdg->addPropertyToType(tmain,"cs",tcs); // change summary + + mdg->addPropertyToType(tsub,"name",tstring); + mdg->addPropertyToType(tsub,"number",tint); + mdg->addPropertyToType(tsub,"bool",tbool); + + + // create a graph, then save it + + DataObjectPtr main1 = mdg->create((Type&)tmain); + main1->setCString("name","MainObject"); + + // asub is initially set + DataObjectPtr sub0 = main1->createDataObject("asub"); + // bsub is not set. + + DataObjectPtr sub1 = mdg->create((Type&)tsub); + DataObjectPtr sub2 = mdg->create((Type&)tsub); + DataObjectPtr sub3 = mdg->create((Type&)tsub); + + DataObjectList& dol = main1->getList("subs"); + + dol.append(sub1); + dol.append(sub2); + dol.append(sub3); + + // sub1 has all values set initially + + sub1->setCString("name","All Initially set"); + sub1->setInteger("number",100); + sub1->setBoolean("bool",false); + + // sub2 has no values set at all + + + // sub3 has all values set to null + sub3->setNull("name"); + sub3->setNull("number"); + sub3->setNull("bool"); + + + // report + + cout << "is ASUB null? (0 expected) " << + main1->isNull("asub") << endl; + + cout << "is ASUB set? (1 expected) " << + main1->isSet("asub") << endl; + + cout << "is BSUB null? (0 expected) " << + main1->isNull("bsub") << endl; + + cout << "is BSUB set? (0 expected) " << + main1->isSet("bsub") << endl; + +// dol0 is set, not null + + cout << "dol[0] name is null? (0 expected) " << + dol[0]->isNull("name") << endl; + + cout << "dol[0] number is null? (0 expected) " << + dol[0]->isNull("number") << endl; + + cout << "dol[0] bool is null? (0 expected) " << + dol[0]->isNull("bool") << endl; + + cout << "dol[0] name is set? (1 expected) " << + dol[0]->isSet("name") << endl; + + cout << "dol[0] number is set? (1 expected) " << + dol[0]->isSet("number") << endl; + + cout << "dol[0] bool is set? (1 expected) " << + dol[0]->isSet("bool") << endl; + +// dol1 is all unset , so no nulls + + cout << "dol[1] name is null? (0 expected) " << + dol[1]->isNull("name") << endl; + + cout << "dol[1] number is null? (0 expected) " << + dol[1]->isNull("number") << endl; + + cout << "dol[1] bool is null? (0 expected) " << + dol[1]->isNull("bool") << endl; + + cout << "dol[1] name is set? (0 expected) " << + dol[1]->isSet("name") << endl; + + cout << "dol[1] number is set? (0 expected) " << + dol[1]->isSet("number") << endl; + + cout << "dol[1] bool is set? (0 expected) " << + dol[1]->isSet("bool") << endl; + +// dol2 is all nulls, so all set + + cout << "dol[2] name is null? (1 expected) " << + dol[2]->isNull("name") << endl; + + cout << "dol[2] number is null? (1 expected) " << + dol[2]->isNull("number") << endl; + + cout << "dol[2] bool is null? (1 expected) " << + dol[2]->isNull("bool") << endl; + + cout << "dol[2] name is set? (1 expected) " << + dol[2]->isSet("name") << endl; + + cout << "dol[2] number is set? (1 expected) " << + dol[2]->isSet("number") << endl; + + cout << "dol[2] bool is set? (1 expected) " << + dol[2]->isSet("bool") << endl; + + ChangeSummaryPtr cs = main1->getChangeSummary(); + + cs->beginLogging(); + + main1->setNull("asub"); + main1->setNull("bsub"); + + dol[0]->setNull("name"); + dol[0]->setNull("number"); + dol[0]->setNull("bool"); + + dol[1]->setNull("bool"); + + dol[2]->setCString("name","NewName"); + dol[2]->setInteger("number",100); + dol[2]->setBoolean("bool",true); + + + cs->endLogging(); + + // what would we expect from the change summary? + + cout << "==============Expected in Change Summary=================" << endl; + cout << "change to main1 - object asub set to null, oldvalue asub (set)" << endl; + cout << "change to main1 - object bsub set to null, oldvalue null (unset)" << endl; + cout << "change to sub1 - name asub set to null, oldvalue \"All Initially Set\" (set)" << endl; + cout << "change to sub1 - number asub set to null, oldvalue 100 (set)" << endl; + cout << "change to sub1 - bool asub set to null, oldvalue false (set)" << endl; + cout << "change to sub2 - bool asub set to null, oldvalue false (unset)" << endl; + cout << "change to sub3 - name asub set to \"NewName\", oldvalue null, set" << endl; + cout << "change to sub3 - number asub set to 100, oldvalue null, set" << endl; + cout << "change to sub3 - bool asub set to true, oldvalue null, set" << endl; + cout << "==============End Expected in Change Summary=============" << endl; + + + dumpchangesummary(cs); + + // report + + cout << "is ASUB null? (1 expected) " << + main1->isNull("asub") << endl; + + cout << "is ASUB set? (1 expected) " << + main1->isSet("asub") << endl; + + cout << "is BSUB null? (1 expected) " << + main1->isNull("bsub") << endl; + + cout << "is BSUB set? (1 expected) " << + main1->isSet("bsub") << endl; + +// dol0 is set to null + + cout << "dol[0] name is null? (1 expected) " << + dol[0]->isNull("name") << endl; + + cout << "dol[0] number is null? (1 expected) " << + dol[0]->isNull("number") << endl; + + cout << "dol[0] bool is null? (1 expected) " << + dol[0]->isNull("bool") << endl; + + cout << "dol[0] name is set? (1 expected) " << + dol[0]->isSet("name") << endl; + + cout << "dol[0] number is set? (1 expected) " << + dol[0]->isSet("number") << endl; + + cout << "dol[0] bool is set? (1 expected) " << + dol[0]->isSet("bool") << endl; + +// dol1 is all unset except bool which is null + + cout << "dol[1] name is null? (0 expected) " << + dol[1]->isNull("name") << endl; + + cout << "dol[1] number is null? (0 expected) " << + dol[1]->isNull("number") << endl; + + cout << "dol[1] bool is null? (1 expected) " << + dol[1]->isNull("bool") << endl; + + cout << "dol[1] name is set? (0 expected) " << + dol[1]->isSet("name") << endl; + + cout << "dol[1] number is set? (0 expected) " << + dol[1]->isSet("number") << endl; + + cout << "dol[1] bool is set? (1 expected) " << + dol[1]->isSet("bool") << endl; + +// dol2 is all set non-null, so all set + + cout << "dol[2] name is null? (0 expected) " << + dol[2]->isNull("name") << endl; + + cout << "dol[2] number is null? (0 expected) " << + dol[2]->isNull("number") << endl; + + cout << "dol[2] bool is null? (0 expected) " << + dol[2]->isNull("bool") << endl; + + cout << "dol[2] name is set? (1 expected) " << + dol[2]->isSet("name") << endl; + + cout << "dol[2] number is set? (1 expected) " << + dol[2]->isSet("number") << endl; + + cout << "dol[2] bool is set? (1 expected) " << + dol[2]->isSet("bool") << endl; + + + // what would we expect from the change summary? +// } +// catch (SDORuntimeException e) +// { +// cout << "Exception in setnull" << endl; +// cout << e; +// } + +} + +void sdotest::testsubs() +{ + + try { + DataFactoryPtr mdg = DataFactory::getDataFactory(); + + mdg->addType("companyNS","MainType"); + + mdg->addType("companyNS","SubType"); + mdg->addType("companyNS","SuperType"); + mdg->addType("companyNS","SubstituteType"); + mdg->addType("companyNS","UnrelatedType"); + + /* Now add the properties to the types...*/ + + + 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& tmain = mdg->getType("companyNS","MainType"); + const Type& sub = mdg->getType("companyNS","SubType"); + const Type& super = mdg->getType("companyNS","SuperType"); + const Type& subst = mdg->getType("companyNS","SubstituteType"); + const Type& unrel = mdg->getType("companyNS","UnrelatedType"); + + + mdg->addPropertyToType(tmain,"name",tstring); + mdg->addPropertyToType(tmain,"sub",super, false); + mdg->addPropertyToType(tmain,"subs",super, true); + + + mdg->setPropertySubstitute(tmain, "sub","wilbur", subst); + mdg->setPropertySubstitute(tmain, "subs","wilburs", subst); + + mdg->setBaseType(sub,super); + + //now sub and subs should accept all the three types + + DataObjectPtr main = mdg->create((Type&)tmain); + main->setCString("name","SubstituteTest"); + + DataObjectList& dol = main->getList("subs"); + + DataObjectPtr sub1 = mdg->create(sub); + DataObjectPtr super1 = mdg->create(super); + DataObjectPtr subst1 = mdg->create(subst); + DataObjectPtr unrel1 = mdg->create(unrel); + + dol.append(sub1); + dol.append(super1); + dol.append(subst1); + try + { + dol.append(unrel1); + } + catch (SDOInvalidConversionException e) + { + cout << "Normal failure to append wrong type" << endl; + } + + dol.remove(0); + dol.remove(0); + dol.remove(0); + + DataObjectList& dol2 = main->getList("wilburs"); + + dol2.append(sub1); + dol2.append(super1); + dol2.append(subst1); + try + { + dol2.append(unrel1); + } + catch (SDOInvalidConversionException e) + { + cout << "Normal failure to append wrong type" << endl; + } + + main->setDataObject("sub",sub1); + main->setDataObject("sub",super1); + main->setDataObject("sub",subst1); + + main->setDataObject("wilbur",sub1); + main->setDataObject("wilbur",super1); + main->setDataObject("wilbur",subst1); + + try + { + main->setDataObject("sub", unrel1); + } + catch (SDOInvalidConversionException e) + { + cout << "Normal failure to set wrong type" << endl; + } + } + + catch (SDORuntimeException e) + { + cout << "Substitute test failed" << endl << e << endl; + } +} + + +void sdotest::merle1() +{ + + try { + + // Dynamic setup of the metadata + + DataFactoryPtr mdg = DataFactory::getDataFactory(); + + XSDHelperPtr xsh = HelperProvider::getXSDHelper(mdg); + xsh->defineFile("axis.xsd"); + + // or dynamically create, but that would get attributes for the strings, not elements + //mdg->addType("axis","ItemSearch",true); // sequenced + //mdg->addType("axis","ItemSearchRequest",true); // sequenced + + const Type& tstring = mdg->getType("commonj.sdo","String"); + const Type& tsearch = mdg->getType("axis","ItemSearch"); + const Type& treq = mdg->getType("axis","ItemSearchRequest"); + + //mdg->addPropertyToType(tsearch,"SubscriptionId",tstring); + //mdg->addPropertyToType(tsearch,"AssociateTag",tstring); + //mdg->addPropertyToType(tsearch,"XMLEscaping",tstring); + //mdg->addPropertyToType(tsearch,"Validate",tstring); + //mdg->addPropertyToType(tsearch,"Shared",treq, false, false, true); + //mdg->addPropertyToType(tsearch,"Request",treq, true, false, true); + + //mdg->addPropertyToType(treq,"Keywords",tstring); + //mdg->addPropertyToType(treq,"SearchIndex",tstring); + + // dynamic creation of the data + + DataObjectPtr search = mdg->create((Type&)tsearch); + + search->setCString("SubscriptionId","I am the subscription ID string"); + search->setCString("AssociateTag","I am the associate Tag string"); + search->setCString("XMLEscaping","I am the XML escaping string"); + search->setCString("Validate","I am the Validate string"); + + DataObjectPtr shared = search->createDataObject("Shared"); + shared->setCString("Keywords","SharedKeywordsString"); + shared->setCString("SearchIndex","SearchIndexString"); + + DataObjectList& requests = search->getList("Request"); + DataObjectPtr request1 = mdg->create(treq); + requests.append(request1); + request1->setCString("Keywords","RequestKeywords"); + request1->setCString("SearchIndex","RequestSearchIndex"); + + // Read the data and put it into XML: + + PropertyList properties = search->getInstanceProperties(); + + XMLHelperPtr myXMLHelper = HelperProvider::getXMLHelper(mdg); + + for (int i=0;i<properties.size();i++) + { + Property& prop = properties[i]; + switch (prop.getTypeEnum()) + { + + case Type::StringType: + cout << "<" << prop.getName() << ">" << + search->getCString(prop) << "</" << + prop.getName() << ">" << endl; + break; + + case Type::DataObjectType: + if (prop.isMany()) + { + // many valued property, such as Requests , so get the list + DataObjectList& rq = search->getList(prop); + for (int j=0;j<rq.size();j++) + { + DataObjectPtr dob = rq[j]; + if (dob != 0) + { + XMLDocumentPtr doc = myXMLHelper->createDocument(dob, + "axis", prop.getName()); + doc->setXMLDeclaration(false); + char* dobXML = myXMLHelper->save(doc); + cout << "DataObject \"" << prop.getName() << + "\" as XML:" << endl; + cout << dobXML << endl; + } // if dob + } // for + } // if many + else + { + DataObjectPtr dob = search->getDataObject(prop); + if (dob != 0) + { + XMLDocumentPtr doc = myXMLHelper->createDocument(dob, + "axis", prop.getName()); + doc->setXMLDeclaration(false); + char* dobXML = myXMLHelper->save(doc); + cout << "DataObject \"" << prop.getName() << + "\" as XML:" << endl; + cout << dobXML << endl; + } // if + } // else + break; + + default: + break; + + } // switch + } // for + } // try + catch (SDORuntimeException e) + { + cout << "Merle 1 failed" << endl << e << endl; + } +} + + +void sdotest::graham3() +{ + //try { + + // Dynamic setup of the metadata + + DataFactoryPtr mdg = DataFactory::getDataFactory(); + + XSDHelperPtr xsh = HelperProvider::getXSDHelper(mdg); + xsh->defineFile("graham3.xsd"); + //} + //catch (SDORuntimeException e) + //{ +// cout << "Graham1 failed " << e << endl; +// } +} + +void sdotest::graham1() +{ + try { + + // Dynamic setup of the metadata + + DataFactoryPtr mdg = DataFactory::getDataFactory(); + + XSDHelperPtr xsh = HelperProvider::getXSDHelper(mdg); + xsh->defineFile("graham1.xsd"); + } + catch (SDORuntimeException e) + { + cout << "Graham1 failed " << e << endl; + } +} +void sdotest::graham2() +{ + try { + + // Dynamic setup of the metadata + + DataFactoryPtr mdg = DataFactory::getDataFactory(); + + XSDHelperPtr xsh = HelperProvider::getXSDHelper(mdg); + xsh->defineFile("graham2.xsd"); + } + catch (SDORuntimeException e) + { + cout << "Graham2 failed " << e << endl; + } +} + + +void sdotest::b46613() +{ + try { + + // Dynamic setup of the metadata + + DataFactoryPtr mdg = DataFactory::getDataFactory(); + + mdg->create("rubbish","MyObject"); + + } + catch (SDOTypeNotFoundException e) + { + cout << "b46613 gave the correct exception" << endl; + } +} + +void sdotest::doctest() +{ + try { + + DataFactoryPtr mdg = DataFactory::getDataFactory(); + + XSDHelperPtr xsh = HelperProvider::getXSDHelper(mdg); + xsh->defineFile("doctest.xsd"); + XMLHelperPtr myXMLHelper = HelperProvider::getXMLHelper(mdg); + XMLDocumentPtr myXMLDocument = myXMLHelper->loadFile("doctest.xml", + "companyNS"); + cout << "RootURI=" << myXMLDocument->getRootElementURI(); + cout << "RootName=" << myXMLDocument->getRootElementName(); + } + catch (SDOTypeNotFoundException e) + { + cout << "doctest failed" << endl; + } + +} + + +void sdotest::b46634() +{ + try { + + DataFactoryPtr mdg = DataFactory::getDataFactory(); + + XSDHelperPtr xsh = HelperProvider::getXSDHelper(mdg); + xsh->defineFile("company_with_nillable_SN.xsd"); + XMLHelperPtr myXMLHelper = HelperProvider::getXMLHelper(mdg); + XMLDocumentPtr myXMLDocument = myXMLHelper->loadFile("company_with_nillable_SN.xml", + "companyNS"); + + DataObjectPtr dob = myXMLDocument->getRootDataObject(); + DataObjectList& dol = dob->getList("departments"); + DataObjectPtr dept = dol[0]; + DataObjectList& dol2 = dept->getList("employees"); + DataObjectPtr emp = dol2[0]; + + if (!emp->isSet("SN")) + { + cout << "B46634 WRONG - isSet should be true" << endl; + } + if (!emp->isNull("SN")) + { + cout << "B46634 WRONG - isNull should be true" << endl; + } + + // now write out the nill value and check its still nil + myXMLHelper->save(myXMLDocument->getRootDataObject(), + 0, "company", "b46634_out.xml"); + + } + catch (SDORuntimeException e) + { + cout << "b46634 failed" << endl; + } + +} + +void sdotest::testErrors() +{ + try { + + int i,j; + + DataFactoryPtr mdg = DataFactory::getDataFactory(); + + XSDHelperPtr xsh = HelperProvider::getXSDHelper(mdg); + xsh->defineFile("error1.xsd"); + if ((i = xsh->getErrorCount()) > 0) + { + cout << "XSD reported some errors:" << endl; + for (j=0;j<i;j++) + { + const char* m = xsh->getErrorMessage(j); + if (m != 0) cout << m; + cout << endl; + } + } + XMLHelperPtr myXMLHelper = HelperProvider::getXMLHelper(mdg); + XMLDocumentPtr myXMLDocument = myXMLHelper->loadFile("error1.xml", + "companyNS"); + + if ((i = myXMLHelper->getErrorCount()) > 0) + { + cout << "XML reported some errors:" << endl; + for (j=0;j<i;j++) + { + const char *m = myXMLHelper->getErrorMessage(j); + if (m != 0) cout << m; + cout << endl; + } + } + + } + catch (SDORuntimeException e) + { + cout << "testErrors failed" << endl << e << endl; + } + +} + +void sdotest::b46734() +{ + try { + + int i,j; + + DataFactoryPtr mdg = DataFactory::getDataFactory(); + + XSDHelperPtr xsh = HelperProvider::getXSDHelper(mdg); + + xsh->defineFile("wsdl.xsd"); + if ((i = xsh->getErrorCount()) > 0) + { + cout << "WSDL XSD reported some errors:" << endl; + for (j=0;j<i;j++) + { + const char *m = xsh->getErrorMessage(j); + if (m != 0) cout << m; + cout << endl; + } + } + xsh->defineFile("wsdl-soap.xsd"); + if ((i = xsh->getErrorCount()) > 0) + { + cout << "WSDL SOAP XSD reported some errors:" << endl; + for (j=0;j<i;j++) + { + const char* m = xsh->getErrorMessage(j); + if (m != 0) cout << m; + cout << endl; + } + } + xsh->defineFile("wsdl-http.xsd"); + if ((i = xsh->getErrorCount()) > 0) + { + cout << "WSDL HTTP XSD reported some errors:" << endl; + for (j=0;j<i;j++) + { + const char* m = xsh->getErrorMessage(j); + if (m != 0) cout << m; + cout << endl; + } + } + // xsh->defineFile("StockQuoteService.wsdl"); + // if ((i = xsh->getErrorCount()) > 0) + // { + // cout << "SQ WSDL reported some errors:" << endl; + // for (j=0;j<i;j++) + // { + // const char *m = xsh->getErrorMessage(j); + // if (m != 0) cout << m; + // cout << endl; + // } + // } + XMLHelperPtr myXMLHelper = HelperProvider::getXMLHelper(mdg); + XMLDocumentPtr myXMLDocument = myXMLHelper->loadFile("StockQuoteService.wsdl" + ); + //, "http://swanandmokashi.com"); + + if ((i = myXMLHelper->getErrorCount()) > 0) + { + cout << "XML reported some errors:" << endl; + for (j=0;j<i;j++) + { + const char * m = myXMLHelper->getErrorMessage(j); + if (m != 0)cout << m; + cout << endl; + } + } + + } + catch (SDORuntimeException e) + { + cout << "b46734 failed" << endl << e << endl; + } + +} + +void sdotest::b46693() +{ + try { + + int i,j; + + DataFactoryPtr mdg = DataFactory::getDataFactory(); + + XSDHelperPtr xsh = HelperProvider::getXSDHelper(mdg); + + xsh->defineFile("b46693.xsd"); + if ((i = xsh->getErrorCount()) > 0) + { + cout << "b46693 XSD reported some errors:" << endl; + for (j=0;j<i;j++) + { + const char* m = xsh->getErrorMessage(j); + if (m != 0)cout << m; + cout << endl; + } + } + + // XMLHelperPtr myXMLHelper = HelperProvider::getXMLHelper(mdg); + // XMLDocumentPtr myXMLDocument = myXMLHelper->loadFile("b46693.xsd" + // ); + + // if ((i = myXMLHelper->getErrorCount()) > 0) + // { + // cout << "b46693 reported some errors:" << endl; + // for (j=0;j<i;j++) + // { + // const char* m = myXMLHelper->getErrorMessage(j); + // if (m != 0)cout << m; + // cout << endl; + // } + // } + + } + catch (SDORuntimeException e) + { + cout << "b46693 failed" << endl << e << endl; + } + +} + +void sdotest::clonetest() +{ + try { + DataFactoryPtr mdg = DataFactory::getDataFactory(); + + mdg->addType("companyNS","CompanyType"); + mdg->addType("companyNS","DepartmentType"); + mdg->addType("companyNS","EmployeeType"); + + + 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"); + + mdg->addPropertyToType(tcomp,"name",tstring); + mdg->addPropertyToType(tcomp,"departments",tdept,true,false,true); + mdg->addPropertyToType(tcomp,"employeeOfTheMonth",temp,false,false,false); + mdg->addPropertyToType(tcomp,"CEO",temp,false,false,true); + + mdg->addPropertyToType(tdept,"employees",temp,true,false,true); + mdg->addPropertyToType(tdept,"name",tstring,false,false,true); + mdg->addPropertyToType(tdept,"location",tstring,false,false,true); + mdg->addPropertyToType(tdept,"number",tstring,false,false,true); + + mdg->addPropertyToType(temp,"name",tstring,false,false,true); + mdg->addPropertyToType(temp,"SN",tstring,false,false,true); + mdg->addPropertyToType(temp,"manager",tbool,false,false,true); + + + DataObjectPtr comp = mdg->create((Type&)tcomp); + comp->setCString("name","The Company"); + + DataObjectPtr dept = mdg->create((Type&)tdept); + + DataObjectList& dol = comp->getList("departments"); + dol.append(dept); + + dept->setCString("name","The Department"); + dept->setCString("location","Botley"); + dept->setCString("number","123"); + + + // now clone the data factory, and add more types + + DataFactoryPtr df2 = mdg->clone(); + + df2->addType("otherNS","DataSet"); + + df2->addPropertyToType("companyNS","DepartmentType","dataset", + "otherNS","DataSet", false, false, true); + + const Type& tstring2 = df2->getType("commonj.sdo","String"); + const Type& tbool2 = df2->getType("commonj.sdo","Boolean"); + const Type& tcs2 = df2->getType("commonj.sdo","ChangeSummary"); + const Type& tcomp2 = df2->getType("companyNS","CompanyType"); + const Type& tdept2 = df2->getType("companyNS","DepartmentType"); + const Type& temp2 = df2->getType("companyNS","EmployeeType"); + + DataObjectPtr comp2 = df2->create((Type&)tcomp2); + comp->setCString("name","The Company"); + + DataObjectPtr dept2 = df2->create((Type&)tdept2); + + DataObjectList& dol2 = comp2->getList("departments"); + dol2.append(dept2); + + dept2->setCString("name","The Other Department"); + dept2->setCString("location","Not Botley"); + dept2->setCString("number","321"); + } + catch (SDORuntimeException e) + { + cout << "clone failed " << e << endl; + } + + +} + +void sdotest::testUtil() +{ + try { + + cout << "START TEST: UTILS ======================================" << endl; + + DataFactoryPtr mdg = DataFactory::getDataFactory(); + + + mdg->addType("companyNS","CompanyType"); + // employee will be an open type... + mdg->addType("companyNS","EmployeeType", /*seq*/false, + /*open*/true, + /*abs */ false, + /*data*/ false); + + mdg->addType("companyNS","DepartmentType"); + + mdg->addType("companyNS","OpenType"); + + /* Now add the properties to the types...*/ + + + 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"); + const Type& topen = mdg->getType("companyNS","OpenType"); + + + mdg->addPropertyToType(tcomp,"name",tstring); + // not containment... + mdg->addPropertyToType(tcomp,"employeeOfTheMonth",temp, false,false,false); + mdg->addPropertyToType(tcomp,"departments",tdept, true); + mdg->addPropertyToType(tcomp,"cs",tcs); + + mdg->addPropertyToType(tdept,"name",tstring); + mdg->addPropertyToType(tdept,"location",tstring); + mdg->addPropertyToType(tdept,"number",tstring); + mdg->addPropertyToType(tdept,"employees",temp,true); + + mdg->addPropertyToType(temp, "name",tstring); + mdg->addPropertyToType(temp, "SN", tstring); + mdg->addPropertyToType(temp, "manager", tbool); + + mdg->addPropertyToType(topen,"name",tstring); + + 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"); + + DataObjectList& emps = dept->getList("employees"); + + DataObjectPtr emp1 = mdg->create(temp); + DataObjectPtr emp2 = mdg->create(temp); + DataObjectPtr emp3 = mdg->create(temp); + + emps.append(emp1); + emps.append(emp2); + emps.append(emp3); + + emp1->setCString("name","Albert"); + emp1->setCString("SN","E0001"); + + emp2->setCString("name","Boris"); + emp2->setCString("SN","E0002"); + emp2->setBoolean("manager",true); + + emp3->setCString("name","Carl"); + emp3->setCString("SN","E0003"); + + emp1->setCString("openstring","Value Of Open String"); + emp1->setBoolean("openboolean",true); + + const char* c = emp1->getCString("openstring"); + + bool b = emp1->getBoolean("openboolean"); + + // unknown list type at present.. + DataObjectList& dl = emp1->getList("openintlist"); + + int i = 45; + dl.append((short)i); // now the list must be primitive and short!! + + // unknown list type at present.. + DataObjectList& dl2 = emp1->getList("opendataobjectlist"); + + DataObjectPtr myopen = mdg->create("companyNS","OpenType"); + myopen->setCString("name","MyOpenName"); + dl2.append(myopen); // now the list must be of data objects + + emp1->setDataObject("opendataobject", myopen); + + SDOUtils::printDataObject(comp); + + } + catch (SDORuntimeException e) + { + cout << "ERROR in UTILS test" << e << endl; + } + cout << "END TEST: UTILS ======================================" << endl; + +} + +void sdotest::printset(ChangeSummaryPtr cs) +{ + ChangedDataObjectList& cdl = cs->getChangedDataObjects(); + + // here there should be a creation of Ed, and a change to dept, which has a + // bool previously unset, and a int list previuously unset and an employees list + // previously unset + + for (int i=0;i< cdl.size();i++) + { + if (cs->isModified(cdl[i])) + { + + cout << "A modified of type " << cdl[i]->getType().getURI() + << "#" << cdl[i]->getType().getName() << endl; + + SettingList& sl = cs->getOldValues(cdl[i]); + if (sl.size() == 0) + { + cout << "No Settings found" << endl; + } + else + { + for (int j=0;j< sl.size(); j++) + { + cout << "Property " << sl[j].getProperty().getName(); + // this could be a many-valued property, and could be one which is + // a data object or a data type... + if (sl[j].getProperty().isMany()) + { + cout << "[" << sl[j].getIndex() << "]" ; + } + if (!sl[j].isSet()) + { + cout << " was unset before the change" << endl; + } + else + { + cout << " was set before the change !!" << endl; + } + } + } + } + } +} + + +void sdotest::b46633() +{ + try { + DataFactoryPtr mdg = DataFactory::getDataFactory(); + + mdg->addType("myspace","Root"); + mdg->addPropertyToType("myspace","Root","cs", + "commonj.sdo","ChangeSummary", false, false, false); + + mdg->addType("myspace","Company"); + mdg->addType("myspace","Department"); + mdg->addType("myspace","Manager"); + mdg->addType("myspace","Employee"); + + + mdg->addPropertyToType("myspace","Company","name", + "commonj.sdo","String", false, false, false); + + + mdg->addPropertyToType("myspace","Root","company", + "myspace","Company", false, false, true); + + mdg->addPropertyToType("myspace","Company","departments", + "myspace","Department", true, false, true); + + + mdg->addPropertyToType("myspace","Department","name", + "commonj.sdo","String", false, false, false); + + mdg->addPropertyToType("myspace","Department","ints", + "commonj.sdo","Integer", true, false, false); + + + mdg->addPropertyToType("myspace","Department","bool", + "commonj.sdo","Boolean", false, false, false); + + mdg->addPropertyToType("myspace","Department","manager", + "myspace","Manager", false, false, true); + + mdg->addPropertyToType("myspace","Department","employees", + "myspace","Employee", true, false, true); + + mdg->addPropertyToType("myspace","Manager","name", + "commonj.sdo","String", false, false, false); + + mdg->addPropertyToType("myspace","Employee","name", + "commonj.sdo","String", false, false, false); + + const Type& tcc = mdg->getType("myspace","Root"); + + DataObjectPtr dor = mdg->create((Type&)tcc); + + ChangeSummaryPtr cs = dor->getChangeSummary(); + + DataObjectPtr com = dor->createDataObject("company"); + com->setCString("name","IBM"); + + DataObjectPtr dept = com->createDataObject("departments"); + dept->setCString("name","JTC"); + + // employees initally unset + + cs->beginLogging(); + + DataObjectPtr emp = dept->createDataObject("employees"); + emp->setCString("name","Ed"); + + + + DataObjectList& dl = dept->getList("ints"); + dl.append((long)400); + + dept->setBoolean("bool", true); + + printset(cs); + + cs->endLogging(); + + // unset them all , restart logging, and get the same results + + dept->unset("bool"); + dept->unset("ints"); + dept->unset("employees"); + + cs->beginLogging(); + + DataObjectPtr emp2 = dept->createDataObject("employees"); + emp2->setCString("name","Ed2"); + + dl.append((long)600); + + dept->setBoolean("bool", true); + + printset(cs); + + cs->endLogging(); + + } + catch (SDORuntimeException e) + { + cout << "b46633 failed " << e << endl; + } + +} + + + +void sdotest::testLoad() +{ + try + { + int i,j; + DataFactoryPtr mdg = DataFactory::getDataFactory(); + FILE* f = fopen("company_with_nillable_SN.xsd","r+"); + char* buffer = new char[4000]; + j = 0; + while ((i = fgetc(f)) != EOF) + { + buffer[j++] = (char)i; + } + buffer[j] = 0; + XSDHelperPtr xsh = HelperProvider::getXSDHelper(mdg); + xsh->define(buffer); + + if ((i = xsh->getErrorCount()) > 0) + { + cout << "XSD reported some errors:" << endl; + for (j=0;j<i;j++) + { + const char *m = xsh->getErrorMessage(j); + if (m != 0) cout << m; + cout << endl; + } + } + + FILE* f2 = fopen("company_with_nillable_SN.xml","r+"); + j = 0; + while ((i = fgetc(f2)) != EOF) + { + buffer[j++] = (char)i; + } + buffer[j] = 0; + + XMLHelperPtr myXMLHelper = HelperProvider::getXMLHelper(mdg); + XMLDocumentPtr myXMLDocument = myXMLHelper->load(buffer); + + } + catch (SDORuntimeException e) + { + cout << "Exception in testDAS " << e << endl; + } +} + +void sdotest::includetest() +{ + try + { + int i,j; + DataFactoryPtr mdg = DataFactory::getDataFactory(); + + XSDHelperPtr xsh = HelperProvider::getXSDHelper(mdg); + + xsh->defineFile("include.xsd"); + if ((i = xsh->getErrorCount()) > 0) + { + cout << "INCLUDE XSD reported some errors:" << endl; + for (j=0;j<i;j++) + { + const char *m = xsh->getErrorMessage(j); + if (m != 0) cout << m; + cout << endl; + } + } + + xsh->defineFile("../t2/includeother.xsd"); + if ((i = xsh->getErrorCount()) > 0) + { + cout << "INCLUDE XSD reported some errors:" << endl; + for (j=0;j<i;j++) + { + const char *m = xsh->getErrorMessage(j); + if (m != 0) cout << m; + cout << endl; + } + } + } + catch (SDORuntimeException e) + { + cout << "Exception in include test" << e << endl; + } +} + +void sdotest::detachtest() +{ + try { + DataFactoryPtr mdg = DataFactory::getDataFactory(); + + mdg->addType("myspace","Root"); + + mdg->addType("myspace","Company"); + mdg->addType("myspace","Department"); + mdg->addType("myspace","Manager"); + mdg->addType("myspace","Employee"); + + + mdg->addPropertyToType("myspace","Company","name", + "commonj.sdo","String", false, false, false); + + + mdg->addPropertyToType("myspace","Root","company", + "myspace","Company", false, false, true); + + mdg->addPropertyToType("myspace","Company","departments", + "myspace","Department", true, false, true); + + + mdg->addPropertyToType("myspace","Department","name", + "commonj.sdo","String", false, false, false); + + + mdg->addPropertyToType("myspace","Department","manager", + "myspace","Manager", false, false, true); + + mdg->addPropertyToType("myspace","Department","employees", + "myspace","Employee", true, false, true); + + mdg->addPropertyToType("myspace","Manager","name", + "commonj.sdo","String", false, false, false); + + mdg->addPropertyToType("myspace","Employee","name", + "commonj.sdo","String", false, false, false); + + const Type& tcc = mdg->getType("myspace","Root"); + + DataObjectPtr dor = mdg->create((Type&)tcc); + + DataObjectPtr com = dor->createDataObject("company"); + com->setCString("name","IBM"); + + DataObjectPtr dept = com->createDataObject("departments"); + + dept->setCString("name","JTC"); + + + DataObjectPtr emp = dept->createDataObject("employees"); + emp->setCString("name","Ed"); + + DataObjectPtr emp2 = dept->createDataObject("employees"); + emp2->setCString("name","Tom"); + + DataObjectList& dol = dept->getList("employees"); + + DataObjectPtr e = dol[0]; + e->detach(); + + DataObjectPtr cont = emp->getContainer(); + + if (cont != 0) + { + cout << "EMP STILL ATTACHED - problem" << endl; + } + + DataObjectPtr cont2 = dol[0]->getContainer(); + + if (cont2 == 0) + { + cout << "SECOND DETACHED - problem" << endl; + } + + } + catch (SDORuntimeException e) + { + cout << "detach failed " << e << endl; + } + +} + + +void sdotest::leak() +{ + try { + DataFactoryPtr mdg = DataFactory::getDataFactory(); + + mdg->addType("myspace","Root"); + + + mdg->addPropertyToType("myspace","Root","ints", + "commonj.sdo","Integer", true, false, false); + + + const Type& tcc = mdg->getType("myspace","Root"); + + DataObjectPtr dor = mdg->create((Type&)tcc); + + + cout << "List set should be false and is " << dor->isSet("ints") << endl; + + DataObjectList& dl = dor->getList("ints"); + + cout << "List set should be false and is " << dor->isSet("ints") << endl; + + dl.append((long)400); + + cout << "List set should be true and is " << dor->isSet("ints") << endl; + + dl.remove(0); + + cout << "List set should be false and is " << dor->isSet("ints") << endl; + + dl.append((long)400); + + cout << "List set should be true and is " << dor->isSet("ints") << endl; + + dor->unset("ints"); + + cout << "List set should be false and is " << dor->isSet("ints") << endl; + + dl.append((long)600); + + cout << "List set should be true and is " << dor->isSet("ints") << endl; + + + } + catch (SDORuntimeException e) + { + cout << "leak failed " << e << endl; + } + +} + +void sdotest::twolists() +{ + try { + DataFactoryPtr mdg = DataFactory::getDataFactory(); + + mdg->addType("myspace","Root"); + + //mdg->addType("myspace","Company"); + //mdg->addType("myspace","Department"); + //mdg->addType("myspace","Manager"); + //mdg->addType("myspace","Employee"); + + + //mdg->addPropertyToType("myspace","Company","name", + // "commonj.sdo","String", false, false, false); + + + //mdg->addPropertyToType("myspace","Root","company", + // "myspace","Company", false, false, true); + + //mdg->addPropertyToType("myspace","Company","departments", + // "myspace","Department", true, false, true); + + + //mdg->addPropertyToType("myspace","Department","name", + // "commonj.sdo","String", false, false, false); + + mdg->addPropertyToType("myspace","Root","ints", + "commonj.sdo","Integer", true, false, false); + + mdg->addPropertyToType("myspace","Root","ints2", + "commonj.sdo","Integer", true, false, false); + + //mdg->addPropertyToType("myspace","Department","bool", + // "commonj.sdo","Boolean", false, false, false); + + //mdg->addPropertyToType("myspace","Department","manager", + // "myspace","Manager", false, false, true); + + //mdg->addPropertyToType("myspace","Department","employees", + // "myspace","Employee", true, false, true); + + //mdg->addPropertyToType("myspace","Manager","name", + // "commonj.sdo","String", false, false, false); + + //mdg->addPropertyToType("myspace","Employee","name", + // "commonj.sdo","String", false, false, false); + + const Type& tcc = mdg->getType("myspace","Root"); + + DataObjectPtr dor = mdg->create((Type&)tcc); + + //ChangeSummaryPtr cs = dor->getChangeSummary(); + + //DataObjectPtr com = dor->createDataObject("company"); + //com->setCString("name","IBM"); + + //DataObjectPtr dept = com->createDataObject("departments"); + //dept->setCString("name","JTC"); + + // employees initally unset + + //cs->beginLogging(); + + //DataObjectPtr emp = dept->createDataObject("employees"); + //emp->setCString("name","Ed"); + + DataObjectList& dl2 = dor->getList("ints2"); + dl2.append((long)400); + + + DataObjectList& dl = dor->getList("ints"); + dl.append((long)400); + + //dept->setBoolean("bool", true); + + //printset(cs); + + //cs->endLogging(); + + // unset them all , restart logging, and get the same results + + //dept->unset("bool"); + //dept->unset("ints"); + //dept->unset("employees"); + + //cs->beginLogging(); + + //DataObjectPtr emp2 = dept->createDataObject("employees"); + //emp2->setCString("name","Ed2"); + + //dl.append((long)600); + + //dept->setBoolean("bool", true); + + // printset(cs); + + //cs->endLogging(); + + } + catch (SDORuntimeException e) + { + cout << "twolists failed " << e << endl; + } + +} + + +void sdotest::graham4() +{ + try { + DataFactoryPtr mdg = DataFactory::getDataFactory(); + + mdg->addType("myspace","Root"); + mdg->addType("myspace","ListItem"); + + + mdg->addPropertyToType("myspace","ListItem","name", + "commonj.sdo","String", false, false, false); + + + mdg->addPropertyToType("myspace","Root","ints", + "commonj.sdo","Integer", true, false, false); + + mdg->addPropertyToType("myspace","Root","items", + "myspace","ListItem", true, false, true); + + + const Type& tcc = mdg->getType("myspace","Root"); + + DataObjectPtr dor = mdg->create((Type&)tcc); + + + // first try with no elements in lists + + try { + DataObjectPtr pitem = dor->getDataObject("items[name=\"hello\"]"); + } + catch (SDOIndexOutOfRangeException e) + { + cout << "Normal exception in Graham4" << endl; + } + + try { + int inty = dor->getInteger("ints[1]"); + } + catch (SDOIndexOutOfRangeException e) + { + cout << "Normal exception in Graham4" << endl; + } + + // now populate them + + DataObjectPtr myitem = dor->createDataObject("items"); + myitem->setCString("name","not hello"); + + try { + DataObjectPtr pitem2 = dor->getDataObject("items[name=\"hello\"]"); + } + catch (SDOIndexOutOfRangeException e) + { + cout << "Normal exception in Graham4" << endl; + } + + DataObjectList& dl = dor->getList("ints"); + dl.append((long)100); + + try { + int inty2 = dor->getInteger("ints[2]"); + } + catch (SDOIndexOutOfRangeException e) + { + cout << "Normal exception in Graham4" << endl; + } + + try + { + DataObjectPtr pitem2 = dor->getDataObject("items[name=\"not hello\"]"); + cout << "item name is " << pitem2->getCString("name") << endl; + } + catch (SDORuntimeException e) + { + cout << "ABNORMAL exception in Graham4" << endl; + } + + try { + int inty2 = dor->getInteger("ints[1]"); + cout << "Integer is " << inty2 << endl; + } + catch (SDOIndexOutOfRangeException e) + { + cout << "Normal exception in Graham4" << endl; + } + + } + catch (SDORuntimeException e) + { + cout << "twolists failed " << e << endl; + } + +} + + +void sdotest::graham5() +{ + try + { + int i,j; + DataFactoryPtr mdg = DataFactory::getDataFactory(); + + XSDHelperPtr xsh = HelperProvider::getXSDHelper(mdg); + + xsh->defineFile("Order.xsd"); + if ((i = xsh->getErrorCount()) > 0) + { + cout << "INCLUDE XSD reported some errors:" << endl; + for (j=0;j<i;j++) + { + const char *m = xsh->getErrorMessage(j); + if (m != 0) cout << m; + cout << endl; + } + } + } + catch (SDORuntimeException r) + { + cout << "Graham5 failed " << r << endl; + } +} + + + +void sdotest::b47293() +{ + int i,j,k; + try + { + DataFactoryPtr mdg = DataFactory::getDataFactory(); + + XSDHelperPtr xsh = HelperProvider::getXSDHelper(mdg); + + xsh->defineFile("47293Catalog.xsd"); + + if ((i = xsh->getErrorCount()) > 0) + { + cout << "47293 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(); + for ( k=0;k<tl.size();k++) + { + cout << "Type:" << tl[k].getURI() << "#" << tl[k].getName() << endl; + } + + xsh->generateFile(tl,"47293Catalog-out.xsd","catalogNS"); + + DataFactoryPtr mdg2 = DataFactory::getDataFactory(); + + XSDHelperPtr xsh2 = HelperProvider::getXSDHelper(mdg2); + + xsh2->defineFile("47293Catalog-out.xsd"); + + if ((i = xsh2->getErrorCount()) > 0) + { + cout << "47293-out XSD reported some errors:" << endl; + for (j=0;j<i;j++) + { + const char *m = xsh2->getErrorMessage(j); + if (m != 0) cout << m; + cout << endl; + } + } + + TypeList tl2 = mdg2->getTypes(); + for (k=0;k<tl2.size();k++) + { + cout << "Type:" << tl2[k].getURI() << "#" << tl2[k].getName() << endl; + } + + + + //XMLHelperPtr xmh = HelperProvider::getXMLHelper(mdg); + + //XMLDocumentPtr doc = xmh->loadFile("47293Catalog.xml", "catalog"); + + //DataObjectPtr dob = doc->getRootDataObject(); + + //xmh->save(dob,"","catalog","47293Catalog-out.xml"); + + + } + catch (SDORuntimeException e) + { + cout << "B47137 failed " << e << endl; + } +} + |