void _checkStringValue (CIMValue & theValue,
const String & value,
Boolean null = false)
{
PEGASUS_TEST_ASSERT (theValue.getType () == CIMTYPE_STRING);
PEGASUS_TEST_ASSERT (!theValue.isArray ());
if (null)
{
PEGASUS_TEST_ASSERT (theValue.isNull ());
}
else
{
PEGASUS_TEST_ASSERT (!theValue.isNull ());
String result;
theValue.get (result);
if (verbose)
{
if (result != value)
{
cerr << "Property value comparison failed. ";
cerr << "Expected " << value << "; ";
cerr << "Actual property value was " << result << "." << endl;
}
}
PEGASUS_TEST_ASSERT (result == value);
}
}
void _sendIndicationShouldBeBlocked
(CIMClient & client)
{
Array <CIMParamValue> inParams;
Array <CIMParamValue> outParams;
Array <CIMKeyBinding> keyBindings;
Sint32 result;
CIMName methodName ("SendTestIndication");
CIMObjectPath className (String::EMPTY, CIMNamespaceName (),
CIMName("Test_IndicationProviderClass"), keyBindings);
try
{
CIMValue retValue = client.invokeMethod
(SOURCENAMESPACE,
className,
methodName,
inParams,
outParams);
retValue.get (result);
PEGASUS_TEST_ASSERT (false);
}
catch (CIMException & e)
{
PEGASUS_TEST_ASSERT (e.getCode () == CIM_ERR_NOT_SUPPORTED);
}
}
/**
***************************************************************************
_filterAssociationInstances is used to filter the set of possible return
instances against the filters (resultClass and resultRole) provided with
the associators and associatorNames operations. It returns the ObjectPaths
of the set of objects that pass the filter tests.
@param assocInstance - The target association class instance
@param sourceObjectPath - The source ObjectPath
@param resultClass - The result class. If there is no resultClass,
this is String::EMPTY.
@param resultRole - The result role. If there is no role, this is
String::EMPTY
@return the ObjectPaths of the set of association instances that pass
the filter tests.
***************************************************************************
*/
Array<CIMObjectPath> ANHProvider::_filterAssociationInstances(
CIMInstance& assocInstance,
const CIMObjectPath& sourceObjectPath,
CIMName resultClass,
String resultRole)
{
Array<CIMObjectPath> returnPaths;
// get all Reference properties
for (Uint32 i = 0, n = assocInstance.getPropertyCount(); i < n; i++)
{
CIMProperty p = assocInstance.getProperty(i);
if (p.getType() == CIMTYPE_REFERENCE)
{
CIMValue v = p.getValue();
CIMObjectPath path;
v.get(path);
if (!sourceObjectPath.identical(path))
{
if (resultClass.isNull() || resultClass == path.getClassName())
{
if (resultRole == String::EMPTY ||
(p.getName() == CIMName(resultRole)))
{
returnPaths.append(path);
}
}
}
}
}
return returnPaths;
}
void
test04 (CIMClient & client)
{
CIMObjectPath instanceName;
instanceName.setNameSpace (providerNamespace);
instanceName.setClassName (CLASSNAME);
Array < CIMParamValue > inParams;
Array < CIMParamValue > outParams;
/* [EmbeddedObject] String returnInstance(); */
CIMValue retValue = client.invokeMethod (providerNamespace,
instanceName,
"returnInstance",
inParams,
outParams);
PEGASUS_TEST_ASSERT (retValue.getType () == CIMTYPE_OBJECT);
PEGASUS_TEST_ASSERT (!retValue.isArray ());
PEGASUS_TEST_ASSERT (!retValue.isNull ());
CIMObject result;
retValue.get (result);
CIMObjectPath objPath = result.getPath();
PEGASUS_TEST_ASSERT (objPath.toString() == "TestCMPI_Instance");
}
static CMPIData mbGetProperty(
const CMPIBroker *mb,
const CMPIContext *ctx,
const CMPIObjectPath *cop,
const char *name,
CMPIStatus *rc)
{
PEG_METHOD_ENTER(
TRC_CMPIPROVIDERINTERFACE,
"CMPI_Broker:mbGetProperty()");
mb = CM_BROKER;
CMPIData data = {0,CMPI_nullValue,{0}};
SCMOInstance* scmoObjPath = SCMO_ObjectPath(cop);
CIMObjectPath qop;
scmoObjPath->getCIMObjectPath(qop);
try
{
CIMValue v = CM_CIMOM(mb)->getProperty(
*CM_Context(ctx),
SCMO_ObjectPath(cop)->getNameSpace(),
qop,
String(name));
CIMType vType = v.getType();
CMPIType t = type2CMPIType(vType,v.isArray());
value2CMPIData(v,t,&data);
CMSetStatus(rc,CMPI_RC_OK);
}
HandlerCatchSetStatus(rc, data);
PEG_METHOD_EXIT();
return data; // "data" will be valid data or nullValue (in error case)
}
void _checkUint32Property
(CIMInstance & instance, const String & name, Uint32 value)
{
Uint32 pos = instance.findProperty (name);
PEGASUS_ASSERT (pos != PEG_NOT_FOUND);
CIMProperty theProperty = instance.getProperty (pos);
CIMValue theValue = theProperty.getValue ();
PEGASUS_ASSERT (theValue.getType () == CIMTYPE_UINT32);
PEGASUS_ASSERT (!theValue.isArray ());
PEGASUS_ASSERT (!theValue.isNull ());
Uint32 result;
theValue.get (result);
if (verbose)
{
if (result != value)
{
cerr << "Property value comparison failed. ";
cerr << "Expected " << value << "; ";
cerr << "Actual property value was " << result << "." << endl;
}
}
PEGASUS_ASSERT (result == value);
}
ProviderName DefaultProviderManager::_resolveProviderName(
const ProviderIdContainer& providerId)
{
String providerName;
String fileName;
String moduleName;
CIMValue genericValue;
genericValue = providerId.getModule().getProperty(
providerId.getModule().findProperty(
PEGASUS_PROPERTYNAME_NAME)).getValue();
genericValue.get(moduleName);
genericValue = providerId.getProvider().getProperty(
providerId.getProvider().findProperty(
PEGASUS_PROPERTYNAME_NAME)).getValue();
genericValue.get(providerName);
genericValue = providerId.getModule().getProperty(
providerId.getModule().findProperty("Location")).getValue();
genericValue.get(fileName);
String resolvedFileName = _resolvePhysicalName(fileName);
if (resolvedFileName == String::EMPTY)
{
// Provider library not found
throw Exception(MessageLoaderParms(
"ProviderManager.ProviderManagerService.PROVIDER_FILE_NOT_FOUND",
"File \"$0\" was not found for provider module \"$1\".",
FileSystem::buildLibraryFileName(fileName), moduleName));
}
return ProviderName(moduleName, providerName, resolvedFileName);
}
void _testHostedIndicationServiceInstance(CIMClient &client)
{
cout << "Testing Association Class "
<< (const char *)PEGASUS_CLASSNAME_PG_HOSTEDINDICATIONSERVICE.
getString().getCString()
<< "...";
// Get PG_HostedIndicationService Instances
Array<CIMInstance> hostedInstances = client.enumerateInstances(
PEGASUS_NAMESPACENAME_INTEROP,
PEGASUS_CLASSNAME_PG_HOSTEDINDICATIONSERVICE);
PEGASUS_TEST_ASSERT(hostedInstances.size() == 1);
// Get PG_HostedIndicationService Instance names
Array<CIMObjectPath> hostedPaths = client.enumerateInstanceNames(
PEGASUS_NAMESPACENAME_INTEROP,
PEGASUS_CLASSNAME_PG_HOSTEDINDICATIONSERVICE);
PEGASUS_TEST_ASSERT(hostedPaths.size() == 1);
// Get CIM_IndicationService instance names
Array<CIMObjectPath> servicePaths = client.enumerateInstanceNames(
PEGASUS_NAMESPACENAME_INTEROP,
PEGASUS_CLASSNAME_CIM_INDICATIONSERVICE);
PEGASUS_TEST_ASSERT(servicePaths.size() == 1);
// Test the CIM_IndicationService value.
CIMValue capValue = hostedInstances[0].getProperty(
hostedInstances[0].findProperty("Dependent")).getValue();
CIMObjectPath testPath;
capValue.get(testPath);
testPath.setNameSpace(CIMNamespaceName());
PEGASUS_TEST_ASSERT(testPath.identical(servicePaths[0]));
cout << "Test Complete" << endl;
}
int main (int argc, char** argv)
{
String stringVal;
verbose = (getenv("PEGASUS_TEST_VERBOSE")) ? true : false;
CIMClient client;
try
{
client.connectLocal ();
}
catch (Exception & e)
{
PEGASUS_STD (cerr) << e.getMessage () << PEGASUS_STD (endl);
return -1;
}
_enumerateInstanceNames(client);
_getInstance(client);
_setProperty(client, 7890);
_getProperty(client);
// getProperty() only returns CIMValues of type String.
value.get(stringVal);
PEGASUS_TEST_ASSERT(atoi((const char*)stringVal.getCString())==7890);
_setProperty(client,1234);
_getProperty(client);
// getProperty() only returns CIMValues of type String.
// Verify that setProperty worked as expected.
value.get(stringVal);
PEGASUS_TEST_ASSERT(atoi((const char*)stringVal.getCString())==1234);
return 0;
}
void _checkUint64Property
(CIMInstance & instance, const String & name, Uint64 value)
{
Uint32 pos = instance.findProperty (name);
PEGASUS_ASSERT (pos != PEG_NOT_FOUND);
CIMProperty theProperty = instance.getProperty (pos);
CIMValue theValue = theProperty.getValue ();
PEGASUS_ASSERT (theValue.getType () == CIMTYPE_UINT64);
PEGASUS_ASSERT (!theValue.isArray ());
PEGASUS_ASSERT (!theValue.isNull ());
Uint64 result;
theValue.get (result);
if (verbose)
{
if (result != value)
{
char buffer[32]; // Should need 21 chars max
sprintf (buffer, "%" PEGASUS_64BIT_CONVERSION_WIDTH "u", value);
cerr << "Property value comparison failed. ";
cerr << "Expected " << buffer << "; ";
sprintf (buffer, "%" PEGASUS_64BIT_CONVERSION_WIDTH "u", result);
cerr << "Actual property value was " << buffer << "." << endl;
}
}
PEGASUS_ASSERT (result == value);
}
void _sendTestIndication(
CIMClient* client,
const CIMName & methodName,
Uint32 indicationSendCount)
{
//
// Invoke method to send test indication
//
Array <CIMParamValue> inParams;
Array <CIMParamValue> outParams;
Array <CIMKeyBinding> keyBindings;
Sint32 result;
CIMObjectPath className (String::EMPTY, CIMNamespaceName (),
CIMName ("Test_IndicationProviderClass"), keyBindings);
inParams.append(CIMParamValue(String("indicationSendCount"),
CIMValue(indicationSendCount)));
CIMValue retValue = client->invokeMethod
(SOURCE_NAMESPACE,
className,
methodName,
inParams,
outParams);
retValue.get (result);
PEGASUS_TEST_ASSERT (result == 0);
}
String CIMHelper::getPropertyAsString(const CIMInstance &instanceObject, String name)
{
CIMValue value = getPropertyValue(instanceObject, name);
if (value.isNull()) return String("");
String result;
value.get(result);
return result;
}
Uint64 CIMHelper::getPropertyAsUint64(const CIMInstance &instanceObject, String name)
{
CIMValue value = getPropertyValue(instanceObject, name);
if (value.isNull()) return PEG_NOT_FOUND;
Uint64 result;
value.get(result);
return result;
}
Array<String> CIMHelper::getPropertyAsStringArray(const CIMInstance &instanceObject, String name)
{
CIMValue value = getPropertyValue(instanceObject, name);
if (value.isNull()) return Array<String>();
Array<String> result;
value.get(result);
return result;
}
void callMethod(const CIMName& methodName)
{
try
{
CIMClient client;
client.connectLocal();
Array<CIMParamValue> inParams;
Array<CIMParamValue> outParams;
CIMObjectPath instName =
CIMObjectPath("Test_MethodProviderClass.Id=1");
inParams.append(CIMParamValue("InParam1", Uint32(1)));
inParams.append(CIMParamValue("InParam2", Uint32(2)));
CIMValue returnValue = client.invokeMethod(
NAMESPACE,
instName,
methodName,
inParams,
outParams);
Uint32 rc;
returnValue.get(rc);
PEGASUS_TEST_ASSERT(rc == 10);
PEGASUS_TEST_ASSERT(outParams.size() == 2);
Uint32 outParam1 = 0;
Uint32 outParam2 = 0;
for (Uint32 i = 0; i < 2; i++)
{
if (outParams[i].getParameterName() == "OutParam1")
{
outParams[i].getValue().get(outParam1);
}
else if (outParams[i].getParameterName() == "OutParam2")
{
outParams[i].getValue().get(outParam2);
}
else
{
PEGASUS_TEST_ASSERT(0);
}
}
PEGASUS_TEST_ASSERT(outParam1 == 21);
PEGASUS_TEST_ASSERT(outParam2 == 32);
}
catch (Exception& e)
{
cerr << "Error: " << e.getMessage() << endl;
exit(1);
}
}
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);
}
void CIMPropertyRep::setValue(const CIMValue& value)
{
// CIMType of value is immutable:
if (!value.typeCompatible(_value))
throw TypeMismatchException();
if (_arraySize && _arraySize != value.getArraySize())
throw TypeMismatchException();
_value = value;
}
void CIMError::setInstance(const CIMInstance& instance)
{
for (Uint32 i = 0; i < instance.getPropertyCount(); i++)
{
CIMConstProperty p = instance.getProperty(i);
_Check("ErrorType", p, (Uint16*)0);
_Check("OtherErrorType", p, (String*)0);
_Check("OwningEntity", p, (String*)0);
_Check("MessageID", p, (String*)0);
_Check("Message", p, (String*)0);
_Check("MessageArguments", p, (Array<String>*)0);
_Check("PerceivedSeverity", p, (Uint16*)0);
_Check("ProbableCause", p, (Uint16*)0);
_Check("ProbableCauseDescription", p, (String*)0);
_Check("RecommendedActions", p, (Array<String>*)0);
_Check("ErrorSource", p, (String*)0);
_Check("ErrorSourceFormat", p, (Uint16*)0);
_Check("OtherErrorSourceFormat", p, (String*)0);
_Check("CIMStatusCode", p, (Uint32*)0);
_Check("CIMStatusCodeDescription", p, (String*)0);
}
// Verify that the instance contains all of the required properties.
for (Uint32 i = 0; i < _numRequiredProperties; i++)
{
// Does inst have this property?
Uint32 pos = instance.findProperty(_requiredProperties[i]);
if (pos == PEG_NOT_FOUND)
{
char buffer[80];
sprintf(buffer, "required property does not exist: %s",
_requiredProperties[i]);
throw CIMException(CIM_ERR_NO_SUCH_PROPERTY, buffer);
}
// is required property non-null?
CIMConstProperty p = instance.getProperty(pos);
CIMValue v = p.getValue();
if (v.isNull())
{
char buffer[80];
sprintf(buffer, "required property MUST NOT be Null: %s",
_requiredProperties[i]);
throw CIMException(CIM_ERR_FAILED, buffer);
}
}
_inst = instance;
}
static void
outputKEYVALUE(ostream& ostr, const CIMProperty& cp)
{
CIMDataType dtype = cp.getDataType();
String type;
if (dtype.isArrayType())
{
OW_THROWCIMMSG(CIMException::INVALID_PARAMETER,
"An array cannot be a KEY");
}
if (dtype.isReferenceType())
{
CIMProperty lcp(cp);
// This is sort of a bad thing to do, basically we are taking advantage
// of a side effect of setDataType. If the type isn't correct then
// the value will be cast to the correct type. This is to work around
// a problem that may happen if a provider writer sets the value of a
// reference property to a String instead of an CIMObjectPath.
// If the value is a string, the xml that is output will be malformed,
// and the client will throw an exception.
lcp.setDataType(lcp.getDataType());
CIMtoXML(lcp.getValue(), ostr);
return;
}
//
// Regular key value
switch (dtype.getType())
{
case CIMDataType::CHAR16:
case CIMDataType::DATETIME:
case CIMDataType::STRING:
type = "string";
break;
case CIMDataType::BOOLEAN:
type = "boolean";
break;
default:
type = "numeric";
}
CIMValue keyValue = cp.getValue();
if (!keyValue)
{
OW_THROWCIMMSG(CIMException::FAILED, "No key value");
}
ostr
<< "<KEYVALUE VALUETYPE=\""
<< type
<< "\">"
<< XMLEscape(keyValue.toString())
<< "</KEYVALUE>";
}
void MethodProvider::invokeMethod(
const OperationContext & context,
const CIMObjectPath & objectReference,
const CIMName & methodName,
const Array<CIMParamValue> & inParameters,
MethodResultResponseHandler & handler)
{
// convert a fully qualified reference into a local reference
// (class name and keys only).
CIMObjectPath localReference = CIMObjectPath(
String(),
CIMNamespaceName(),
objectReference.getClassName(),
objectReference.getKeyBindings());
handler.processing();
if (objectReference.getClassName().equal("Sample_MethodProviderClass"))
{
if (methodName.equal("SayHello"))
{
String outString = "Hello";
if (inParameters.size() > 0)
{
CIMValue paramVal = inParameters[0].getValue();
if (!paramVal.isNull())
{
String replyName;
paramVal.get(replyName);
if (replyName != String::EMPTY)
{
outString.append(", " + replyName + "!");
}
}
handler.deliverParamValue(
CIMParamValue("Place",
CIMValue(String("From Neverland"))));
handler.deliver(CIMValue(outString));
}
else
{
handler.deliver(CIMValue(outString));
}
}
}
handler.complete();
}
void _getKeyValue (
const CIMInstance& namespaceInstance,
CIMNamespaceName& childNamespaceName,
Boolean& isRelativeName)
{
//Validate key property
Uint32 pos;
CIMValue propertyValue;
// [Key, MaxLen (256), Description (
// "A string that uniquely identifies the Namespace "
// "within the ObjectManager.") ]
// string Name;
pos = namespaceInstance.findProperty(NAMESPACE_PROPERTYNAME);
if (pos == PEG_NOT_FOUND)
{
throw CIMPropertyNotFoundException
(NAMESPACE_PROPERTYNAME.getString());
}
propertyValue = namespaceInstance.getProperty(pos).getValue();
if (propertyValue.getType() != CIMTYPE_STRING)
{
//l10n
//throw CIMInvalidParameterException("Invalid type for property: "
//+ NAMESPACE_PROPERTYNAME.getString());
throw CIMInvalidParameterException(MessageLoaderParms(
"ControlProviders.NamespaceProvider.NamespaceProvider.INVALID_TYPE_FOR_PROPERTY",
"Invalid type for property: $0",
NAMESPACE_PROPERTYNAME.getString()));
}
String cnsName;
propertyValue.get(cnsName);
if (cnsName == String::EMPTY)
{
childNamespaceName = CIMNamespaceName();
}
else
{
childNamespaceName = CIMNamespaceName(cnsName);
}
isRelativeName = !(childNamespaceName.isNull());
}
void _testServiceAffectsElementInstances(CIMClient &client)
{
cout << "Testing Association Class "
<< (const char *)PEGASUS_CLASSNAME_PG_SERVICEAFFECTSELEMENT.
getString().getCString()
<< "...";
// Get PG_ServiceAffectsElement instances.
Array<CIMInstance> sfInstances = client.enumerateInstances(
PEGASUS_NAMESPACENAME_INTEROP,
PEGASUS_CLASSNAME_PG_SERVICEAFFECTSELEMENT);
// Get PG_ServiceAffectsElement instance names
Array<CIMObjectPath> sfPaths = client.enumerateInstanceNames(
PEGASUS_NAMESPACENAME_INTEROP,
PEGASUS_CLASSNAME_PG_SERVICEAFFECTSELEMENT);
PEGASUS_TEST_ASSERT(sfInstances.size() == sfPaths.size());
// Get CIM_IndicationFilter instance names
Array<CIMObjectPath> filterPaths = client.enumerateInstanceNames(
PEGASUS_NAMESPACENAME_INTEROP,
PEGASUS_CLASSNAME_INDFILTER);
// Get CIM_ListenerDestination instance names
Array<CIMObjectPath> handlerPaths = client.enumerateInstanceNames(
PEGASUS_NAMESPACENAME_INTEROP,
PEGASUS_CLASSNAME_LSTNRDST);
// Count only handlers and filters from interop namespace
Uint32 elements = 0;
for (Uint32 i = 0; i < sfInstances.size() ; ++i)
{
CIMValue value = sfInstances[i].getProperty(
sfInstances[i].findProperty("AffectedElement")).getValue();
CIMObjectPath path;
value.get(path);
PEGASUS_TEST_ASSERT(path.getNameSpace() != CIMNamespaceName());
if (path.getNameSpace() == PEGASUS_NAMESPACENAME_INTEROP)
{
elements++;
}
}
PEGASUS_TEST_ASSERT(
elements == (filterPaths.size() + handlerPaths.size()));
cout << "Test Complete" << endl;
}
void UNIX_ApplicationSystemDirectoryFixture::Run()
{
CIMName className("UNIX_ApplicationSystemDirectory");
CIMNamespaceName nameSpace("root/cimv2");
UNIX_ApplicationSystemDirectory _p;
UNIX_ApplicationSystemDirectoryProvider _provider;
Uint32 propertyCount;
CIMOMHandle omHandle;
_provider.initialize(omHandle);
_p.initialize();
for(int pIndex = 0; _p.load(pIndex); pIndex++)
{
CIMInstance instance = _provider.constructInstance(className,
nameSpace,
_p);
CIMObjectPath path = instance.getPath();
cout << path.toString() << endl;
propertyCount = instance.getPropertyCount();
for(Uint32 i = 0; i < propertyCount; i++)
{
CIMProperty propertyItem = instance.getProperty(i);
if (propertyItem.getType() == CIMTYPE_REFERENCE) {
CIMValue subValue = propertyItem.getValue();
CIMInstance subInstance;
subValue.get(subInstance);
CIMObjectPath subPath = subInstance.getPath();
cout << " Name: " << propertyItem.getName().getString() << ": " << subPath.toString() << endl;
Uint32 subPropertyCount = subInstance.getPropertyCount();
for(Uint32 j = 0; j < subPropertyCount; j++)
{
CIMProperty subPropertyItem = subInstance.getProperty(j);
cout << " Name: " << subPropertyItem.getName().getString() << " - Value: " << subPropertyItem.getValue().toString() << endl;
}
}
else {
cout << " Name: " << propertyItem.getName().getString() << " - Value: " << propertyItem.getValue().toString() << endl;
}
}
cout << "------------------------------------" << endl;
cout << endl;
}
_p.finalize();
}
CIMPropertyRep::CIMPropertyRep(
const CIMName& name,
const CIMValue& value,
Uint32 arraySize,
const CIMName& referenceClassName,
const CIMName& classOrigin,
Boolean propagated)
:
_name(name), _value(value), _arraySize(arraySize),
_referenceClassName(referenceClassName), _classOrigin(classOrigin),
_propagated(propagated), _refCounter(1), _ownerCount(0)
{
// ensure name is not null
if (name.isNull())
{
throw UninitializedObjectException();
}
// Set the CIM name tag.
_nameTag = generateCIMNameTag(_name);
if ((arraySize != 0) &&
(!value.isArray() || value.getArraySize() != arraySize))
{
throw TypeMismatchException();
}
// A CIM Property may not be of reference array type
if (value.isArray() && (value.getType() == CIMTYPE_REFERENCE))
{
throw TypeMismatchException();
}
// if referenceClassName exists, must be CIMType REFERENCE.
if (!referenceClassName.isNull())
{
if (_value.getType() != CIMTYPE_REFERENCE)
{
throw TypeMismatchException();
}
}
// Can a property be of reference type with a null referenceClassName?
// The DMTF says yes if it is a property of an instance; no if it is a
// property of a class. We'll allow it here, but check in the CIMClass
// addProperty() method.
}
void _testElementCapabilityInstance(CIMClient &client)
{
cout << "Testing Association Class "
<< (const char *)PEGASUS_CLASSNAME_CIM_INDICATIONSERVICECAPABILITIES.
getString().getCString()
<< "...";
// Get CIM_IndicationServiceCapabilities instance names
Array<CIMObjectPath> capPaths = client.enumerateInstanceNames(
PEGASUS_NAMESPACENAME_INTEROP,
PEGASUS_CLASSNAME_CIM_INDICATIONSERVICECAPABILITIES);
PEGASUS_TEST_ASSERT(capPaths.size() == 1);
// Get CIM_IndicationService instance names
Array<CIMObjectPath> servicePaths = client.enumerateInstanceNames(
PEGASUS_NAMESPACENAME_INTEROP,
PEGASUS_CLASSNAME_CIM_INDICATIONSERVICE);
PEGASUS_TEST_ASSERT(servicePaths.size() == 1);
// Get PG_ElementCapabilities instances
Array<CIMInstance> eleInstances = client.enumerateInstances(
PEGASUS_NAMESPACENAME_INTEROP,
PEGASUS_CLASSNAME_PG_ELEMENTCAPABILITIES);
PEGASUS_TEST_ASSERT(eleInstances.size() == 1);
// Test PG_ElementCapabilities instance.
CIMValue capValue = eleInstances[0].getProperty(
eleInstances[0].findProperty("Capabilities")).getValue();
CIMValue meValue = eleInstances[0].getProperty(
eleInstances[0].findProperty("ManagedElement")).getValue();
// Now test the instance names of CIM_IndicationService instance and
// CIM_IndicationServiceCapabilities instance.
CIMObjectPath testPath;
capValue.get(testPath);
testPath.setNameSpace(CIMNamespaceName());
PEGASUS_TEST_ASSERT(testPath.identical(capPaths[0]));
meValue.get(testPath);
testPath.setNameSpace(CIMNamespaceName());
PEGASUS_TEST_ASSERT(testPath.identical(servicePaths[0]));
cout << "Test Complete" << endl;
}
void CIMPropertyRep::setValue(const CIMValue& value)
{
// CIMType of value is immutable:
if (!value.typeCompatible(_value))
throw TypeMismatchException();
if (_arraySize && _arraySize != value.getArraySize())
throw TypeMismatchException();
// A CIM Property may not be of reference array type
if (value.isArray() && (value.getType() == CIMTYPE_REFERENCE))
{
throw TypeMismatchException();
}
_value = value;
}
static CMPIData mbInvokeMethod(
const CMPIBroker *mb,
const CMPIContext *ctx,
const CMPIObjectPath *cop,
const char *method,
const CMPIArgs *in,
CMPIArgs *out,
CMPIStatus *rc)
{
PEG_METHOD_ENTER(
TRC_CMPIPROVIDERINTERFACE,
"CMPI_Broker:mbInvokeMethod()");
CMPIData data = {0,CMPI_nullValue,{0}};
mb = CM_BROKER;
SCMOInstance* scmoObjPath = SCMO_ObjectPath(cop);
CIMObjectPath qop;
try
{
scmoObjPath->getCIMObjectPath(qop);
CIMValue v = CM_CIMOM(mb)->invokeMethod(
*CM_Context(ctx),
SCMO_ObjectPath(cop)->getNameSpace(),
qop,
method ? String(method) : String::EMPTY,
*CM_Args(in),
*CM_Args(out));
CIMType vType=v.getType();
CMPIType t = type2CMPIType(vType,v.isArray());
value2CMPIData(v,t,&data);
if (rc)
{
CMSetStatus(rc,CMPI_RC_OK);
}
}
HandlerCatchSetStatus(rc, data);
PEG_METHOD_EXIT();
return data; // "data" will be valid data or nullValue (in error case)
}
/* SystemName property in ObjectManager instance should be set to
fully qualified hostname which is set on cimserver at startup to "hugo.bert"
before this test case is executed
class resides in PEGASUS_NAMESPACENAME_INTEROP
*/
void testObjectManagerSystemName(
CIMClient & client)
{
Array<CIMInstance> instances=client.enumerateInstances(
PEGASUS_NAMESPACENAME_INTEROP,
CIMName("CIM_ObjectManager"));
PEGASUS_TEST_ASSERT(instances.size() == 1);
Uint32 pos = instances[0].findProperty("SystemName");
PEGASUS_TEST_ASSERT(PEG_NOT_FOUND != pos);
CIMProperty p = instances[0].getProperty(pos);
CIMValue v = p.getValue();
String s;
v.get(s);
PEGASUS_TEST_ASSERT(String::equal(s,"hugo.bert"));
}
void _testDeliveryRetryIntervalValue(
CIMInstance& instance)
{
CIMValue value =
instance.getProperty(
instance.findProperty(
_PROPERTY_DELIVERYRETRYINTERVAL)).getValue();
if (value.getType() == CIMTYPE_UINT64)
{
// CIM Schema 2.17 experimental class
PEGASUS_TEST_ASSERT(
Uint64(_PROPERTY_DELIVERYRETRYINTERVAL_VALUE) == value);
}
else
{
// CIM Schema 2.22 and up
PEGASUS_TEST_ASSERT(_PROPERTY_DELIVERYRETRYINTERVAL_VALUE == value);
}
}
Boolean setObjectManagerStatistics(CIMClient & client, Boolean newState)
{
CIMName gathStatName ("GatherStatisticalData");
Array<CIMInstance> instancesObjectManager;
CIMInstance instObjectManager;
Uint32 prop_num;
Array<CIMName> plA;
plA.append(gathStatName);
CIMPropertyList statPropertyList(plA);
// Create property list that represents correct request
// get instance. Get only the gatherstatitistics property
instancesObjectManager =
client.enumerateInstances(PEGASUS_NAMESPACENAME_INTEROP,
"CIM_ObjectManager",
true, false, false, false, statPropertyList);
PEGASUS_TEST_ASSERT(instancesObjectManager.size() == 1);
instObjectManager = instancesObjectManager[0];
// set correct path into instance
instObjectManager.setPath(instancesObjectManager[0].getPath());
prop_num = instObjectManager.findProperty(gathStatName);
PEGASUS_TEST_ASSERT(prop_num != PEG_NOT_FOUND);
instObjectManager.getProperty(prop_num).setValue(CIMValue(newState));
client.modifyInstance(PEGASUS_NAMESPACENAME_INTEROP, instObjectManager,
false, statPropertyList);
CIMInstance updatedInstance =
client.getInstance(PEGASUS_NAMESPACENAME_INTEROP,
instObjectManager.getPath(),
false, false, false, statPropertyList);
prop_num = updatedInstance.findProperty(gathStatName);
PEGASUS_TEST_ASSERT(prop_num != PEG_NOT_FOUND);
CIMProperty p = updatedInstance.getProperty(prop_num);
CIMValue v = p.getValue();
Boolean rtn;
v.get(rtn);
//// Need to get it again
cout << "Updated Status= " << ((rtn)? "true" : "false") << endl;
return(rtn);
}