void TestInitRepo()
{
if (verbose) cout << ProgName << "-TestInitRepo()" << endl;
try
{
r->createNameSpace(NS);
}
catch (AlreadyExistsException&)
{
// Ignore this!
}
// -- Declare the key qualifier:
r->setQualifier(NS, CIMQualifierDecl(CIMName ("key"),true,CIMScope::PROPERTY));
r->setQualifier(NS, CIMQualifierDecl(CIMName ("description"),String(),(CIMScope::PROPERTY + CIMScope::CLASS)));
r->setQualifier(NS, CIMQualifierDecl(CIMName ("junk"),String(),(CIMScope::PROPERTY + CIMScope::CLASS)));
}
CIMQualifierDecl compilerDeclContext::lookupQualifierDecl(
const CIMNamespaceName &nameSpace,
const CIMName &qualifierName) const
{
const CIMQualifierDecl *pTheQualifier = 0;
if (_ot != compilerCommonDefs::USE_REPOSITORY) {
if ( (pTheQualifier =
_findQualifierInMemory(qualifierName)) )
return *pTheQualifier;
}
if (_repository && (_ot != compilerCommonDefs::IGNORE_REPOSITORY)) {
return _repository->_getQualifier(nameSpace, qualifierName);
}
return CIMQualifierDecl();
}
int main(int, char** argv)
{
Boolean verbose = (getenv("PEGASUS_TEST_VERBOSE")) ? true : false;
try
{
const String NAMESPACE = "/zzz";
// Create and populate a declaration context:
SimpleDeclContext context;
context.addQualifierDecl(NAMESPACE, CIMQualifierDecl
(CIMName ("abstract"),
false, CIMScope::CLASS, CIMFlavor::OVERRIDABLE));
context.addQualifierDecl(NAMESPACE, CIMQualifierDecl
(CIMName ("description"),
String(), CIMScope::CLASS, CIMFlavor::OVERRIDABLE));
context.addQualifierDecl(NAMESPACE, CIMQualifierDecl(CIMName ("q1"),
false, CIMScope::CLASS, CIMFlavor::OVERRIDABLE +
CIMFlavor::TOSUBCLASS));
context.addQualifierDecl(NAMESPACE, CIMQualifierDecl(CIMName ("q2"),
false, CIMScope::CLASS, CIMFlavor::TOSUBCLASS));
// ATTN: KS P1 29 Mar 2002 - Add Tests for Null Value
// ATTN: KS P1 29 Mar 2002 - Add tests for array values in Qualifier.
// Create qualifier list 1:
CIMQualifierList qualifiers0;
CIMQualifierList qualifiers1;
qualifiers1
.add(CIMQualifier(CIMName ("Abstract"), true))
.add(CIMQualifier(CIMName ("Description"),
String("CIMQualifier List 1")))
.add(CIMQualifier(CIMName ("q1"), false))
.add(CIMQualifier(CIMName ("q2"), false));
// Run the find, get, etc tests.
PEGASUS_TEST_ASSERT(qualifiers1.getCount() == 4);
PEGASUS_TEST_ASSERT(qualifiers1.find(CIMName ("Abstract")) == 0);
PEGASUS_TEST_ASSERT(qualifiers1.exists(CIMName ("Abstract")));
PEGASUS_TEST_ASSERT(qualifiers1.isTrue(CIMName ("Abstract")));
PEGASUS_TEST_ASSERT(qualifiers1.exists(CIMName ("q1")));
PEGASUS_TEST_ASSERT(!qualifiers1.isTrue(CIMName ("q1")));
PEGASUS_TEST_ASSERT(qualifiers1.exists(CIMName ("q2")));
PEGASUS_TEST_ASSERT(!qualifiers1.isTrue(CIMName ("q2")));
PEGASUS_TEST_ASSERT(qualifiers1.find(CIMName ("QualifierDoesNotExist")) ==
PEG_NOT_FOUND);
PEGASUS_TEST_ASSERT(!qualifiers1.exists(CIMName("QualifierDoesNotExist")));
qualifiers1.resolve(
&context, NAMESPACE, CIMScope::CLASS, false, qualifiers0, true);
// Qualifiers after the resolve. Should have resolved against the
// declarations.
PEGASUS_TEST_ASSERT(qualifiers1.getCount() == 4);
PEGASUS_TEST_ASSERT(qualifiers1.find(CIMName ("Abstract")) == 0);
PEGASUS_TEST_ASSERT(qualifiers1.exists(CIMName ("Abstract")));
PEGASUS_TEST_ASSERT(qualifiers1.isTrue(CIMName ("Abstract")));
PEGASUS_TEST_ASSERT(qualifiers1.exists(CIMName ("q1")));
PEGASUS_TEST_ASSERT(!qualifiers1.isTrue(CIMName ("q1")));
PEGASUS_TEST_ASSERT(qualifiers1.exists(CIMName ("q2")));
PEGASUS_TEST_ASSERT(!qualifiers1.isTrue(CIMName ("q2")));
PEGASUS_TEST_ASSERT(qualifiers1.find(CIMName ("QualifierDoesNotExist")) ==
PEG_NOT_FOUND);
PEGASUS_TEST_ASSERT(!qualifiers1.exists(CIMName("QualifierDoesNotExist")));
if(verbose)
qualifiers1.print();
// Add test for double add of a name
Boolean exceptionCaught = false;
try
{
qualifiers1.add(CIMQualifier(CIMName ("Abstract"), true));
}
catch (Exception&)
{
exceptionCaught = true;
}
PEGASUS_TEST_ASSERT(exceptionCaught);
// Test some of the basics again after the double insertion problem
PEGASUS_TEST_ASSERT(qualifiers1.getCount() == 4);
PEGASUS_TEST_ASSERT(qualifiers1.find(CIMName ("Abstract")) == 0);
PEGASUS_TEST_ASSERT(qualifiers1.exists(CIMName ("Abstract")));
PEGASUS_TEST_ASSERT(qualifiers1.isTrue(CIMName ("Abstract")));
// Create qualifier list 2: Will be resolved against qualifiers1
CIMQualifierList qualifiers2;
qualifiers2
.add(CIMQualifier(CIMName ("Description"),
String("CIMQualifier List 1")))
.add(CIMQualifier(CIMName ("q1"), Boolean(true),
CIMFlavor::OVERRIDABLE));
if(verbose)
qualifiers2.print();
PEGASUS_TEST_ASSERT(qualifiers2.getCount() == 2);
PEGASUS_TEST_ASSERT(qualifiers2.exists(CIMName ("Description")));
PEGASUS_TEST_ASSERT(qualifiers2.exists(CIMName ("q1")));
PEGASUS_TEST_ASSERT(qualifiers2.isTrue(CIMName ("q1")));
// Resolve the qualifiers against the previous list qualifiers1
qualifiers2.resolve(
&context, NAMESPACE, CIMScope::CLASS, false, qualifiers1, true);
if(verbose)
qualifiers2.print();
// Post resolution
PEGASUS_TEST_ASSERT(qualifiers2.getCount() == 4);
PEGASUS_TEST_ASSERT(qualifiers2.exists(CIMName ("Description")));
PEGASUS_TEST_ASSERT(qualifiers2.exists(CIMName ("abstract")));
PEGASUS_TEST_ASSERT(qualifiers2.isTrue(CIMName ("abstract")));
PEGASUS_TEST_ASSERT(qualifiers2.exists(CIMName ("q1")));
PEGASUS_TEST_ASSERT(qualifiers2.isTrue(CIMName ("q1")));
PEGASUS_TEST_ASSERT(qualifiers2.exists(CIMName ("q2")));
// Should inherit the value from the superclass
PEGASUS_TEST_ASSERT(!qualifiers2.isTrue(CIMName ("q2")));
}
catch (Exception& e)
{
cerr << "Exception: " << e.getMessage() << endl;
exit(1);
}
cout << argv[0] << " +++++ passed all tests" << endl;
return 0;
}
int main(int argc, char** argv)
{
#ifdef IO
verbose = getenv("PEGASUS_TEST_VERBOSE") ? true : false;
if (verbose)
cout << "Test CIMValue. To turn off display, compile with IO undefined\n";
#endif
// Test the primitive CIMValue types with test01
test01(Boolean(true));
test01(Boolean(false));
test01(Char16('Z'));
test01(Uint8(77));
test01(Sint8(-77));
test01(Sint16(77));
test01(Uint16(-77));
test01(Sint32(77));
test01(Uint32(-77));
test01(Sint64(77));
test01(Uint64(-77));
test01(Real32(1.5));
test01(Real64(55.5));
test01(Uint64(123456789));
test01(Sint64(-123456789));
test01(String("Hello world"));
test01(CIMDateTime("19991224120000.000000+360"));
test01(CIMObjectPath(
"//host1:77/root/test:Class1.key1=\"key1Value\",key2=\"key2Value\""));
// Create and populate a declaration context:
const CIMNamespaceName NAMESPACE = CIMNamespaceName ("/zzz");
SimpleDeclContext* context = new SimpleDeclContext;
context->addQualifierDecl(
NAMESPACE, CIMQualifierDecl(CIMName ("counter"), false,
CIMScope::PROPERTY));
context->addQualifierDecl(
NAMESPACE, CIMQualifierDecl(CIMName ("classcounter"), false,
CIMScope::CLASS));
context->addQualifierDecl(
NAMESPACE, CIMQualifierDecl(CIMName ("min"), String(),
CIMScope::PROPERTY));
context->addQualifierDecl(
NAMESPACE, CIMQualifierDecl(CIMName ("max"), String(),
CIMScope::PROPERTY));
context->addQualifierDecl(NAMESPACE,
CIMQualifierDecl(CIMName ("Description"), String(),
CIMScope::PROPERTY));
CIMClass class1(CIMName ("MyClass"));
class1
.addProperty(CIMProperty(CIMName ("count"), Uint32(55))
.addQualifier(CIMQualifier(CIMName ("counter"), true))
.addQualifier(CIMQualifier(CIMName ("min"), String("0")))
.addQualifier(CIMQualifier(CIMName ("max"), String("1"))))
.addProperty(CIMProperty(CIMName ("message"), String("Hello"))
.addQualifier(CIMQualifier(CIMName ("description"),
String("My Message"))))
.addProperty(CIMProperty(CIMName ("ratio"), Real32(1.5)));
Resolver::resolveClass (class1, context, NAMESPACE);
context->addClass(NAMESPACE, class1);
// Test a CIMObject that is a CIMClass
test01(CIMObject(class1));
// Test a CIMObject that is a CIMInstance
CIMInstance instance1(CIMName ("MyClass"));
instance1.addQualifier(CIMQualifier(CIMName ("classcounter"), true));
instance1.addProperty(CIMProperty(CIMName ("message"), String("Goodbye")));
Resolver::resolveInstance (instance1, context, NAMESPACE, true);
test01(CIMObject(instance1));
testEmbeddedValue<CIMObject>(instance1);
testEmbeddedValue<CIMInstance>(instance1);
// Test CIMValue arrays
Array<Uint8> arr1;
arr1.append(11);
arr1.append(22);
arr1.append(23);
test02(arr1);
Array<Uint16> arr2;
arr2.append(333);
arr2.append(444);
arr2.append(445);
test02(arr2);
Array<Uint32> arr3;
arr3.append(5555);
arr3.append(6666);
arr3.append(6667);
test02(arr3);
Array<Uint64> arr4;
arr4.append(123456789);
arr4.append(987654321);
arr4.append(987654322);
test02(arr4);
Array<Sint8> arr5;
arr5.append(-11);
arr5.append(-22);
arr5.append(-23);
test02(arr5);
Array<Sint16> arr6;
arr6.append(333);
arr6.append(444);
arr6.append(555);
test02(arr6);
Array<Sint32> arr7;
arr7.append(555);
arr7.append(666);
arr7.append(777);
test02(arr7);
Array<Sint64> arr8;
arr8.append(-123456789);
arr8.append(-987654321);
arr8.append(-987654321);
test02(arr8);
Array<Boolean> arr9;
arr9.append(true);
arr9.append(false);
arr9.append(false);
test02(arr9);
Array<Real32> arr10;
arr10.append(1.55F);
arr10.append(2.66F);
arr10.append(3.77F);
test02(arr10);
Array<Real64> arr11;
arr11.append(55.55);
arr11.append(66.66);
arr11.append(77.77);
test02(arr11);
Array<Char16> arr12;
arr12.append('X');
arr12.append('Y');
arr12.append('Z');
test02(arr12);
Array<String> arr13;
arr13.append("One");
arr13.append("Two");
arr13.append("Three");
test02(arr13);
Array<CIMDateTime> arr14;
arr14.append(CIMDateTime ("20020130120000.000000+360"));
arr14.append(CIMDateTime ("20020201120000.000000+360"));
arr14.append(CIMDateTime ("20020202120000.000000+360"));
test02(arr14);
Array<CIMObjectPath> arr15;
arr15.append(CIMObjectPath(
"//host1:77/root/test:Class1.key1=\"key1Value\",key2=\"key2Value\""));
arr15.append(CIMObjectPath(
"//host2:88/root/static:Class2.keyA=\"keyAValue\",keyB="
"\"keyBValue\""));
arr15.append(CIMObjectPath(
"//host3:99/root/test/static:Class3.keyX=\"keyXValue\","
"keyY=\"keyYValue\""));
test02(arr15);
testEmbeddedValueArray<CIMObject>(instance1, NAMESPACE, context);
testEmbeddedValueArray<CIMInstance>(instance1, NAMESPACE, context);
// Calling remaining Array tests..
CIMDateTime D1("19991224120000.000000+100");
Array<CIMDateTime> arrD1(10,D1);
CIMDateTime *D2 = new CIMDateTime("19991224120000.000000+100");
Array<CIMDateTime> arrD2(D2,1);
test03(arrD1, arrD2, D2, CIMDateTime("19991224120000.000000+100"),
CIMDateTime("29991224120000.000000+100"));
delete D2;
CIMName cimname1("yourName");
Array<CIMName> arrcimname1(10,cimname1);
CIMName *cimname2 = new CIMName("yourName");
Array<CIMName> arrcimname2(cimname2,1);
test03(arrcimname1, arrcimname2, cimname2, CIMName("yourName"),
CIMName("myName"));
delete cimname2;
CIMKeyBinding cimbind1(cimname1, "myKey", CIMKeyBinding::STRING);
CIMKeyBinding cimbind2(cimname1, "yourKey", CIMKeyBinding::STRING);
Array<CIMKeyBinding> arrcimbind1(10,cimbind1);
CIMKeyBinding *cimbind3 =
new CIMKeyBinding(cimname1, "myKey", CIMKeyBinding::STRING);
Array<CIMKeyBinding> arrcimbind2(cimbind3,1);
test03(arrcimbind1, arrcimbind2, cimbind3, cimbind1, cimbind2 );
delete cimbind3;
CIMNamespaceName cimnamespace1("root/SampleProvider");
Array<CIMNamespaceName> arrcimnamespace1(10,cimnamespace1);
CIMNamespaceName *cimnamespace2 = new CIMNamespaceName(
"root/SampleProvider");
Array<CIMNamespaceName> arrcimnamespace2(cimnamespace2,1);
test03(arrcimnamespace1, arrcimnamespace2, cimnamespace2,
CIMNamespaceName("root/SampleProvider"),
CIMNamespaceName("root/SampleProvider2"));
delete cimnamespace2;
Array<Boolean> arrB1(10,true);
Boolean *b = new Boolean(true);
Array<Boolean> arrB2(b,1);
Array<Boolean> arrB3(2);
Boolean b1 = true, b2=false;
test03(arrB1, arrB2, b, Boolean(true),Boolean(false));
delete b;
Array<Real32> arrreal321(10);
Real32 creal321(2.5);
Array<Real32> arrreal322(10, creal321);
Real32 *creal322 = new Real32(2.5);
Array<Real32> arrreal323(creal322,1);
Array<Real32> arrreal324(arrreal321);
test03(arrreal322, arrreal323, creal322,Real32(2.5),Real32(3.5));
delete creal322;
Array<Real64> arrreal641(10);
Real64 creal641(20000.54321);
Array<Real64> arrreal642(10, creal641);
Real64 *creal642 = new Real64(20000.54321);
Array<Real64> arrreal643(creal642,1);
Array<Real64> arrreal644(arrreal641);
test03(arrreal642, arrreal643, creal642,Real64(20000.54321),
Real64(30000.54321));
delete creal642;
Array<Sint16> arrSint161(10);
Sint16 cSint161(-2000);
Array<Sint16> arrSint162(10, cSint161);
Sint16 *cSint162 = new Sint16(-2000);
Array<Sint16> arrSint163(cSint162,1);
Array<Sint16> arrSint164(arrSint161);
test03(arrSint162, arrSint163, cSint162, Sint16(-2000), Sint16(-3000));
delete cSint162;
Array<Sint32> arrSint321(10);
Sint32 cSint321(-200000000);
Array<Sint32> arrSint322(10, cSint321);
Sint32 *cSint322 = new Sint32(-200000000);
Array<Sint32> arrSint323(cSint322,1);
Array<Sint32> arrSint324(arrSint321);
test03(arrSint322, arrSint323, cSint322, Sint32(-200000000),
Sint32(-300000000));
delete cSint322;
Array<Sint64> arrSint641(10);
Sint64 cSint641(Sint64(-2000000)*Sint64(10000000) );
Array<Sint64> arrSint642(10, cSint641);
Sint64 *cSint642 = new Sint64(Sint64(-2000000)*Sint64(10000000));
Array<Sint64> arrSint643(cSint642,1);
Array<Sint64> arrSint644(arrSint641);
test03(arrSint642, arrSint643, cSint642,Sint64(-2000000)*Sint64(10000000),
Sint64(-3000000)*Sint64(10000000));
delete cSint642;
Array<Sint8> arrSint81(10);
Sint8 cSint81(-20);
Array<Sint8> arrSint82(10, cSint81);
Sint8 *cSint82 = new Sint8(-20);
Array<Sint8> arrSint83(cSint82,1);
Array<Sint8> arrSint84(arrSint81);
test03(arrSint82, arrSint83, cSint82, Sint8(-20), Sint8(-22));
delete cSint82;
Array<Uint16> arrUint161(10);
Uint16 cUint161(200);
Array<Uint16> arrUint162(10, cUint161);
Uint16 *cUint162 = new Uint16(200);
Array<Uint16> arrUint163(cUint162,1);
Array<Uint16> arrUint164(arrUint161);
test03(arrUint162, arrUint163, cUint162, Uint16(200), Uint16(255));
delete cUint162;
Array<Uint32> arrUint321(10);
Uint32 cUint321(2000);
Array<Uint32> arrUint322(10, cUint321);
Uint32 *cUint322 = new Uint32(2000);
Array<Uint32> arrUint323(cUint322,1);
Array<Uint32> arrUint324(arrUint321);
test03(arrUint322, arrUint323, cUint322, Uint32(2000), Uint32(3000));
delete cUint322;
Array<Uint64> arrUint641(10);
Uint64 cUint641(Uint64(2000000)*Uint64(10000000));
Array<Uint64> arrUint642(10, cUint641);
Uint64 *cUint642 = new Uint64(Uint64(2000000)*Uint64(10000000));
Array<Uint64> arrUint643(cUint642,1);
Array<Uint64> arrUint644(arrUint641);
test03(arrUint642, arrUint643, cUint642,Uint64(2000000)*Uint64(10000000),
Uint64(255000)*Uint64(10000000));
delete cUint642;
Array<Uint8> arrUint81(10);
Uint8 cUint81(200);
Array<Uint8> arrUint82(10, cUint81);
Uint8 *cUint82 = new Uint8(200);
Array<Uint8> arrUint83(cUint82,1);
Array<Uint8> arrUint84(arrUint81);
test03(arrUint82, arrUint83, cUint82, Uint8(200), Uint8(255));
delete cUint82;
Array<Char16> arrChar161(10);
Char16 cChar161('Z');
Array<Char16> arrChar162(10, cChar161);
Char16 *cChar162 = new Char16('Z');
Array<Char16> arrChar163(cChar162,1);
Array<Char16> arrChar164(arrChar161);
test03(arrChar162, arrChar163, cChar162, Char16('Z'), Char16('z'));
delete cChar162;
delete context;
cout << argv[0] << " +++++ passed all tests" << endl;
return 0;
}
CIMQualifierDecl CIMConstQualifierDecl::clone() const
{
return CIMQualifierDecl(_rep->clone());
}
void test01()
{
const CIMNamespaceName NAMESPACE = CIMNamespaceName("/zzz");
// Create and populate a declaration context:
SimpleDeclContext* context = new SimpleDeclContext;
context->addQualifierDecl(
NAMESPACE, CIMQualifierDecl(CIMName("counter"), false,
CIMScope::PROPERTY));
context->addQualifierDecl(
NAMESPACE, CIMQualifierDecl(CIMName("classcounter"), false,
CIMScope::CLASS));
context->addQualifierDecl(
NAMESPACE, CIMQualifierDecl(CIMName("min"), String(),
CIMScope::PROPERTY));
context->addQualifierDecl(
NAMESPACE, CIMQualifierDecl(CIMName("max"), String(),
CIMScope::PROPERTY));
context->addQualifierDecl(NAMESPACE,
CIMQualifierDecl(CIMName("Description"), String(),
CIMScope::PROPERTY));
CIMClass class1(CIMName("MyClass"));
class1
.addProperty(CIMProperty(CIMName("count"), Uint32(55))
.addQualifier(CIMQualifier(CIMName("counter"), true))
.addQualifier(CIMQualifier(CIMName("min"), String("0")))
.addQualifier(CIMQualifier(CIMName("max"), String("1"))))
.addProperty(CIMProperty(CIMName("message"), String("Hello"))
.addQualifier(CIMQualifier(CIMName("description"),
String("My Message"))))
.addProperty(CIMProperty(CIMName("ratio"), Real32(1.5)));
// Test
assert(class1.findProperty(CIMName("count")) != PEG_NOT_FOUND);
assert(class1.findProperty(CIMName("message")) != PEG_NOT_FOUND);
assert(class1.findProperty(CIMName("ratio")) != PEG_NOT_FOUND);
Resolver::resolveClass(class1, context, NAMESPACE);
context->addClass(NAMESPACE, class1);
if (verbose)
{
XmlWriter::printClassElement(class1);
}
CIMInstance instance0(CIMName("MyClass"));
assert(instance0.getClassName().equal(CIMName("MyClass")));
instance0.setPath(CIMObjectPath("//localhost/root/cimv2:MyClass.Foo=1"));
assert(instance0.getPath() ==
CIMObjectPath("//localhost/root/cimv2:MyClass.Foo=1"));
CIMInstance instance1(CIMName("MyClass"));
instance1.addQualifier(CIMQualifier(CIMName("classcounter"), true));
instance1.addProperty(CIMProperty(CIMName("message"), String("Goodbye")));
assert(instance1.findProperty(CIMName("message")) != PEG_NOT_FOUND);
assert(instance1.findProperty(CIMName("count")) == PEG_NOT_FOUND);
assert(instance1.findProperty(CIMName("ratio")) == PEG_NOT_FOUND);
assert(instance1.findProperty(CIMName("nuts")) == PEG_NOT_FOUND);
assert(instance1.getPropertyCount() == 1);
if (verbose)
{
XmlWriter::printInstanceElement(instance1);
}
Resolver::resolveInstance(instance1, context, NAMESPACE, true);
if (verbose)
{
XmlWriter::printInstanceElement(instance1);
}
// Now test for properties after resolution.
assert(instance1.findProperty(CIMName("message")) != PEG_NOT_FOUND);
assert(instance1.findProperty(CIMName("count")) != PEG_NOT_FOUND);
assert(instance1.findProperty(CIMName("ratio")) != PEG_NOT_FOUND);
assert(instance1.findProperty(CIMName("nuts")) == PEG_NOT_FOUND);
assert(instance1.getPropertyCount() == 3);
// Now remove a property
Uint32 posProperty;
posProperty = instance1.findProperty(CIMName("count"));
instance1.removeProperty(posProperty);
assert(instance1.findProperty(CIMName("message")) != PEG_NOT_FOUND);
assert(instance1.findProperty(CIMName("count")) == PEG_NOT_FOUND);
assert(instance1.findProperty(CIMName("ratio")) != PEG_NOT_FOUND);
assert(instance1.findProperty(CIMName("nuts")) == PEG_NOT_FOUND);
assert(instance1.getPropertyCount() == 2);
// Instance qualifier tests
CIMQualifier cq=instance1.getQualifier(instance1.findQualifier(
CIMName("classcounter")));
const CIMInstance instance2 = instance1.clone();
assert(instance2.identical(instance1));
assert(instance1.findQualifier(CIMName("nuts")) == PEG_NOT_FOUND);
assert(instance2.findQualifier(CIMName("nuts")) == PEG_NOT_FOUND);
assert(instance1.getQualifierCount() != 4);
assert(instance1.getQualifierCount() == 1);
assert(instance2.getQualifierCount() == 1);
if (verbose)
{
XmlWriter::printInstanceElement(instance2);
}
// Tests for CIMConstInstance
CIMConstInstance cinstance1(CIMName("MyClass")), cinstance3;
CIMConstInstance ccopy(cinstance1);
cinstance1 = instance1;
assert(cinstance1.identical(instance1));
assert(cinstance1.getQualifierCount() == 1);
CIMConstQualifier ccq = cinstance1.getQualifier(cinstance1.findQualifier(
CIMName("classcounter")));
assert(cinstance1.findProperty(CIMName("message")) != PEG_NOT_FOUND);
CIMConstProperty ccp =
cinstance1.getProperty(cinstance1.findProperty(CIMName("message")));
cinstance3 = cinstance1;
assert(cinstance3.identical(cinstance1));
assert(cinstance1.getClassName() == CIMName("MyClass"));
assert(cinstance1.getClassName().equal(CIMName("MyClass")));
assert(cinstance1.getClassName().equal(CIMName("MYCLASS")));
assert(cinstance1.getClassName().equal(CIMName("myclass")));
assert(!cinstance1.getClassName().equal(CIMName("blob")));
assert(cinstance1.getQualifierCount() != 4);
assert(cinstance1.getPropertyCount() == 2);
CIMConstInstance cinstance2 = cinstance1.clone();
assert(cinstance2.identical(cinstance1));
if (verbose)
{
XmlWriter::printInstanceElement(cinstance1);
}
cinstance1.buildPath(class1);
assert( !cinstance1.isUninitialized() );
delete context;
}
//
// Test of the Instance creation and instance filtering
//
void test04()
{
if (verbose)
{
cout << "Test04 - Create instance from Class. " << endl;
}
const CIMNamespaceName NAMESPACE = CIMNamespaceName("/zzz");
// Create and populate a declaration context:
SimpleDeclContext* context = new SimpleDeclContext;
context->addQualifierDecl(
NAMESPACE, CIMQualifierDecl(CIMName("counter"), false,
CIMScope::PROPERTY));
context->addQualifierDecl(
NAMESPACE, CIMQualifierDecl(CIMName("classcounter"), false,
CIMScope::CLASS));
context->addQualifierDecl(
NAMESPACE, CIMQualifierDecl(CIMName("min"), String(),
CIMScope::PROPERTY));
context->addQualifierDecl(
NAMESPACE, CIMQualifierDecl(CIMName("max"), String(),
CIMScope::PROPERTY));
context->addQualifierDecl(NAMESPACE,
CIMQualifierDecl(CIMName("Description"), String(),
CIMScope::PROPERTY));
CIMClass class1(CIMName("MyClass"));
class1
.addProperty(CIMProperty(CIMName("count"), Uint32(55))
.addQualifier(CIMQualifier(CIMName("counter"), true))
.addQualifier(CIMQualifier(CIMName("min"), String("0")))
.addQualifier(CIMQualifier(CIMName("max"), String("1"))))
.addProperty(CIMProperty(CIMName("message"), String("Hello"))
.addQualifier(CIMQualifier(CIMName("description"),
String("My Message"))))
.addProperty(CIMProperty(CIMName("ratio"), Real32(1.5)));
Resolver::resolveClass(class1, context, NAMESPACE);
context->addClass(NAMESPACE, class1);
if (verbose)
{
XmlWriter::printClassElement(class1);
}
//
// Create instance with qualifiers, classorigin, and Null propertyList
//
{
CIMInstance newInstance;
newInstance = class1.buildInstance(true, true, CIMPropertyList());
if (verbose)
{
XmlWriter::printInstanceElement(newInstance);
}
assert(newInstance.getPropertyCount() == class1.getPropertyCount());
assert(newInstance.getQualifierCount() == class1.getQualifierCount());
assert(newInstance.findProperty("ratio") != PEG_NOT_FOUND);
assert(newInstance.findProperty("message") != PEG_NOT_FOUND);
}
//
// Test with include qualifiers false. Should be no qualifiers in result
//
{
CIMInstance newInstance =
class1.buildInstance(false, true, CIMPropertyList());
assert(newInstance.getQualifierCount() == 0);
assert(newInstance.getPropertyCount() == class1.getPropertyCount());
assert(newInstance.findProperty("ratio") != PEG_NOT_FOUND);
assert(newInstance.findProperty("message") != PEG_NOT_FOUND);
}
//
// Test with empty property list. Should have no properties.
//
{
Array<CIMName> pl1Array;
CIMPropertyList pl1(pl1Array);
CIMInstance newInstance = class1.buildInstance(false, true, pl1);
assert(newInstance.getQualifierCount() == 0);
assert(newInstance.getPropertyCount() == 0);
}
//
// Test with a property that exists in property list.
//
{
Array<CIMName> pl1Array;
pl1Array.append("ratio");
CIMPropertyList pl1(pl1Array);
CIMInstance newInstance = class1.buildInstance(false, true, pl1);
if (verbose)
{
cout << "Test with one property in new instance" << endl;
XmlWriter::printInstanceElement(newInstance);
}
assert(newInstance.getPropertyCount() == 1);
assert(newInstance.findProperty("ratio") != PEG_NOT_FOUND);
assert(newInstance.findProperty("message") == PEG_NOT_FOUND);
assert(newInstance.getQualifierCount() == 0);
}
//
// Test with a property that does/does not exist in property list
//
{
Array<CIMName> pl1Array;
CIMPropertyList pl1(pl1Array);
pl1.clear();
pl1Array.append("blob");
pl1Array.append("ratio");
pl1.set(pl1Array);
CIMInstance newInstance = class1.buildInstance(false, true, pl1);
assert(newInstance.getPropertyCount() == 1);
assert(newInstance.findProperty("ratio") != PEG_NOT_FOUND);
assert(newInstance.findProperty("blob") == PEG_NOT_FOUND);
assert(newInstance.findProperty("message") == PEG_NOT_FOUND);
assert(newInstance.getQualifierCount() == 0);
}
///////////////////////////////////////////////////////////////////////
//
// Instance Filtering function tests
//
///////////////////////////////////////////////////////////////////////
// build instance as starting point for tests.
CIMInstance tstInstance =
class1.buildInstance(true, true, CIMPropertyList());
//
// Test complete copy, no change
//
{
if (verbose)
{
cout << "Test1" << endl;
}
CIMInstance filterInstance = tstInstance.clone();
filterInstance.filter(true, true, CIMPropertyList());
assert(tstInstance.identical(filterInstance));
assert(filterInstance.getPropertyCount() == 3);
assert(filterInstance.getQualifierCount() ==
tstInstance.getQualifierCount());
}
//
// Filter to one property, ratio
//
{
if (verbose)
{
cout << "Test2" << endl;
}
Array<CIMName> pl1Array;
pl1Array.append("ratio");
CIMPropertyList pl1(pl1Array);
CIMInstance filterInstance = tstInstance.clone();
filterInstance.filter(true, true, pl1);
if (verbose)
{
XmlWriter::printInstanceElement(filterInstance);
}
assert(filterInstance.getPropertyCount() == 1);
assert(filterInstance.findProperty("ratio") != PEG_NOT_FOUND);
assert(_propertyIdentical("ratio", filterInstance, tstInstance));
assert(filterInstance.getQualifierCount() ==
tstInstance.getQualifierCount());
}
//
// Filter to one property, message
//
{
if (verbose)
{
cout << "Test3" << endl;
}
Array<CIMName> pl1Array;
pl1Array.append("message");
CIMPropertyList pl1(pl1Array);
CIMInstance filterInstance = tstInstance.clone();
filterInstance.filter(true, true, pl1);
if (verbose)
{
XmlWriter::printInstanceElement(filterInstance);
}
assert(filterInstance.getPropertyCount() == 1);
assert(filterInstance.findProperty("message") != PEG_NOT_FOUND);
assert(_propertyIdentical("message", filterInstance, tstInstance));
assert(filterInstance.getQualifierCount() ==
tstInstance.getQualifierCount());
}
//
// Filter to one property, count
//
{
if (verbose)
{
cout << "Test4" << endl;
}
Array<CIMName> pl1Array;
pl1Array.append("count");
CIMPropertyList pl1(pl1Array);
CIMInstance filterInstance = tstInstance.clone();
filterInstance.filter(true, true, pl1);
if (verbose)
{
XmlWriter::printInstanceElement(filterInstance);
}
assert(filterInstance.getPropertyCount() == 1);
assert(filterInstance.findProperty("count") != PEG_NOT_FOUND);
assert(filterInstance.getQualifierCount() ==
tstInstance.getQualifierCount());
}
//
// Filter to no properties
//
{
if (verbose)
{
cout << "Test5a" << endl;
}
Array<CIMName> pl1Array;
CIMPropertyList pl1(pl1Array);
CIMInstance filterInstance = tstInstance.clone();
filterInstance.filter(true, true, pl1);
assert(filterInstance.getPropertyCount() == 0);
assert(filterInstance.findProperty("ratio") == PEG_NOT_FOUND);
assert(filterInstance.getQualifierCount() ==
tstInstance.getQualifierCount());
}
//
// Filter to two properties
//
{
if (verbose)
{
cout << "Test5b" << endl;
}
Array<CIMName> pl1Array;
pl1Array.append("count");
pl1Array.append("message");
CIMPropertyList pl1(pl1Array);
CIMInstance filterInstance = tstInstance.clone();
filterInstance.filter(true, true, pl1);
assert(filterInstance.getPropertyCount() == 2);
assert(filterInstance.findProperty("ratio") == PEG_NOT_FOUND);
assert(filterInstance.findProperty("message") != PEG_NOT_FOUND);
assert(_propertyIdentical("message", filterInstance, tstInstance));
assert(filterInstance.findProperty("count") != PEG_NOT_FOUND);
assert(_propertyIdentical("count", filterInstance, tstInstance));
assert(filterInstance.getQualifierCount() ==
tstInstance.getQualifierCount());
}
//
// Filter to no qualifiers and all properties.
//
{
if (verbose)
{
cout << "Test6" << endl;
}
CIMInstance filterInstance = tstInstance.clone();
filterInstance.filter(false, true, CIMPropertyList());
assert(filterInstance.getPropertyCount() == 3);
assert(filterInstance.findProperty("ratio") != PEG_NOT_FOUND);
assert(filterInstance.getQualifierCount() == 0);
for (Uint32 i = 0; i < filterInstance.getPropertyCount() ; i++)
{
CIMConstProperty p = filterInstance.getProperty(i);
assert(p.getQualifierCount() == 0);
}
}
//
// Filter to no qualifiers and no properties.
//
{
if (verbose)
{
cout << "Test6a" << endl;
}
Array<CIMName> pl1Array;
CIMPropertyList pl1(pl1Array);
CIMInstance filterInstance = tstInstance.clone();
filterInstance.filter(false, true, pl1);
assert(filterInstance.getPropertyCount() == 0);
assert(filterInstance.findProperty("ratio") == PEG_NOT_FOUND);
assert(filterInstance.getQualifierCount() == 0);
}
//
// Test Class Origin Filter
//
{
if (verbose)
{
cout << "Test7 Class Origin" << endl;
}
// Create a subclass to do classOrigin testing
CIMClass mySubClass(CIMName("subclass"));
mySubClass.setSuperClassName(CIMName("MyClass"));
Resolver::resolveClass(mySubClass, context, NAMESPACE);
context->addClass(NAMESPACE, mySubClass);
// build instance
CIMInstance filterInstance =
mySubClass.buildInstance(true, true, CIMPropertyList());
filterInstance.filter(false, true, CIMPropertyList());
assert(filterInstance.getPropertyCount() == 3);
assert(filterInstance.findProperty("ratio") != PEG_NOT_FOUND);
assert(filterInstance.getQualifierCount() == 0);
for (Uint32 i = 0 ; i < filterInstance.getPropertyCount() ; i++)
{
CIMProperty p = filterInstance.getProperty(i);
assert(!(p.getClassOrigin() == CIMName()));
}
filterInstance.filter(false, false, CIMPropertyList());
for (Uint32 i = 0 ; i < filterInstance.getPropertyCount() ; i++)
{
CIMProperty p = filterInstance.getProperty(i);
assert(p.getClassOrigin() == CIMName());
}
CIMInstance filterInstance2 =
mySubClass.buildInstance(true, false, CIMPropertyList());
for (Uint32 i = 0 ; i < filterInstance2.getPropertyCount() ; i++)
{
CIMProperty p = filterInstance2.getProperty(i);
assert(p.getClassOrigin() == CIMName());
}
}
delete context;
}
