void testCreateLocalAuthFile(void)
{
int testUid;
int testGid;
PEGASUS_TEST_ASSERT(
GetUserInfo(PEGASUS_CIMSERVERMAIN_USER, &testUid, &testGid) == 0);
/* Test with file path that already exists */
{
ssize_t result;
const char* path = "testlocalauthfile";
int fd = open(path, O_WRONLY | O_EXCL | O_CREAT | O_TRUNC, S_IRUSR);
EXECUTOR_RESTART(write(fd, "test", 4), result);
close(fd);
PEGASUS_TEST_ASSERT(CreateLocalAuthFile(path, testUid, testGid) == 0);
unlink(path);
}
/* Test with non-existent directory in file path */
{
const char* path =
"/tmp/nonexistentdirectory/anotherone/pegasus/localauthtestfile";
PEGASUS_TEST_ASSERT(CreateLocalAuthFile(path, testUid, testGid) != 0);
}
}
void testCheckLocalAuthToken(void)
{
/* Test with file path that does not exist */
{
const char* path = "nonexistenttestfile";
PEGASUS_TEST_ASSERT(CheckLocalAuthToken(path, "secret") != 0);
}
/* Test with secret token that is too short */
{
ssize_t result;
const char* path = "testlocalauthfile";
int fd = open(path, O_WRONLY | O_EXCL | O_CREAT | O_TRUNC, S_IRUSR);
EXECUTOR_RESTART(write(fd, "secret", 6), result);
close(fd);
PEGASUS_TEST_ASSERT(CheckLocalAuthToken(path, "secret") != 0);
unlink(path);
}
/* Test with incorrect secret token */
{
ssize_t result;
const char* path = "testlocalauthfile";
int fd = open(path, O_WRONLY | O_EXCL | O_CREAT | O_TRUNC, S_IRUSR);
EXECUTOR_RESTART(
write(fd, "1234567890123456789012345678901234567890", 40), result);
close(fd);
PEGASUS_TEST_ASSERT(CheckLocalAuthToken(
path, "123456789012345678901234567890123456789X") != 0);
unlink(path);
}
}
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
test06 (CIMClient & client)
{
CIMObjectPath instanceName;
Uint32 exception =0;
instanceName.setNameSpace (providerNamespace);
instanceName.setClassName (CLASSNAME);
Array < CIMParamValue > inParams;
Array < CIMParamValue > outParams;
/* String returnDateTime(); */
try {
CIMValue retValue = client.invokeMethod (providerNamespace,
instanceName,
"noSuchFunction",
inParams,
outParams);
} catch (const CIMException &e)
{
exception ++;
PEGASUS_TEST_ASSERT (e.getCode() == CIM_ERR_NOT_FOUND);
}
PEGASUS_TEST_ASSERT (exception == 1);
}
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 runCIMNameCastTests()
{
try
{
CIMName name(CIMNameCast("Okay"));
}
catch (...)
{
PEGASUS_TEST_ASSERT(false);
}
Boolean caught = false;
try
{
CIMName name(CIMNameCast("Not Okay"));
}
catch (InvalidNameException& e)
{
caught = true;
}
catch (...)
{
PEGASUS_TEST_ASSERT(false);
}
#if defined(PEGASUS_DEBUG)
PEGASUS_TEST_ASSERT(caught);
#else
PEGASUS_TEST_ASSERT(!caught);
#endif
}
//Test reference array type properties
void test05()
{
Array<CIMObjectPath> oa;
oa.append(CIMObjectPath("/root/cimv2:My_Class.a=1"));
oa.append(CIMObjectPath("/root/cimv2:My_Class.a=2"));
CIMProperty p1;
Boolean gotException = false;
try
{
p1 = CIMProperty(CIMName("property1"), oa, 0, CIMName("refclass"));
}
catch (TypeMismatchException&)
{
gotException = true;
}
PEGASUS_TEST_ASSERT(gotException);
p1 = CIMProperty(CIMName("property1"), oa[0], 0, CIMName("refclass"));
gotException = false;
try
{
p1.setValue(oa);
}
catch (TypeMismatchException&)
{
gotException = true;
}
PEGASUS_TEST_ASSERT(gotException);
}
// Test Thread and AtomicInt
void test02()
{
const Uint32 numThreads = 64;
AtomicInt * atom = new AtomicInt(0);
Thread* threads[numThreads];
(*atom)++;
Boolean zero = atom->decAndTestIfZero();
PEGASUS_TEST_ASSERT(zero);
for (Uint32 i=0; i<numThreads; i++)
{
threads[i] = new Thread(atomicIncrement, atom, false);
}
for (Uint32 i=0; i<numThreads; i++)
{
threads[i]->run();
}
for (Uint32 i=0; i<numThreads; i++)
{
threads[i]->join();
delete threads[i];
}
PEGASUS_TEST_ASSERT(atom->get() == numThreads);
delete atom;
}
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 testCleanupIdleThread()
{
if (verbose)
{
cout << "testCleanupIdleThread" << endl;
}
try
{
struct timeval deallocateWait = { 0, 1 };
ThreadPool threadPool(0, "test cleanup", 0, 6, deallocateWait);
threadPool.allocate_and_awaken(
(void*)1, funcSleepSpecifiedMilliseconds);
Threads::sleep(1000);
PEGASUS_TEST_ASSERT(threadPool.idleCount() == 1);
threadPool.cleanupIdleThreads();
PEGASUS_TEST_ASSERT(threadPool.idleCount() == 0);
}
catch (const Exception& e)
{
cout << "Exception in testCleanupIdleThread: " <<
e.getMessage() << endl;
PEGASUS_TEST_ASSERT(false);
}
}
PEGASUS_NAMESPACE_END
void CompareQualifiers(
CIMRepository& r1,
CIMRepository& r2,
const CIMNamespaceName& namespaceName)
{
Array<CIMQualifierDecl> quals1 = r1.enumerateQualifiers(namespaceName);
Array<CIMQualifierDecl> quals2 = r2.enumerateQualifiers(namespaceName);
PEGASUS_TEST_ASSERT(quals1.size() == quals2.size());
BubbleSort(quals1);
BubbleSort(quals2);
for (Uint32 i = 0; i < quals2.size(); i++)
{
if (verbose)
{
cout << "testing qualifier " << namespaceName.getString() << "/";
cout << quals1[i].getName().getString() << "/ against /";
cout << quals2[i].getName().getString() << "/" << endl;
}
PEGASUS_TEST_ASSERT(quals1[i].identical(quals2[i]));
}
}
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 testInstancesTransfer(
CIMRepository& oldRepository,
CIMRepository& newRepository,
const CIMNamespaceName& ns,
const CIMName& className)
{
Array<CIMInstance> i1 =
oldRepository.enumerateInstancesForClass(ns, className);
Array<CIMInstance> i2 =
newRepository.enumerateInstancesForClass(ns, className);
PEGASUS_TEST_ASSERT(i1.size() == i2.size());
for (Uint32 i = 0; i < i1.size(); i++)
{
Boolean found = false;
for (Uint32 j = 0; j < i2.size(); j++)
{
if (i1[i].identical(i2[j]))
{
found = true;
break;
}
}
PEGASUS_TEST_ASSERT(found);
}
}
void
test_async_queue::async_handleEnqueue (AsyncOpNode * op,
MessageQueue * q, void *parm)
{
// I am static, get a pointer to my object
test_async_queue *myself = static_cast < test_async_queue * >(q);
async_start *rq = static_cast < async_start * >(op->removeRequest());
PEGASUS_TEST_ASSERT(rq != 0);
async_complete *rp = static_cast < async_complete * >(op->removeResponse());
PEGASUS_TEST_ASSERT(rp != 0);
if ((rq->getType () == ASYNC_ASYNC_OP_START) &&
(rp->getType () == ASYNC_ASYNC_OP_RESULT))
{
Message *cim_rq = rq->get_action ();
Message *cim_rp = rp->get_result_data ();
PEGASUS_TEST_ASSERT (cim_rq->getType () ==
CIM_GET_INSTANCE_REQUEST_MESSAGE);
PEGASUS_TEST_ASSERT (cim_rp->getType () ==
CIM_GET_INSTANCE_RESPONSE_MESSAGE);
test_async_queue::msg_count++;
delete cim_rp;
delete cim_rq;
delete rp;
delete rq;
delete op;
}
}
void _checkUint32Property
(CIMInstance & instance, const String & name, Uint32 value)
{
Uint32 pos = instance.findProperty (name);
PEGASUS_TEST_ASSERT (pos != PEG_NOT_FOUND);
CIMProperty theProperty = instance.getProperty (pos);
CIMValue theValue = theProperty.getValue ();
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);
}
void
test_async_queue::_handle_async_request (AsyncRequest * rq)
{
if ((rq->getType () == ASYNC_ASYNC_OP_START) ||
(rq->getType () == ASYNC_ASYNC_LEGACY_OP_START))
{
try {
PEGASUS_TEST_ASSERT (_role == SERVER);
Message *response_data =
new Message (CIM_GET_INSTANCE_RESPONSE_MESSAGE);
async_complete *response_msg =
new async_complete (static_cast < async_start & >(*rq),
async_results::OK,
response_data);
_complete_op_node (rq->op);
} catch (const PEGASUS_STD(bad_alloc) &)
{
cerr <<" Out of memory!" << endl;
}
}
else if (rq->getType () == ASYNC_CIMSERVICE_STOP)
{
PEGASUS_TEST_ASSERT (_role == SERVER);
_handle_stop ((CimServiceStop *) rq);
}
else
Base::_handle_async_request (rq);
}
void TestQualifiers()
{
// -- Create repository and qualifier test namespace:
const CIMNamespaceName QNS = CIMNamespaceName ("TestQualifiers");
try
{
r->createNameSpace(QNS);
}
catch (AlreadyExistsException&)
{
// Ignore this!
}
// -- Construct a qualifier declaration:
CIMQualifierDecl q(CIMName ("abstract"), true, CIMScope::CLASS);
r->setQualifier(QNS, q);
CIMQualifierDecl qq = r->getQualifier(QNS, CIMName ("abstract"));
PEGASUS_TEST_ASSERT(qq.identical(q));
PEGASUS_TEST_ASSERT(q.identical(qq));
// -- Delete the qualifier:
r->deleteQualifier(QNS, CIMName ("abstract"));
// -- Delete the namespace:
r->deleteNameSpace(QNS);
}
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;
}
void _checkUint64Property
(CIMInstance & instance, const String & name, Uint64 value)
{
Uint32 pos = instance.findProperty (name);
PEGASUS_TEST_ASSERT (pos != PEG_NOT_FOUND);
CIMProperty theProperty = instance.getProperty (pos);
CIMValue theValue = theProperty.getValue ();
PEGASUS_TEST_ASSERT (theValue.getType () == CIMTYPE_UINT64);
PEGASUS_TEST_ASSERT (!theValue.isArray ());
PEGASUS_TEST_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_TEST_ASSERT (result == value);
}
void
test_async_queue::_handle_async_callback (AsyncOpNode * op)
{
PEGASUS_TEST_ASSERT (_role == CLIENT);
PEGASUS_TEST_ASSERT (op->getState() & ASYNC_OPSTATE_COMPLETE);
Base::_handle_async_callback (op);
}
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);
}
}
void drive_Schema(QueryContext& _query)
{
CIMName base("CQL_TestElement");
CIMClass _class = _query.getClass(base);
PEGASUS_TEST_ASSERT(_class.getClassName() == base);
Array<CIMName> names = _query.enumerateClassNames(base);
PEGASUS_TEST_ASSERT(names.size() == 2);
CIMName derived("CQL_TestPropertyTypes");
PEGASUS_TEST_ASSERT(_query.isSubClass(base, derived));
PEGASUS_TEST_ASSERT(!_query.isSubClass(derived, base));
PEGASUS_TEST_ASSERT(
_query.getClassRelation(base, base) == QueryContext::SAMECLASS);
PEGASUS_TEST_ASSERT(
_query.getClassRelation(base, derived) == QueryContext::SUBCLASS);
PEGASUS_TEST_ASSERT(
_query.getClassRelation(derived, base) == QueryContext::SUPERCLASS);
CIMName unrelated("CIM_Process");
PEGASUS_TEST_ASSERT(
_query.getClassRelation(base, unrelated) == QueryContext::NOTRELATED);
PEGASUS_TEST_ASSERT(
_query.getClassRelation(unrelated, base) == QueryContext::NOTRELATED);
}
void testSharedArrayPtr()
{
Monkey::numConstructions = 0;
Monkey::numDestructions = 0;
{
SharedArrayPtr<Monkey> p1(new Monkey[3]);
PEGASUS_TEST_ASSERT(Monkey::numConstructions == 3);
PEGASUS_TEST_ASSERT(Monkey::numDestructions == 0);
SharedArrayPtr<Monkey> p5(new Monkey[2]);
p1 = p5;
PEGASUS_TEST_ASSERT(Monkey::numConstructions == 5);
PEGASUS_TEST_ASSERT(Monkey::numDestructions == 3);
PEGASUS_TEST_ASSERT(p1[0].index == p5[0].index);
PEGASUS_TEST_ASSERT(p1[1].index == p5[1].index);
PEGASUS_TEST_ASSERT(p1[0].index != p1[1].index);
}
PEGASUS_TEST_ASSERT(Monkey::numConstructions == 5);
PEGASUS_TEST_ASSERT(Monkey::numDestructions == 5);
}
void testClearMethod()
{
// Test with a variety of object types in the From ResponseData
// Build the class
CIMClass CIMclass1 = buildClass();
// Build a CIM Instance. NOTE: key is defaulted in class
CIMInstance CIMInst1 = CIMclass1.buildInstance(true, true,
CIMPropertyList());
// Clone the instance and change key
CIMInstance CIMInst2 = CIMInst1.clone();
setPropertyValue(CIMInst2, "id", 2);
CIMInstance CIMInst3 = CIMInst1.clone();
setPropertyValue(CIMInst3, "id", 3);
CIMInstance CIMInst4 = CIMInst1.clone();
setPropertyValue(CIMInst4, "id", 4);
// build CIMInstance array
Array<CIMInstance> CIMInstArray;
CIMInstArray.append(CIMInst1);
CIMInstArray.append(CIMInst2);
CIMInstArray.append(CIMInst3);
CIMInstArray.append(CIMInst4);
// Create CIMReponseData object
CIMResponseData crd = CIMResponseData(CIMResponseData::RESP_INSTANCES);
// Append an array of CIMInstances
crd.appendInstances(CIMInstArray);
PEGASUS_TEST_ASSERT(crd.size() == 4);
// Build SCMO instances
SCMOClass SCMO_CSClass(CIMclass1);
VCOUT << "Creating SCMOInstance from CIMInstance" << endl;
SCMOInstance SCMO_CSInstance3(SCMO_CSClass,CIMInst3);
SCMOInstance SCMO_CSInstance4(SCMO_CSClass,CIMInst4);
// Create array of 2 SCMO Instances
Array<SCMOInstance> SCMOInstArray;
SCMOInstArray.append(SCMO_CSInstance3);
SCMOInstArray.append(SCMO_CSInstance4);
crd.appendSCMO(SCMOInstArray);
PEGASUS_TEST_ASSERT(crd.size() == 6);
crd.clear();
PEGASUS_TEST_ASSERT(crd.size() == 0);
}
//Test reference type properties
void test04()
{
// Create reference type property from string input and reference class name
String p = "//localhost/root/SampleProvider:"
"TST_PersonDynamic.Name=\"Father\"";
CIMObjectPath path = p;
String referenceClassName = "TST_Person";
CIMProperty p1(CIMName ("message"), path, 0,
CIMName(referenceClassName));
PEGASUS_TEST_ASSERT(!p1.isArray());
PEGASUS_TEST_ASSERT(p1.getReferenceClassName()==
CIMName(referenceClassName));
PEGASUS_TEST_ASSERT(p1.getType() == CIMTYPE_REFERENCE);
CIMValue v1;
v1 = p1.getValue();
PEGASUS_TEST_ASSERT(v1.getType() == CIMTYPE_REFERENCE);
PEGASUS_TEST_ASSERT(!v1.isNull());
CIMObjectPath pathout;
v1.get(pathout);
PEGASUS_TEST_ASSERT( pathout == path );
if(verbose)
XmlWriter::printPropertyElement(p1, cout);
// Now create an empty property, one used in class declaration
// for a reference
CIMProperty p2(CIMName ("parent"), CIMObjectPath(),
0, CIMName(referenceClassName));
PEGASUS_TEST_ASSERT(!p2.isArray());
PEGASUS_TEST_ASSERT(p2.getReferenceClassName() ==
CIMName(referenceClassName));
PEGASUS_TEST_ASSERT(p2.getType() == CIMTYPE_REFERENCE);
CIMValue v2;
v2 = p2.getValue();
PEGASUS_TEST_ASSERT(v2.getType() == CIMTYPE_REFERENCE);
// ATTN: P3 KS 27 Feb 2003. Why does the following test not work.
// I assume that the value should
// be null in this case.
//PEGASUS_TEST_ASSERT(v2.isNull());
CIMObjectPath pathout2;
v1.get(pathout2);
// Now compare the paths
if(verbose)
XmlWriter::printPropertyElement(p2, cout);
}
void _checkResult(const Array<CIMInstance> & instArr)
{
// provider returns exactly six instances
PEGASUS_TEST_ASSERT(6==instArr.size());
for (int i=0; i<6;i++)
{
const CIMObjectPath& objPath = instArr[i].getPath();
const Array<CIMKeyBinding>& keyBinds = objPath.getKeyBindings();
// instance should have three key bindings
PEGASUS_TEST_ASSERT(3==keyBinds.size());
}
}
void testCIMOMHandle()
{
ProviderStatus status;
status.setInitialized(true);
status.setCIMOMHandle((CIMOMHandle*) 10);
PEGASUS_TEST_ASSERT(status.getCIMOMHandle() == (CIMOMHandle*) 10);
status.setInitialized(false);
PEGASUS_TEST_ASSERT(status.getCIMOMHandle() == 0);
status.setInitialized(true);
CIMOMHandle cimomHandle;
status.setCIMOMHandle(&cimomHandle);
PEGASUS_TEST_ASSERT(status.isIdle());
cimomHandle.disallowProviderUnload();
PEGASUS_TEST_ASSERT(!status.isIdle());
cimomHandle.disallowProviderUnload();
PEGASUS_TEST_ASSERT(!status.isIdle());
cimomHandle.allowProviderUnload();
PEGASUS_TEST_ASSERT(!status.isIdle());
cimomHandle.allowProviderUnload();
PEGASUS_TEST_ASSERT(status.isIdle());
// An extra allowProviderUnload() call should be ignored
cimomHandle.allowProviderUnload();
PEGASUS_TEST_ASSERT(status.isIdle());
}
// Test handling of escape characters
void test05()
{
{
// Test '\' and '"' characters in a key value
// This represents MyClass.key1="\\\"\"\\",key2="\"\"\"\"\\\\\\\\"
String s1 = "MyClass.key1=\"\\\\\\\"\\\"\\\\\","
"key2=\"\\\"\\\"\\\"\\\"\\\\\\\\\\\\\\\\\"";
CIMObjectPath r1 = s1;
PEGASUS_TEST_ASSERT(r1.toString() == s1);
}
// Catch invalid escape sequences in a key value
Boolean errorDetected;
// Invalid trailing backslash
errorDetected = false;
try
{
CIMObjectPath r1("MyClass.key1=\"\\\"");
}
catch (const MalformedObjectNameException&)
{
errorDetected = true;
}
PEGASUS_TEST_ASSERT(errorDetected);
// Invalid "\n" sequence
errorDetected = false;
try
{
CIMObjectPath r1("MyClass.key1=\"\\n\"");
}
catch (const MalformedObjectNameException&)
{
errorDetected = true;
}
PEGASUS_TEST_ASSERT(errorDetected);
// Invalid hex sequence
errorDetected = false;
try
{
CIMObjectPath r1("MyClass.key1=\"\\x000A\"");
}
catch (const MalformedObjectNameException&)
{
errorDetected = true;
}
PEGASUS_TEST_ASSERT(errorDetected);
}
void testUserContextRequestor()
{
try
{
CIMClient client;
client.connectLocal();
// Determine whether the CIM Server has authentication enabled
CIMObjectPath authConfigInstName = CIMObjectPath(
"PG_ConfigSetting.PropertyName=\"enableAuthentication\"");
CIMInstance authConfigInst =
client.getInstance("root/PG_Internal", authConfigInstName);
String authConfigValue;
authConfigInst.getProperty(authConfigInst.findProperty("CurrentValue"))
.getValue().get(authConfigValue);
Boolean authenticationEnabled =
String::equalNoCase(authConfigValue, "true");
// Test a provider running in Requestor user context
CIMObjectPath instName =
CIMObjectPath("TST_UserContextRequestor.Id=1");
CIMInstance cimInstance = client.getInstance(NAMESPACE, instName);
String userContext;
cimInstance.getProperty(cimInstance.findProperty("UserContext"))
.getValue().get(userContext);
if (verbose)
{
cout << "Requestor test: UserContext = " << userContext << endl;
}
if (authenticationEnabled)
{
PEGASUS_TEST_ASSERT(userContext == System::getEffectiveUserName());
}
else
{
PEGASUS_TEST_ASSERT(userContext == serverUserContext);
}
}
catch (Exception& e)
{
cerr << "Error: " << e.getMessage() << endl;
exit(1);
}
}
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;
}
