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;
}
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 _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 _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);
}
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);
}
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;
}
/**
***************************************************************************
_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");
}
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);
}
}
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);
}
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;
}
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;
}
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 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);
}
}
// get the current provider test parameters.
void tests::get(Uint64& instanceSize, Uint64& responseCount)
{
Array<CIMParamValue> InParams;
Array<CIMParamValue> outParams;
InParams.append(CIMParamValue("ResponseInstanceSize", instanceSize));
InParams.append(CIMParamValue("ResponseCount", responseCount));
CIMValue returnValue = client.invokeMethod(
testNamespaceName,
CIMObjectPath(String::EMPTY,
CIMNamespaceName(),
CIMName(testClass)),
CIMName("get"),
InParams,
outParams);
Uint32 rc;
returnValue.get(rc);
CIMPLE_TEST_ASSERT(rc == 0);
for(Uint32 i = 0; i < outParams.size(); ++i)
{
String paramName = outParams[i].getParameterName();
CIMValue v = outParams[i].getValue();
if(paramName =="ResponseCount")
{
v.get(responseCount);
}
else if(paramName =="ResponseInstanceSize")
{
v.get(instanceSize);
}
else
{
cout <<"Error: unknown parameter name = " << paramName << endl;
CIMPLE_TEST_ASSERT(false);
}
}
}
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 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 _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();
}
/* 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"));
}
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);
}
void _checkUint32Value (CIMValue & theValue, Uint32 value)
{
PEGASUS_TEST_ASSERT (theValue.getType () == CIMTYPE_UINT32);
PEGASUS_TEST_ASSERT (!theValue.isArray ());
PEGASUS_TEST_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_TEST_ASSERT (result == value);
}
String IndicationFormatter::_getBooleanStr(
const CIMValue & booleanCIMValue)
{
PEG_METHOD_ENTER (TRC_IND_FORMATTER,
"IndicationFormatter::_getBooleanStr");
Boolean propertyValueBoolean;
booleanCIMValue.get(propertyValueBoolean);
if (propertyValueBoolean)
{
PEG_METHOD_EXIT();
return ("true");
}
else
{
PEG_METHOD_EXIT();
return ("false");
}
}
void _sendIndicationShouldFail
(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);
CIMValue retValue = client.invokeMethod
(SOURCENAMESPACE,
className,
methodName,
inParams,
outParams);
retValue.get (result);
PEGASUS_TEST_ASSERT (result == 1);
}
Sint32 _getValue(
CIMClient &client,
const String &className,
const CIMName &methodName)
{
Array<CIMParamValue> inParams;
Array<CIMParamValue> outParams;
CIMObjectPath instName =
CIMObjectPath(className);
CIMValue returnValue = client.invokeMethod(
NAMESPACE,
instName,
methodName,
inParams,
outParams);
Sint32 rc;
returnValue.get(rc);
return rc;
}
/**
***************************************************************************
_filterAssociationInstancesByRole is used to filter the list of association
instances against the specified role filter. It returns a list of
association instances that pass the filter test.
@param associationInstance - The target association instances
@param targetObjectPath - The target ObjectPath
@param role - The role filter. If there is no role, this
is String::EMPTY
@return the set of association instances that pass the filter test.
***************************************************************************
*/
Array<CIMInstance> ANHProvider::_filterAssociationInstancesByRole(
const Array<CIMInstance>& associationInstances,
const CIMObjectPath& targetObjectPath,
const String& role)
{
Array<CIMInstance> returnInstances;
// Filter the instances from the list of association instances against
// the specified role filter
//
for (Uint32 i = 0, n = associationInstances.size(); i < n; i++)
{
CIMInstance instance = associationInstances[i];
// Search the association instance for all reference properties
for (Uint32 j = 0, m = instance.getPropertyCount(); j < m; j++)
{
const CIMProperty p = instance.getProperty(j);
if (p.getType() == CIMTYPE_REFERENCE)
{
CIMValue v = p.getValue();
CIMObjectPath path;
v.get(path);
if ((role == String::EMPTY) ||
(p.getName() == CIMName(role)))
{
if (targetObjectPath.identical(path))
{
returnInstances.append(instance);
}
}
}
}
}
return returnInstances;
}
// set the instanceSize and response count parameters in the
// client
void tests::set(Uint64 instanceSize, Uint64 responseCount)
{
Array<CIMParamValue> InParams;
Array<CIMParamValue> outParams;
InParams.append(CIMParamValue("ResponseCount", responseCount));
InParams.append(CIMParamValue("ResponseInstanceSize", instanceSize));
CIMValue returnValue = client.invokeMethod(
testNamespaceName,
CIMObjectPath(String::EMPTY,
CIMNamespaceName(),
CIMName(testClass)),
CIMName("set"),
InParams,
outParams);
CIMPLE_TEST_ASSERT(outParams.size() == 0);
Uint32 rc;
returnValue.get(rc);
CIMPLE_TEST_ASSERT(rc == 0);
}
//
// Send test indications
// The RT_IndicationProvider SendTestIndication method is invoked
// If the provider is enabled, it sends two test indications
// (the second test indication includes SNMP trap OID)
//
Sint32 _sendTestIndications
(CIMClient & client)
{
//
// Invoke method to send test indication
//
Array <CIMParamValue> inParams;
Array <CIMParamValue> outParams;
Array <CIMKeyBinding> keyBindings;
Sint32 result;
CIMObjectPath className (String::EMPTY, CIMNamespaceName (),
CIMName ("RT_TestIndication"), keyBindings);
CIMValue retValue = client.invokeMethod
(SOURCENAMESPACE,
className,
CIMName ("SendTestIndication"),
inParams,
outParams);
retValue.get (result);
return result;
}
// Tests PROPERTY as an embedded object.
static void testGetInstanceElement(const char* testDataFile)
{
//--------------------------------------------------------------------------
// Read in instance
//--------------------------------------------------------------------------
CIMInstance cimInstance;
Buffer text;
FileSystem::loadFileToMemory(text, testDataFile);
XmlParser parser((char*)text.getData());
XmlReader::getInstanceElement(parser, cimInstance);
PEGASUS_TEST_ASSERT(
cimInstance.getClassName() == CIMName("CIM_InstCreation"));
Uint32 idx;
CIMProperty cimProperty;
CIMValue cimValue;
CIMType cimType;
PEGASUS_TEST_ASSERT(cimInstance.getPropertyCount() == 3);
idx = cimInstance.findProperty(CIMName("IndicationIdentifier"));
PEGASUS_TEST_ASSERT(idx != PEG_NOT_FOUND);
cimProperty = cimInstance.getProperty(idx);
cimValue = cimProperty.getValue();
cimType = cimProperty.getType();
PEGASUS_TEST_ASSERT(strcmp(cimTypeToString(cimType), "string") == 0);
String myString;
cimValue.get(myString);
PEGASUS_TEST_ASSERT(strcmp(myString.getCString(), "0") == 0);
idx = cimInstance.findProperty(CIMName("IndicationTime"));
PEGASUS_TEST_ASSERT(idx != PEG_NOT_FOUND);
cimProperty = cimInstance.getProperty(idx);
cimValue = cimProperty.getValue();
cimType = cimProperty.getType();
PEGASUS_TEST_ASSERT(strcmp(cimTypeToString(cimType), "datetime") == 0);
CIMDateTime myDateTime;
cimValue.get(myDateTime);
PEGASUS_TEST_ASSERT(myDateTime.equal(
CIMDateTime("20050227225624.524000-300")));
idx = cimInstance.findProperty(CIMName("SourceInstance"));
PEGASUS_TEST_ASSERT(idx != PEG_NOT_FOUND);
cimProperty = cimInstance.getProperty(idx);
cimValue = cimProperty.getValue();
cimType = cimProperty.getType();
PEGASUS_TEST_ASSERT(strcmp(cimTypeToString(cimType), "object") == 0);
CIMObject cimObject;
cimValue.get(cimObject);
PEGASUS_TEST_ASSERT(
cimObject.getClassName() ==
CIMName("Sample_LifecycleIndicationProviderClass"));
PEGASUS_TEST_ASSERT(cimObject.getPropertyCount() == 2);
idx = cimObject.findProperty(CIMName("uniqueId"));
PEGASUS_TEST_ASSERT(idx != PEG_NOT_FOUND);
cimProperty = cimObject.getProperty(idx);
cimValue = cimProperty.getValue();
cimType = cimProperty.getType();
PEGASUS_TEST_ASSERT(strcmp(cimTypeToString(cimType), "uint32") == 0);
Uint32 myUint32;
cimValue.get(myUint32);
PEGASUS_TEST_ASSERT(myUint32 == 1);
idx = cimObject.findProperty(CIMName("lastOp"));
PEGASUS_TEST_ASSERT(idx != PEG_NOT_FOUND);
cimProperty = cimObject.getProperty(idx);
cimValue = cimProperty.getValue();
cimType = cimProperty.getType();
PEGASUS_TEST_ASSERT(strcmp(cimTypeToString(cimType), "string") == 0);
cimValue.get(myString);
PEGASUS_TEST_ASSERT(strcmp(myString.getCString(), "createInstance") == 0);
}