Boolean CIMKeyBinding::equal(CIMValue value)
{
if (value.isArray())
{
return false;
}
CIMValue kbValue;
try
{
switch (value.getType())
{
case CIMTYPE_CHAR16:
if (getType() != STRING) return false;
kbValue.set(getValue()[0]);
break;
case CIMTYPE_DATETIME:
if (getType() != STRING) return false;
kbValue.set(CIMDateTime(getValue()));
break;
case CIMTYPE_STRING:
if (getType() != STRING) return false;
kbValue.set(getValue());
break;
case CIMTYPE_REFERENCE:
if (getType() != REFERENCE) return false;
kbValue.set(CIMObjectPath(getValue()));
break;
case CIMTYPE_BOOLEAN:
if (getType() != BOOLEAN) return false;
kbValue = XmlReader::stringToValue(0, getValue().getCString(),
value.getType());
break;
// case CIMTYPE_REAL32:
// case CIMTYPE_REAL64:
case CIMTYPE_OBJECT:
case CIMTYPE_INSTANCE:
// From PEP 194: EmbeddedObjects cannot be keys.
return false;
default: // Numerics
if (getType() != NUMERIC) return false;
kbValue = XmlReader::stringToValue(0, getValue().getCString(),
value.getType());
break;
}
}
catch (Exception&)
{
return false;
}
return value.equal(kbValue);
}
/**
Function to convert CMPIValue to CIMValue
*/
CIMValue value2CIMValue(const CMPIValue* data, const CMPIType type, CMPIrc *rc)
{
CIMValue v;
if( rc )
{
*rc=CMPI_RC_OK;
}
/**
check data for NULL if type is not CMPIArray.
*/
if( !(type & CMPI_ARRAY) && !data )
{
return CIMValue(type2CIMType(type), false);
}
/**
Case when type is CMPIArray
*/
if( type & CMPI_ARRAY )
{
//Return if data itself is NULL or Array is NULL
if( data == NULL || data->array == NULL )
{
CMPIType aType=type&~CMPI_ARRAY;
return CIMValue(type2CIMType(aType),true);
}
// When data is not NULL and data->array is also set
CMPIArray *ar=data->array;
CMPIData *aData=(CMPIData*)((CMPI_Array*)ar->hdl)->hdl;
//Get the type of the elements in the array
CMPIType aType=aData->type&~CMPI_ARRAY;
int aSize=aData->value.sint32;
aData++;
// Checks for Signed Integers
if( (aType & (CMPI_UINT|CMPI_SINT))==CMPI_SINT )
{
switch( aType )
{
case CMPI_sint32:
CopyToArray(Sint32,sint32);
break;
case CMPI_sint16:
CopyToArray(Sint16,sint16);
break;
case CMPI_sint8:
CopyToArray(Sint8,sint8);
break;
case CMPI_sint64:
CopyToArray(Sint64,sint64);
break;
default: ;
}
}
else
if( aType == CMPI_chars )
{
CopyToStringArray(String,string->hdl)
}
else
if( aType == CMPI_charsptr )
{
CopyCharsptrToStringArray(String,chars)
}
else
if( aType == CMPI_string )
{
CopyToStringArray(String,string->hdl)
}
// Checks for Unsigned Integers
else
if( (aType & (CMPI_UINT|CMPI_SINT))==CMPI_UINT )
{
switch( aType )
{
case CMPI_uint32:
CopyToArray(Uint32,uint32);
break;
case CMPI_uint16:
CopyToArray(Uint16,uint16);
break;
case CMPI_uint8:
CopyToArray(Uint8,uint8);
break;
case CMPI_uint64:
CopyToArray(Uint64,uint64);
break;
default: ;
}
}
else
{
switch( aType )
{
case CMPI_ref:
{
Array<CIMObjectPath> arCIMObjectPath(aSize);
ArrayIterator<CIMObjectPath> iterator(arCIMObjectPath);
for (int i=0; i<aSize; i++)
{
SCMOInstance* scmoInst =
(SCMOInstance*)aData[i].value.ref->hdl;
scmoInst->getCIMObjectPath(iterator[i]);
}
v.set(arCIMObjectPath);
}
break;
case CMPI_dateTime:
CopyToEncArray(CIMDateTime,dateTime);
break;
case CMPI_instance:
{
Array<CIMObject> arCIMInstance(aSize);
ArrayIterator<CIMObject> iterator(arCIMInstance);
for (int i=0; i<aSize; i++)
{
SCMOInstance* scmoInst =
(SCMOInstance*)aData[i].value.inst->hdl;
CIMInstance inst;
scmoInst->getCIMInstance(inst);
CIMObject obj(inst);
iterator[i]=obj;
}
v.set(arCIMInstance);
}
break;
case CMPI_boolean:
CopyToArray(Boolean,boolean);
break;
case CMPI_char16:
CopyToArray(Char16,char16);
break;
case CMPI_real32:
CopyToArray(Real32,real32);
break;
case CMPI_real64:
CopyToArray(Real64,real64);
break;
default:
if( rc )
{
*rc=CMPI_RC_ERR_NOT_SUPPORTED;
}
}
}
return CIMValue(v);
} // end of array processing
//Start of non - array types processing
else
if( type == CMPI_chars )
void testEmbeddedValueArray(const CIMInstance & startInstance,
const CIMNamespaceName & NAMESPACE,
SimpleDeclContext * context)
{
CIMInstance instance1(startInstance.clone());
// Test an array of CIMObjects that are CIMInstances
CIMInstance instance2(CIMName ("MyClass"));
instance2.addQualifier(CIMQualifier(CIMName ("classcounter"), true));
instance2.addProperty(CIMProperty(CIMName ("message"), String("Adios")));
Resolver::resolveInstance (instance2, context, NAMESPACE, true);
CIMInstance instance3(CIMName ("MyClass"));
instance3.addQualifier(CIMQualifier(CIMName ("classcounter"), false));
instance3.addProperty(CIMProperty(CIMName ("message"),
String("Au Revoir")));
Resolver::resolveInstance (instance3, context, NAMESPACE, true);
Array<EmbeddedType> arr16;
arr16.append(EmbeddedType(instance1));
arr16.append(EmbeddedType(instance2));
arr16.append(EmbeddedType(instance3));
test02(arr16);
// Specific test to verify the cloning of CIMObjects when set as and
// gotten from a CIMValue.
CIMValue v1array;
// Create CIMValue v1 of type CIMTYPE_OBJECT (ie. CIMObject)
v1array.set(arr16);
// Change the "count" property of arr16[1], and then verify
// that the CIMValue v1array, that was set from arr16, is
// not affected (ie. tests clone() on CIMValue::set() ).
Uint32 propIx = arr16[1].findProperty(CIMName("count"));
PEGASUS_TEST_ASSERT(propIx != PEG_NOT_FOUND);
CIMValue v2 = arr16[1].getProperty(propIx).getValue();
Uint32 propCount;
v2.get(propCount);
PEGASUS_TEST_ASSERT(propCount == 55);
arr16[1].removeProperty(propIx);
arr16[1].addProperty(CIMProperty(CIMName ("count"), Uint32(65))
.addQualifier(CIMQualifier(CIMName ("counter"), true))
.addQualifier(CIMQualifier(CIMName ("min"), String("0")))
.addQualifier(CIMQualifier(CIMName ("max"), String("1"))));
Array<EmbeddedType> object2array;
v1array.get(object2array);
CIMInstance instance2a(object2array[1]);
propIx = instance2a.findProperty(CIMName("count"));
PEGASUS_TEST_ASSERT(propIx != PEG_NOT_FOUND);
CIMValue v3 = instance2a.getProperty(propIx).getValue();
v3.get(propCount);
PEGASUS_TEST_ASSERT(propCount == 55);
// Now change the "count" property of instance2a, which was obtained
// from a get of CIMValue v1array. Again, the underlying CIMValue should
// not be affected (ie. tests clone() on CIMValue::get() ).
instance2a.removeProperty(propIx);
instance2a.addProperty(CIMProperty(CIMName ("count"), Uint32(65))
.addQualifier(CIMQualifier(CIMName ("counter"), true))
.addQualifier(CIMQualifier(CIMName ("min"), String("0")))
.addQualifier(CIMQualifier(CIMName ("max"), String("1"))));
Array<EmbeddedType> object3array;
v1array.get(object3array);
CIMInstance instance2b(object3array[1]);
propIx = instance2b.findProperty(CIMName("count"));
PEGASUS_TEST_ASSERT(propIx != PEG_NOT_FOUND);
CIMValue v4 = instance2b.getProperty(propIx).getValue();
v4.get(propCount);
PEGASUS_TEST_ASSERT(propCount == 55);
// Specific test for setting value as a null CIMObject() (see bug 3373).
// Confirm that CIMValue() with an uninitialized CIMObject in the input
// array will throw exception.
arr16.append(EmbeddedType());
bool caught_exception = false;
try
{
CIMValue y(arr16);
}
catch(UninitializedObjectException&)
{
caught_exception = true;
}
PEGASUS_TEST_ASSERT (caught_exception == true);
// Confirm that set() with an uninitialized CIMObject in the input
// array will throw exception.
caught_exception = false;
try
{
CIMValue y;
y.set(arr16);
}
catch(UninitializedObjectException&)
{
caught_exception = true;
}
PEGASUS_TEST_ASSERT (caught_exception == true);
}
void testEmbeddedValue(const CIMInstance & instance)
{
CIMInstance instance1 = instance.clone();
// Specific test to verify the cloning of CIMObjects/CIMInstances when set
// and gotten from a CIMValue.
CIMValue v1;
// Create CIMValue v1 of type CIMTYPE_OBJECT/CIMTYPE_INSTANCE
v1.set(EmbeddedType(instance1));
// Change the "count" property of instance1, and then verify
// that the CIMValue v1, that was set from instance1, is
// not affected (ie. tests clone() on CIMValue::set() ).
Uint32 propIx = instance1.findProperty(CIMName("count"));
PEGASUS_TEST_ASSERT(propIx != PEG_NOT_FOUND);
CIMValue v2 = instance1.getProperty(propIx).getValue();
Uint32 propCount;
v2.get(propCount);
PEGASUS_TEST_ASSERT(propCount == 55);
instance1.removeProperty(propIx);
instance1.addProperty(CIMProperty(CIMName ("count"), Uint32(65))
.addQualifier(CIMQualifier(CIMName ("counter"), true))
.addQualifier(CIMQualifier(CIMName ("min"), String("0")))
.addQualifier(CIMQualifier(CIMName ("max"), String("1"))));
EmbeddedType object2;
v1.get(object2);
CIMInstance instance1a(object2);
propIx = instance1a.findProperty(CIMName("count"));
PEGASUS_TEST_ASSERT(propIx != PEG_NOT_FOUND);
CIMValue v3 = instance1a.getProperty(propIx).getValue();
v3.get(propCount);
PEGASUS_TEST_ASSERT(propCount == 55);
// Now change the "count" property of instance1a, which was obtained
// from a get of CIMValue v1. Again, the underlying CIMValue should
// not be affected (ie. tests clone() on CIMValue::get() ).
instance1a.removeProperty(propIx);
instance1a.addProperty(CIMProperty(CIMName ("count"), Uint32(65))
.addQualifier(CIMQualifier(CIMName ("counter"), true))
.addQualifier(CIMQualifier(CIMName ("min"), String("0")))
.addQualifier(CIMQualifier(CIMName ("max"), String("1"))));
EmbeddedType object3;
v1.get(object3);
CIMInstance instance1b(object3);
propIx = instance1b.findProperty(CIMName("count"));
PEGASUS_TEST_ASSERT(propIx != PEG_NOT_FOUND);
CIMValue v4 = instance1b.getProperty(propIx).getValue();
v4.get(propCount);
PEGASUS_TEST_ASSERT(propCount == 55);
// Specific test for setting value as a null CIMObject/CIMInstance
// (see bug 3373).
// Confirm that CIMValue() with an uninitialized CIMObject/CIMInstance will
// throw exception.
Boolean caught_exception = false;
try
{
EmbeddedType obj = EmbeddedType();
CIMValue y(obj);
}
catch(UninitializedObjectException&)
{
caught_exception = true;
}
PEGASUS_TEST_ASSERT (caught_exception == true);
// Confirm that set() with an uninitialized CIMObject/CIMInstance will
// throw exception.
caught_exception = false;
try
{
CIMValue y;
y.set(EmbeddedType());
}
catch(UninitializedObjectException&)
{
caught_exception = true;
}
PEGASUS_TEST_ASSERT (caught_exception == true);
}
void ComputerSystem::initialize(void)
{
// fills in the values of all properties that are not
// hardcoded (i.e., are obtained from the system) but not
// going to change dynamically (which is most, for this
// provider)
// _hostName
struct hostent *he;
char hn[PEGASUS_MAXHOSTNAMELEN];
// fill hn with what this system thinks is name
gethostname(hn,PEGASUS_MAXHOSTNAMELEN);
// find out what nameservices think is full name
if (he=gethostbyname(hn)) _hostName = he->h_name;
else _hostName = hn;
size_t bufSize;
// get serial number using confstr
bufSize = confstr(_CS_MACHINE_SERIAL, NULL, 0);
if (bufSize != 0)
{
char* serialNumber = new char[bufSize];
try
{
if (confstr(_CS_MACHINE_SERIAL, serialNumber, bufSize) != 0)
{
_serialNumber.set(String(serialNumber));
}
}
catch(...)
{
delete [] serialNumber;
throw;
}
delete [] serialNumber;
}
// get model using command
FILE *s = popen("/usr/bin/model","r");
if (s == 0) throw CIMOperationFailedException("/usr/bin/model: command not found");
char buf[100];
if (fgets(buf,100,s) == 0)
throw CIMOperationFailedException("/usr/bin/model: no output");
pclose(s);
_model = String(buf);
// get system UUID using confstr.
bufSize = confstr(_CS_MACHINE_IDENT, NULL, 0);
if (bufSize != 0)
{
char* uuid = new char[bufSize];
try
{
if (confstr(_CS_MACHINE_IDENT, uuid, bufSize) != 0)
{
_uuid.set(String(uuid));
}
}
catch(...)
{
delete [] uuid;
throw;
}
delete [] uuid;
}
// InstallDate
/*
A CIM date has the following form:
yyyymmddhhmmss.mmmmmmsutc
Where
yyyy = year (0-1999)
mm = month (1-12)
dd = day (1-31)
hh = hour (0-23)
mm = minute (0-59)
ss = second (0-59)
mmmmmm = microseconds.
s = '+' or '-' to represent the UTC sign.
utc = UTC offset (same as GMT offset).
*/
// creation date of /stand/vmunix
struct stat st;
// get get modification time of file
if (0 != stat("/stand/vmunix", &st))
throw CIMOperationFailedException("/stand/vmunix: can't access");
// convert to a usable format
struct tm tmBuffer;
struct tm *t = localtime_r(&st.st_mtime, &tmBuffer);
// convert to CIMDateTime format
char timstr[26];
sprintf(timstr,"%04d%02d%02d%02d%02d%02d.000000%c%03d",t->tm_year+1900,
t->tm_mon+1,
t->tm_mday,
t->tm_hour,
t->tm_min,
t->tm_sec,
(timezone>0)?'-':'+',
labs (timezone/60 - (t->tm_isdst? 60:0)));
_installDate = CIMDateTime (timstr);
// ----------------------------------------------------------
// Now set properties obtained from DMI
// ----------------------------------------------------------
typedef enum
{
GenInfoSysName_E = 1,
GenInfoSysLoc_E = 2,
GenInfoSysPUser_E = 3,
GenInfoSysPPhone_E = 4,
GenInfoSysUpTime_E = 5,
GenInfoSysDate_E = 6,
GenInfoSysSUser_E = 7,
GenInfoSysSPhone_E = 8,
GenInfoSysPPager_E = 9,
GenInfoSysSPager_E = 10,
GenInfoSecurity_E = 11,
GenInfoModel_E = 12,
GenInfoSerialNumber_E = 13,
GenInfoSoftwareID_E = 14
} GenInfoEnumList;
char inLine[1024];
char *tmpGroupId = NULL;
char *tmpAttrId = NULL;
char *value = NULL;
int groupId;
int attrId;
char *tokp = NULL;
// open file
ifstream mParmStream(DMI_FILE);
// Values will be left blank if can't access file
if (mParmStream == 0) return;
while (mParmStream.getline(inLine, sizeof(inLine)))
{
/* Parse out the line to get the DMI group Id, attribute Id */
/* and value. */
tmpGroupId = strtok_r(inLine, "|", &tokp);
tmpAttrId = strtok_r(NULL, "|", &tokp);
value = strtok_r(NULL, "\n", &tokp);
if (NULL != tmpGroupId)
{
groupId = atoi(tmpGroupId);
}
else
{
continue;
}
if (NULL != tmpAttrId)
{
attrId = atoi(tmpAttrId);
}
else
{
continue;
}
/* Make sure information read in is the right DMI group. */
if ((groupId != GEN_INFO_GROUP_ID) || (NULL == value))
{
continue;
}
if (attrId == GenInfoSysPUser_E)
{
_primaryOwnerName = value;
}
else if (attrId == GenInfoSysPPhone_E)
{
_primaryOwnerContact = value;
}
else if (attrId == GenInfoSysSUser_E)
{
_secondaryOwnerName = value;
}
else if (attrId == GenInfoSysSPhone_E)
{
_secondaryOwnerContact = value;
}
else if (attrId == GenInfoSysPPager_E)
{
_primaryOwnerPager = value;
}
else if (attrId == GenInfoSysSPager_E)
{
_secondaryOwnerPager = value;
}
} /* while */
return;
}
int main(int argc, char** argv)
{
#ifdef IO
verbose = getenv("PEGASUS_TEST_VERBOSE");
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));
// Specific test for setting value as a null CIMObject() (see bug 3373).
// Confirm that CIMValue() with an uninitialized CIMObject will throw exception.
Boolean caught_exception = false;
try
{
CIMObject obj = CIMObject();
CIMValue y(obj);
}
catch(UninitializedObjectException& e)
{
caught_exception = true;
}
assert (caught_exception == true);
// Confirm that set() with an uninitialized CIMObject will throw exception.
caught_exception = false;
try
{
CIMValue y;
y.set(CIMObject());
}
catch(UninitializedObjectException& e)
{
caught_exception = true;
}
assert (caught_exception == true);
// 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.55);
arr10.append(2.66);
arr10.append(3.77);
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);
// Test an array of CIMObjects that are CIMInstances
CIMInstance instance2(CIMName ("MyClass"));
instance2.addQualifier(CIMQualifier(CIMName ("classcounter"), true));
instance2.addProperty(CIMProperty(CIMName ("message"), String("Adios")));
Resolver::resolveInstance (instance2, context, NAMESPACE, true);
CIMInstance instance3(CIMName ("MyClass"));
instance3.addQualifier(CIMQualifier(CIMName ("classcounter"), false));
instance3.addProperty(CIMProperty(CIMName ("message"), String("Au Revoir")));
Resolver::resolveInstance (instance3, context, NAMESPACE, true);
Array<CIMObject> arr16;
arr16.append(CIMObject(instance1));
arr16.append(CIMObject(instance2));
arr16.append(CIMObject(instance3));
test02(arr16);
// Specific test for setting value as a null CIMObject() (see bug 3373).
// Confirm that CIMValue() with an uninitialized CIMObject in the input
// array will throw exception.
arr16.append(CIMObject());
caught_exception = false;
try
{
CIMValue y(arr16);
}
catch(UninitializedObjectException& e)
{
caught_exception = true;
}
assert (caught_exception == true);
// Confirm that set() with an uninitialized CIMObject in the input
// array will throw exception.
caught_exception = false;
try
{
CIMValue y;
y.set(arr16);
}
catch(UninitializedObjectException& e)
{
caught_exception = true;
}
assert (caught_exception == true);
// 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;
AcceptLanguageElement al1("en-US-mn;;");
Array<AcceptLanguageElement> al_arr1(10,al1);
AcceptLanguageElement *al2 = new AcceptLanguageElement("en-US-mn;;");
Array<AcceptLanguageElement> al_arr2(al2,1);
test03(al_arr1, al_arr2, al2, AcceptLanguageElement("en-US-mn;;"),
AcceptLanguageElement("en-US"));
delete al2;
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;
}
