void testInstancesTransfer(
CIMRepository& oldRepository,
CIMRepository& newRepository,
const CIMNamespaceName& ns,
const CIMName& className)
{
Array<CIMInstance> i1 =
oldRepository.enumerateInstancesForClass(ns, className);
Array<CIMInstance> i2 =
newRepository.enumerateInstancesForClass(ns, className);
PEGASUS_TEST_ASSERT(i1.size() == i2.size());
for (Uint32 i = 0; i < i1.size(); i++)
{
Boolean found = false;
for (Uint32 j = 0; j < i2.size(); j++)
{
if (i1[i].identical(i2[j]))
{
found = true;
break;
}
}
PEGASUS_TEST_ASSERT(found);
}
}
PEGASUS_NAMESPACE_END
void CompareQualifiers(
CIMRepository& r1,
CIMRepository& r2,
const CIMNamespaceName& namespaceName)
{
Array<CIMQualifierDecl> quals1 = r1.enumerateQualifiers(namespaceName);
Array<CIMQualifierDecl> quals2 = r2.enumerateQualifiers(namespaceName);
PEGASUS_TEST_ASSERT(quals1.size() == quals2.size());
BubbleSort(quals1);
BubbleSort(quals2);
for (Uint32 i = 0; i < quals2.size(); i++)
{
if (verbose)
{
cout << "testing qualifier " << namespaceName.getString() << "/";
cout << quals1[i].getName().getString() << "/ against /";
cout << quals2[i].getName().getString() << "/" << endl;
}
PEGASUS_TEST_ASSERT(quals1[i].identical(quals2[i]));
}
}
Boolean ProcessValueObjectElement(CIMRepository& repository, XmlParser& parser)
{
XmlEntry entry;
if (!XmlReader::testStartTag(parser, entry, "VALUE.OBJECT"))
return false;
CIMClass cimClass;
CIMQualifierDecl qualifierDecl;
if (XmlReader::getClassElement(parser, cimClass))
{
cout << "Creating: class ";
cout << cimClass.getClassName() << endl;
repository.createClass(CIMV2_NAMESPACE, cimClass);
repository.createClass(ROOT_NAMESPACE, cimClass);
}
else if (XmlReader::getQualifierDeclElement(parser, qualifierDecl))
{
cout << "Creating: qualifier ";
cout << qualifierDecl.getName() << endl;
repository.setQualifier(CIMV2_NAMESPACE, qualifierDecl);
repository.setQualifier(ROOT_NAMESPACE, qualifierDecl);
}
XmlReader::expectEndTag(parser, "VALUE.OBJECT");
return true;
}
void CompareClasses(
CIMRepository& r1,
CIMRepository& r2,
const CIMNamespaceName& namespaceName)
{
Array<CIMName> classNames1 = r1.enumerateClassNames(namespaceName);
Array<CIMName> classNames2 = r2.enumerateClassNames(namespaceName);
BubbleSort(classNames1);
BubbleSort(classNames2);
PEGASUS_TEST_ASSERT(classNames1 == classNames2);
for (Uint32 i = 0; i < classNames1.size(); i++)
{
CIMClass class1 = r1.getClass(namespaceName, classNames1[i]);
CIMClass class2 = r2.getClass(namespaceName, classNames2[i]);
if (verbose)
{
cout << "testing class " << namespaceName.getString() << "/";
cout << classNames1[i].getString() << "..." << endl;
}
if (!class1.identical(class2))
{
PutClass("file1", class1);
PutClass("file2", class2);
cout << "=========================================================";
cout << "=========================================================";
cout << endl;
cout << "ERROR: not identical! - ";
cout << "ERROR FOUND testing class: " << namespaceName.getString();
cout << "/";
cout << classNames1[i].getString();
cout << " .... differences follow:" << endl << endl;
if (system("diff file1 file2") == -1)
{
cout << "Error: system(\"diff file1 file2\") failed." << endl;
}
if (verbose)
{
XmlWriter::printClassElement(class1, cout);
XmlWriter::printClassElement(class2, cout);
}
failures++;
}
}
}
void testClassTransfer(
CIMRepository& oldRepository,
CIMRepository& newRepository,
const CIMNamespaceName& ns,
const CIMName& className)
{
CIMClass c1 = oldRepository.getClass(ns, className);
CIMClass c2 = newRepository.getClass(ns, className);
PEGASUS_TEST_ASSERT(c1.identical(c2));
}
void testQualifierTransfer(
CIMRepository& oldRepository,
CIMRepository& newRepository,
const CIMNamespaceName& ns,
const CIMName& qualifierName)
{
CIMQualifierDecl q1 = oldRepository.getQualifier(ns, qualifierName);
CIMQualifierDecl q2 = newRepository.getQualifier(ns, qualifierName);
PEGASUS_TEST_ASSERT(q1.identical(q2));
}
void CompareQualifiers(
CIMRepository& r1,
CIMRepository& r2,
const CIMNamespaceName& namespaceName)
{
Array<CIMQualifierDecl> quals1 = r1.enumerateQualifiers(namespaceName);
Array<CIMQualifierDecl> quals2 = r2.enumerateQualifiers(namespaceName);
assert(quals1.size() == quals2.size());
for (size_t i = 0; i < quals2.size(); i++)
{
if (verbose)
{
cout << "testing qualifier " << namespaceName.getString() << "/";
cout << quals2[i].getName().getString() << "..." << endl;
}
assert(quals1[i].identical(quals2[i]));
}
}
void CompareInstances(
CIMRepository& r1,
CIMRepository& r2,
const CIMNamespaceName& namespaceName)
{
Array<CIMName> classNames1 = r1.enumerateClassNames(namespaceName);
Array<CIMName> classNames2 = r2.enumerateClassNames(namespaceName);
BubbleSort(classNames1);
BubbleSort(classNames2);
PEGASUS_TEST_ASSERT(classNames1 == classNames2);
for (Uint32 i = 0; i < classNames1.size(); i++)
{
Array<CIMObjectPath> objectPaths1 = r1.enumerateInstanceNamesForClass(
namespaceName, classNames1[i]);
Array<CIMObjectPath> objectPaths2 = r2.enumerateInstanceNamesForClass(
namespaceName, classNames2[i]);
// BubbleSort(objectPaths1);
// BubbleSort(objectPaths2);
PEGASUS_TEST_ASSERT(objectPaths1 == objectPaths2);
for (Uint32 j = 0; j < objectPaths2.size(); j++)
{
CIMInstance inst1 = r1.getInstance(namespaceName, objectPaths1[j]);
CIMInstance inst2 = r2.getInstance(namespaceName, objectPaths2[j]);
if (verbose)
{
cout << "testing instance " << namespaceName.getString() << "/";
cout << objectPaths1[j].toString() << "..." << endl;
}
PEGASUS_TEST_ASSERT(inst1.identical(inst2));
}
}
}
int main()
{
const char* pegasusHome = getenv("PEGASUS_HOME");
if (!pegasusHome)
{
cerr << "PEGASUS_HOME environment variable not set" << endl;
exit(1);
}
String repositoryRoot = pegasusHome;
repositoryRoot.append("/repository");
CIMRepository* repository = new CIMRepository(
repositoryRoot, CIMRepository::MODE_BIN);
ConfigManager::setPegasusHome(pegasusHome);
// -- Create repository and namespaces:
CreateRepository(*repository);
try
{
HandlerTable handlerTable;
String handlerId = "snmpIndicationHandler";
CIMHandler* handler = handlerTable.getHandler(handlerId, repository);
PEGASUS_TEST_ASSERT(handler != 0);
TestExceptionHandling(handler);
//
// -- Clean up classes:
//
repository->deleteClass(NS, testClass1);
repository->deleteClass(NS, testClass2);
repository->deleteClass(NS, testClass3);
repository->deleteClass(NS, testClass4);
repository->deleteClass(NS, testClass5);
repository->deleteClass(NS, testClass6);
repository->deleteClass(NS, testClass7);
repository->deleteClass(NS, testClass8);
//
// -- Delete the qualifier:
//
repository->deleteQualifier(NS, CIMName ("MappingStrings"));
repository->deleteQualifier(NS, CIMName ("NotMappingStrings"));
repository->deleteNameSpace(NS);
}
catch(Exception& e)
{
PEGASUS_STD(cerr) << "Error: " << e.getMessage() << PEGASUS_STD(endl);
exit(1);
}
delete repository;
cout << "+++++ passed all tests" << endl;
return 0;
}
static void CreateRepository(CIMRepository & repository)
{
repository.createNameSpace(NS);
Array<String> qualifierValue;
qualifierValue.append("");
CIMQualifierDecl q1(CIMName ("MappingStrings"), qualifierValue,
CIMScope::PROPERTY + CIMScope::CLASS);
// Qualifier name must be "MappingStrings", test the qualifier
// name is not "MappingStrings"
CIMQualifierDecl q2(CIMName ("NotMappingStrings"), qualifierValue,
CIMScope::CLASS);
repository.setQualifier(NS, q1);
repository.setQualifier(NS, q2);
Array<String> classMappingStr;
classMappingStr.append("OID.IETF | SNMP.1.3.6.1.4.1.892.2.3.9000.8600");
CIMClass class1(testClass1);
class1.addQualifier(CIMQualifier(CIMName ("MappingStrings"),
CIMValue(classMappingStr)));
Array<String> invalidFormatStr;
invalidFormatStr.append(
"Wrong format OID.IETF | SNMP.1.3.6.1.4.1.2.3.9000.8600");
invalidFormatStr.append("DataType.IETF | OctetString ");
// create wrong format property mappingStrings value
class1.addProperty(
CIMProperty(CIMName("OidDataType"), String("OctetString"))
.addQualifier(CIMQualifier(CIMName ("MappingStrings"),
CIMValue(invalidFormatStr))));
repository.createClass(NS, class1);
// create invalid mapping string value
Array<String> class2MappingStr;
Array<String> mappingStr2;
class2MappingStr.append("OID.IETF |Invalid Mapping String Value");
mappingStr2.append("OID.IETF | SNMP.1.3.6.1.4.1.2.3.9000.8600");
mappingStr2.append("DataType.IETF OctetString ");
CIMClass class2(testClass2);
class2.addQualifier(CIMQualifier(CIMName ("MappingStrings"),
CIMValue(class2MappingStr)));
class2.addProperty(CIMProperty(CIMName ("OidDataType"), String())
.addQualifier(CIMQualifier(CIMName ("MappingStrings"),
CIMValue(mappingStr2))));
repository.createClass(NS, class2);
// create non MappingStrings qualifier
CIMClass class3(testClass3);
class3.addQualifier(CIMQualifier(CIMName ("NotMappingStrings"),
CIMValue(classMappingStr)));
repository.createClass(NS, class3);
// error building ASN.1 representation
Array<String> class4MappingStr;
class4MappingStr.append("OID.IETF | SNMP.1.204.6.1.6.3.1.330.5.1.0 ");
CIMClass class4(testClass4);
class4.addQualifier(CIMQualifier(CIMName ("MappingStrings"),
CIMValue(class4MappingStr)));
repository.createClass(NS, class4);
// create incorrect class mappingStrings value
Array<String> class5MappingStr;
class5MappingStr.append("OID.IETF | SNMP.1.3.6.1.6.test.1.1.5.1.3 ");
CIMClass class5(testClass5);
class5.addQualifier(CIMQualifier(CIMName
("MappingStrings"), CIMValue(class5MappingStr)));
// create incorrect property name
class5.addProperty(
CIMProperty(CIMName ("WrongPropertyName"), String("OctetString"))
.addQualifier(CIMQualifier(CIMName ("MappingStrings"),
CIMValue(class5MappingStr))));
repository.createClass(NS, class5);
// create incorrect property mappingStrings value
Array<String> class6MappingStr;
class6MappingStr.append("OID.IETF | SNMP.1.3.6.1.6.3.1.1.0.1 ");
Array<String> mappingStr6;
mappingStr6.append("OID.IETF | SNMP.1.3.6.1.6.test.1.1.5.1.3");
mappingStr6.append("DataType.IETF | OctetString");
CIMClass class6(testClass6);
class6.addQualifier(CIMQualifier(CIMName ("MappingStrings"),
CIMValue(class6MappingStr)));
class6.addProperty(
CIMProperty(CIMName ("OidDataType"), String("OctetString"))
.addQualifier(CIMQualifier(CIMName ("MappingStrings"),
CIMValue(mappingStr6))));
repository.createClass(NS, class6);
// create unsupportted SNMP Data Type for the CIM property
Array<String> class7MappingStr;
class7MappingStr.append("OID.IETF | SNMP.1.3.6.1.6.3.1.1.5.1 ");
Array<String> mappingStr7;
mappingStr7.append("OID.IETF | SNMP.1.3.6.1.6.test.1.1.5.1.3");
mappingStr7.append("DataType.IETF | test ");
CIMClass class7(testClass7);
class7.addQualifier(CIMQualifier(CIMName ("MappingStrings"),
CIMValue(class7MappingStr)));
class7.addProperty(
CIMProperty(CIMName ("OidDataType"), String("test"))
.addQualifier(CIMQualifier(CIMName ("MappingStrings"),
CIMValue(mappingStr7))));
repository.createClass(NS, class7);
// create invalid syntax for MappingStrings qualifier
Array<String> invalidSyntax;
Array<String> class8MappingStr;
class8MappingStr.append("OID.IETF Invalid Syntax for MappingStrings");
Array<String> mappingStr8;
mappingStr8.append("OID.IETF | SNMP.1.3.6.1.4.1.2.3.9000.8600");
mappingStr8.append("DataType.IETF | OctetString ");
CIMClass class8(testClass8);
class8.addQualifier(CIMQualifier(CIMName ("MappingStrings"),
CIMValue(class8MappingStr)));
class8.addProperty(CIMProperty(CIMName ("OidDataType"), String())
.addQualifier(CIMQualifier(CIMName ("MappingStrings"),
CIMValue(mappingStr8))));
repository.createClass(NS, class8);
}
void Test01(Uint32 mode)
{
String repositoryRoot;
const char* tmpDir = getenv ("PEGASUS_TMP");
if (tmpDir == NULL)
{
repositoryRoot = ".";
}
else
{
repositoryRoot = tmpDir;
}
repositoryRoot.append("/repository");
FileSystem::removeDirectoryHier(repositoryRoot);
CIMRepository r (repositoryRoot, mode);
// Create a namespace:
const CIMNamespaceName NAMESPACE = CIMNamespaceName ("zzz");
r.createNameSpace(NAMESPACE);
// Create a qualifier (and read it back):
CIMQualifierDecl q1(CIMName ("abstract"), false, CIMScope::CLASS);
r.setQualifier(NAMESPACE, q1);
CIMConstQualifierDecl q2 = r.getQualifier(NAMESPACE, CIMName ("abstract"));
PEGASUS_TEST_ASSERT(q1.identical(q2));
// Create two simple classes:
CIMClass class1(CIMName ("Class1"));
class1.addQualifier(
CIMQualifier(CIMName ("abstract"), true, CIMFlavor::DEFAULTS));
CIMClass class2(CIMName ("Class2"), CIMName ("Class1"));
r.createClass(NAMESPACE, class1);
r.createClass(NAMESPACE, class2);
// Enumerate the class names:
Array<CIMName> classNames =
r.enumerateClassNames(NAMESPACE, CIMName(), true);
BubbleSort(classNames);
PEGASUS_TEST_ASSERT(classNames.size() == 2);
PEGASUS_TEST_ASSERT(classNames[0] == "Class1");
PEGASUS_TEST_ASSERT(classNames[1] == "Class2");
// Get the classes and determine if they are identical with input
CIMClass c1 = r.getClass(NAMESPACE, CIMName ("Class1"), true, true, false);
CIMClass c2 = r.getClass(NAMESPACE, CIMName ("Class2"), true, true, false);
PEGASUS_TEST_ASSERT(c1.identical(class1));
PEGASUS_TEST_ASSERT(c1.identical(class1));
Array<CIMClass> classes =
r.enumerateClasses(NAMESPACE, CIMName (), true, true, true);
// Attempt to delete Class1. It should fail since the class has
// children.
try
{
r.deleteClass(NAMESPACE, CIMName ("Class1"));
}
catch (CIMException& e)
{
PEGASUS_TEST_ASSERT(e.getCode() == CIM_ERR_CLASS_HAS_CHILDREN);
}
// Delete all classes created here:
r.deleteClass(NAMESPACE, CIMName ("Class2"));
r.deleteClass(NAMESPACE, CIMName ("Class1"));
// Be sure the classes are really gone:
try
{
CIMClass c1 = r.getClass(
NAMESPACE, CIMName ("Class1"), true, true, true);
PEGASUS_TEST_ASSERT(false);
}
catch (CIMException& e)
{
PEGASUS_TEST_ASSERT(e.getCode() == CIM_ERR_NOT_FOUND);
}
try
{
CIMClass c2 = r.getClass(
NAMESPACE, CIMName ("Class2"), true, true, true);
PEGASUS_TEST_ASSERT(false);
}
catch (CIMException& e)
{
PEGASUS_TEST_ASSERT(e.getCode() == CIM_ERR_NOT_FOUND);
}
FileSystem::removeDirectoryHier(repositoryRoot);
}
void TestAssociations(CIMRepository& r)
{
String nameSpace = "root";
{
CIMObjectPath instanceName = CIMObjectPath ("X.key=\"John Smith\"");
Array<CIMObjectPath> names = r.associatorNames(
nameSpace,
instanceName,
CIMName ("A"),
CIMName ("Y"),
"left",
"right");
assert(names.size() == 1);
Boolean cond = names[0] == CIMObjectPath("Y.key=\"John Jones\"");
assert(cond);
}
{
CIMObjectPath instanceName = CIMObjectPath ("X.key=\"John Smith\"");
Array<CIMObject> result = r.associators(
nameSpace,
instanceName,
CIMName ("a"),
CIMName ("y"),
"LEFT",
"RIGHT");
assert(result.size() == 1);
CIMObjectPath cimReference = result[0].getPath ();
CIMInstance cimInstance = CIMInstance(result[0]);
CIMClass tmpClass = r.getClass(nameSpace, cimInstance.getClassName());
CIMObjectPath tmpInstanceName = cimInstance.buildPath(tmpClass);
Boolean t = tmpInstanceName == CIMObjectPath("Y.key=\"John Jones\"");
assert(t);
// result[0].print();
}
{
CIMObjectPath instanceName = CIMObjectPath ("X.key=\"John Smith\"");
Array<CIMObjectPath> result = r.referenceNames(
nameSpace,
instanceName,
CIMName ("A"),
"left");
assert(result.size() == 1);
CIMObjectPath tmp = CIMObjectPath ("A."
"left=\"x.key=\\\"John Smith\\\"\","
"right=\"y.key=\\\"John Jones\\\"\"");
Boolean cond = (result[0] == tmp);
assert(cond);
}
{
CIMObjectPath instanceName = CIMObjectPath ("X.key=\"John Smith\"");
Array<CIMObject> result = r.references(
nameSpace,
instanceName,
CIMName ("A"),
"left");
assert(result.size() == 1);
CIMClass tmpClass = r.getClass(
nameSpace, CIMInstance(result[0]).getClassName());
CIMObjectPath tmpInstanceName =
CIMInstance(result[0]).buildPath(tmpClass);
CIMObjectPath tmp = CIMObjectPath ("A."
"left=\"x.key=\\\"John Smith\\\"\","
"right=\"y.key=\\\"John Jones\\\"\"");
Boolean cond = (tmpInstanceName == tmp);
assert(cond);
}
// Delete all the object we created:
{
// First delete the association:
CIMObjectPath assocInstanceName = CIMObjectPath ("A."
"left=\"x.key=\\\"John Smith\\\"\","
"right=\"y.key=\\\"John Jones\\\"\"");
r.deleteInstance(nameSpace, assocInstanceName);
}
}
