CMPIStatus TestCMPIBrokerInstanceProviderModifyInstance (CMPIInstanceMI * mi, const CMPIContext * ctx, const CMPIResult * rslt, const CMPIObjectPath * cop, const CMPIInstance * ci, const char **properties) { CMPIString* type; CMPIBoolean bol=0; CMPIStatus rc = {CMPI_RC_OK, NULL}; PROV_LOG_OPEN (_ClassName, _ProviderLocation); PROV_LOG ("Inside Modify Instance"); /* Testcases for increasing coverage in CMPI_BrokerEnc.cpp*/ type = CDGetType (_broker, rslt, &rc); PROV_LOG ("++++ Status of mbEncGetType with input of type " "CMPIResult with CMPI_ResultResponseOnStack_Ftab : (%s) type(%s)", strCMPIStatus (rc), CMGetCharsPtr(type, NULL)); bol = CDIsOfType (_broker, rslt, "CMPIResult", &rc); if ( bol ) { PROV_LOG ("++++ CDIsOfType for CMPIResult with " "CMPI_ResultResponseOnStack_Ftab status is (%s) : %d", strCMPIStatus (rc), bol); } PROV_LOG_CLOSE (); CMReturn (CMPI_RC_OK); }
CMPIStatus TestCMPIIndicationProviderActivateFilter (CMPIIndicationMI * mi, CMPIContext * ctx, CMPIResult * rslt, CMPISelectExp * se, const char *ns, CMPIObjectPath * op, CMPIBoolean firstActivation) #endif { CMPIContext *context; //void **arguments[4]; const void **arguments = (const void **) malloc (4 * sizeof (char *)); CMPIStatus rc_Clone = { CMPI_RC_OK, NULL }; PROV_LOG_OPEN (_IndClassName, _ProviderLocation); PROV_LOG ("--- %s CMPI ActivateFilter() called", _IndClassName); // Get a new CMPI_Context which the thread will use. context = CBPrepareAttachThread (_broker, ctx); // We have to pass in the parameters some way. We are passing the // addresses of them via the void pointer to the thread. // This could also be achieved via passing it thread-specific data. arguments[0] = se; arguments[1] = context; arguments[2] = _broker; arguments[3] = strdup(ns); // Spawn of a new thread! _broker->xft->newThread (thread, (void *)arguments, 0); PROV_LOG ("--- %s CMPI ActivateFilter() exited", _IndClassName); CMReturn (CMPI_RC_OK); }
CMPIStatus TestCMPIAssociationProviderAssociatorNames( CMPIAssociationMI* mi, const CMPIContext* ctx, const CMPIResult* rslt, const CMPIObjectPath* ref, const char* _RefLeftClass, const char* _RefRightClass, const char* role, const char* resultRole) { CMPIObjectPath* op = NULL; CMPIObjectPath* rop = NULL; CMPIEnumeration* en = NULL; CMPIData data ; CMPIStatus rc = { CMPI_RC_OK, NULL }; PROV_LOG_OPEN (_ClassName, _ProviderLocation); PROV_LOG ("\n\n********************* %s CMPI AssociatorNames() called", _ClassName); /* get object path of the target class */ op = get_assoc_targetClass_ObjectPath( _broker, ref, _RefLeftClass, _RefRightClass, &rc); PROV_LOG (" New Object Path [%s]", CMGetCharsPtr (CMGetNameSpace (ref, &rc),NULL)); /* create new object path of association */ rop = CMNewObjectPath( _broker, CMGetCharsPtr(CMGetNameSpace(ref,&rc),NULL), _ClassName, &rc ); /* upcall to CIMOM; call enumInstanceNames() of the target class */ en = CBEnumInstanceNames( _broker, ctx, op, &rc); /* as long as object path entries are found in the enumeration */ while( CMHasNext( en, &rc) ) { /* get the object path */ data = CMGetNext(en, &rc); /* and return the target class object path as result of the * associatorNames() call */ CMReturnObjectPath( rslt, data.value.ref ); } PROV_LOG ("\n\n********************* %s CMPI AssociatorNames() exited", _ClassName); PROV_LOG_CLOSE (); return rc; }
CMPIStatus TestCMPIAssociationProviderAssociators( CMPIAssociationMI* mi, const CMPIContext* ctx, const CMPIResult* rslt, const CMPIObjectPath* ref, const char* _RefLeftClass, const char* _RefRightClass, const char* role, const char* resultRole, const char** properties) { CMPIObjectPath * op = NULL; CMPIEnumeration * en = NULL; CMPIData data ; CMPIStatus rc = { CMPI_RC_OK, NULL }; CMPIString * sourceClass = NULL; PROV_LOG_OPEN (_ClassName, _ProviderLocation); PROV_LOG ("\n\n********************* %s CMPI Associators() called", _ClassName); sourceClass = CMGetClassName(ref,&rc); /* get object path of the target class */ op = get_assoc_targetClass_ObjectPath( _broker, ref, _RefLeftClass, _RefRightClass, &rc); sourceClass = CMGetClassName(op,&rc); PROV_LOG(" target class: %s ",CMGetCharsPtr(sourceClass,NULL)); PROV_LOG (" New Object Path [%s]", CMGetCharsPtr (CMGetNameSpace (ref, &rc),NULL)); /* Call to Associators */ /* upcall to CIMOM; call enumInstances() of the target class */ en = CBEnumInstances( _broker, ctx, op, NULL, &rc); /* as long as instance entries are found in the enumeration */ while( CMHasNext( en, &rc) ) { /* get the instance */ data = CMGetNext( en, &rc); /* and return the target class instance as result of the * associators() call */ CMReturnInstance( rslt, data.value.inst ); } PROV_LOG ("\n\n********************* %s CMPI Associators exited", _ClassName); PROV_LOG_CLOSE (); return rc; }
CMPIStatus TestCMPIBrokerInstanceProviderEnumInstanceNames (CMPIInstanceMI * mi, const CMPIContext * ctx, const CMPIResult * rslt, const CMPIObjectPath * ref) { PROV_LOG_OPEN (_ClassName, _ProviderLocation); PROV_LOG ("Inside Enumerate Instance Names"); PROV_LOG_CLOSE (); CMReturn (CMPI_RC_ERR_NOT_SUPPORTED); }
CMPIStatus TestCMPIBrokerInstanceProviderDeleteInstance (CMPIInstanceMI * mi, const CMPIContext * ctx, const CMPIResult * rslt, const CMPIObjectPath * cop) { PROV_LOG_OPEN (_ClassName, _ProviderLocation); PROV_LOG ("Inside Delete Instance"); PROV_LOG_CLOSE (); CMRelease (_inst); CMReturn (CMPI_RC_OK); }
CMPIStatus TestCMPIBrokerInstanceProviderExecQuery (CMPIInstanceMI * mi, const CMPIContext * ctx, const CMPIResult * rslt, const CMPIObjectPath * ref, const char *lang, const char *query) { CMPIData retData; CMPIString* type; CMPIBoolean bol=0; CMPIStatus rc = {CMPI_RC_OK, NULL}; PROV_LOG_OPEN (_ClassName, _ProviderLocation); PROV_LOG ("ExecQuery"); retData = CMGetProperty(_inst, "n64", &rc); PROV_LOG("++++ Status of CMGetProperty : (%s)", strCMPIStatus(rc)); PROV_LOG("n64 = %" PEGASUS_64BIT_CONVERSION_WIDTH "u", retData.value.uint64); type = CDGetType (_broker, rslt, &rc); PROV_LOG ("++++ Status of mbEncGetType with input of type " "CMPIResult with CMPI_ResultExecQueryOnStack_Ftab : (%s) type(%s)", strCMPIStatus (rc), CMGetCharsPtr(type, NULL)); bol = CDIsOfType (_broker, rslt, "CMPIResult", &rc); if ( bol ) { PROV_LOG ("++++ CDIsOfType for CMPIResult with " "CMPI_ResultExecQueryOnStack_Ftab status is (%s) : %d", strCMPIStatus (rc), bol); } PROV_LOG_CLOSE(); CMReturnInstance(rslt, _inst); CMReturnDone(rslt); CMReturn (CMPI_RC_OK); }
CMPIStatus TestCMPIBrokerInstanceProviderGetInstance (CMPIInstanceMI * mi, const CMPIContext * ctx, const CMPIResult * rslt, const CMPIObjectPath * cop, const char **properties) { CMPIStatus rc = {CMPI_RC_OK, NULL}; CMPIString* retNamespace; CMPIString* retClassname; CMPIString* type; CMPIData retData; CMPIObjectPath* obj; CMPIBoolean bol = 0; const char* str1; const char* str2; PROV_LOG_OPEN (_ClassName, _ProviderLocation); PROV_LOG("GetInstance"); PROV_LOG("++++Namespace "); obj = CMGetObjectPath(_inst, &rc); PROV_LOG("++++ Status of CMGetObjectPath : (%s)", strCMPIStatus(rc)); retNamespace = CMGetNameSpace(obj, &rc); PROV_LOG("++++ Status of CMGetNameSpace : (%s)", strCMPIStatus(rc)); retClassname = CMGetClassName(obj, &rc); PROV_LOG("++++ Status of CMGetClassName : (%s)", strCMPIStatus(rc)); str1 = CMGetCharsPtr(retNamespace, &rc); PROV_LOG("++++ Status of CMGetCharsPtr : (%s)", strCMPIStatus(rc)); str2 = CMGetCharsPtr(retClassname, &rc); PROV_LOG("++++ Status of CMGetCharsPtr : (%s)", strCMPIStatus(rc)); retData = CMGetProperty(_inst, "n64", &rc); PROV_LOG("++++ Status of CMGetProperty : (%s)", strCMPIStatus(rc)); PROV_LOG("n64 = %" PEGASUS_64BIT_CONVERSION_WIDTH "u", retData.value.uint64); /* Test cases for increasing coverage in CMPI_BrokerEnc.cpp*/ type = CDGetType (_broker, rslt, &rc); PROV_LOG ("++++ Status of mbEncGetType with input of type " "CMPIResult with CMPI_ResultInstOnStack_Ftab : (%s) type(%s)", strCMPIStatus (rc), CMGetCharsPtr(type, NULL)); bol = CDIsOfType (_broker, rslt, "CMPIResult", &rc); if ( bol ) { PROV_LOG ("++++ CDIsOfType for CMPIResult with " "CMPI_ResultInstOnStack_Ftab status is (%s) : %d", strCMPIStatus (rc), bol); } PROV_LOG_CLOSE(); if (_inst) { CMReturnInstance(rslt, _inst); CMReturnDone(rslt); CMReturn (CMPI_RC_OK); } else { CMReturn (CMPI_RC_ERR_NOT_SUPPORTED); } }
CMPIStatus TestCMPIBrokerInstanceProviderCreateInstance (CMPIInstanceMI * mi, const CMPIContext * ctx, const CMPIResult * rslt, const CMPIObjectPath * cop, const CMPIInstance * ci) { const CMPIString* retNamespace; const CMPIString* retClassname; CMPIString* type; const char* str1; const char* str2; CMPIStatus rc = { CMPI_RC_OK, NULL }; CMPIData retData; CMPIObjectPath *obj; CMPIBoolean bol = 0; PROV_LOG_OPEN (_ClassName, _ProviderLocation); PROV_LOG("CreateInstance"); retNamespace = CMGetNameSpace(cop, &rc); retClassname = CMGetClassName(cop, &rc); str1 = CMGetCharsPtr(retNamespace, &rc); str2 = CMGetCharsPtr(retClassname, &rc); PROV_LOG("++++Obtained Namespace : (%s) Class (%s)", str1, str2); if(ci) { /* Test to increase coverage in Broker_Enc.cpp*/ type = CDToString (_broker, ci, &rc); PROV_LOG ("++++ Passing CMPIInstance with CMPI_InstanceOnStack_Ftab " "to mbEncToString successes : " "(%s)", strCMPIStatus (rc)); type = CDGetType (_broker, ci, &rc); PROV_LOG ("++++ Status of mbEncGetType with input of type CMPIInstance" " : (%s) type(%s)", strCMPIStatus (rc), CMGetCharsPtr(type, NULL)); bol = CDIsOfType (_broker, ci, "CMPIInstance", &rc); if ( bol ) { PROV_LOG ("++++ CDIsOfType for CMPIInstance with " "CMPI_InstanceOnStack_Ftab status is (%s) : %d", strCMPIStatus (rc), bol); } type = CDToString (_broker, cop, &rc); PROV_LOG ("++++ Passing CMPIObjectPath with " "CMPI_ObjectPathOnStack_Ftab to mbEncToString successes : (%s)", strCMPIStatus (rc)); type = CDGetType (_broker, cop, &rc); PROV_LOG ("++++ Status of mbEncGetType with input of type " "CMPIObjectPath : (%s) type(%s)", strCMPIStatus (rc), CMGetCharsPtr(type, NULL)); bol = CDIsOfType (_broker, cop, "CMPIObjectPath", &rc); if ( bol ) { PROV_LOG ("++++ CDIsOfType for CMPIObjectPath with " "CMPI_ObjectPathOnStack_Ftab status is (%s) : %d", strCMPIStatus (rc), bol); } type = CDGetType (_broker, rslt, &rc); PROV_LOG ("++++ Status of mbEncGetType with input of type " "CMPIResult with CMPI_ResultRefOnStack_Ftab : (%s) type(%s)", strCMPIStatus (rc), CMGetCharsPtr(type, NULL)); bol = CDIsOfType (_broker, rslt, "CMPIResult", &rc); if ( bol ) { PROV_LOG ("++++ CDIsOfType for CMPIResult with " "CMPI_ResultRefOnStack_Ftab status is (%s) : %d", strCMPIStatus (rc), bol); } _inst = CMClone(ci, &rc); PROV_LOG("++++ Status of CMClone(ci) : (%s)", strCMPIStatus(rc)); CMSetObjectPath (_inst, cop); PROV_LOG("++++ Status of CMSetObjectPath(_inst) : (%s)", strCMPIStatus(rc)); _setProperty1(_inst, "*"); retData = CMGetProperty(_inst, "n64", &rc); PROV_LOG("++++ Status of CMGetProperty : (%s)", strCMPIStatus(rc)); PROV_LOG("n64 = %" PEGASUS_64BIT_CONVERSION_WIDTH "u", retData.value.uint64); retData = CMGetProperty(_inst, "n32", &rc); PROV_LOG("++++ Status of CMGetProperty : (%s)", strCMPIStatus(rc)); PROV_LOG("n32 = %d", retData.value.uint32); obj = CMGetObjectPath(_inst, &rc); PROV_LOG("++++ Status of CMGetObjectPath : (%s)", strCMPIStatus(rc)); retNamespace = CMGetNameSpace(obj, &rc); PROV_LOG("++++ Status of CMGetNameSpace : (%s)", strCMPIStatus(rc)); retClassname = CMGetClassName(obj, &rc); PROV_LOG("++++ Status of CMGetClassName : (%s)", strCMPIStatus(rc)); str1 = CMGetCharsPtr(retNamespace, &rc); PROV_LOG("++++ Status of CMGetCharsPtr : (%s)", strCMPIStatus(rc)); str2 = CMGetCharsPtr(retClassname, &rc); PROV_LOG("++++ Status of CMGetCharsPtr : (%s)", strCMPIStatus(rc)); PROV_LOG("++++Namespace (_inst): (%s) Class (*%s)", str1, str2); retData = CMGetProperty(_inst, "n64", &rc); PROV_LOG("++++ Status of CMGetProperty : (%s)", strCMPIStatus(rc)); PROV_LOG("n64 = %" PEGASUS_64BIT_CONVERSION_WIDTH "u", retData.value.uint64); PROV_LOG_CLOSE (); CMReturnObjectPath(rslt, cop); CMReturnDone(rslt); CMReturn (CMPI_RC_OK); } else { PROV_LOG_CLOSE (); CMReturn (CMPI_RC_ERR_NOT_SUPPORTED); } }
// To increase the coverage in CMPIBrokerEnc.cpp static int _testBrokerEnc (const CMPIContext * ctx, const CMPIResult * rslt) { int flag = 1 ; int count; char* msgId; char* illegal; char path[100]; void* hdl; CMPIStatus rc = { CMPI_RC_OK, NULL }; CMPIString *type; CMPIString *cmpiStr; CMPIBoolean bol=0; CMPIBoolean bool=0; CMPIArray* cmpiArray = NULL ; CMPIInstance* instance = NULL; CMPIInstance* instance1 = NULL; CMPIInstance* instanceErr = NULL; CMPIObjectPath* objPath = NULL; CMPIObjectPath* objPath1 = NULL; CMPICount cmpiCnt = 5; CMPIType cmpiType = CMPI_uint64; CMPIDateTime* cmpiDateTime = NULL ; CMPIMsgFileHandle msgFileHandle; CMPIEnumeration* cmpiEnum; CMPISelectExp* selExp; CMPIValue val; CMPIError* err; CMPIStatus* rc1 = NULL; CMPIArgs* args = NULL; void* handle; CMPIInstanceFT* funcTable; PROV_LOG ("++++ _testBrokerEnc "); PROV_LOG ("++++ ObjectPath testing"); objPath1 = CMNewObjectPath (_broker, NULL, _ClassName, &rc); PROV_LOG ("++++ New object path with NULL namespace creation : (%s)", strCMPIStatus (rc)); CMRelease(objPath1); objPath1 = CMNewObjectPath (_broker, _Namespace, "abc", &rc); PROV_LOG ("++++ New object path with wrong classname : (%s)", strCMPIStatus (rc)); instance = CMNewInstance(_broker, NULL, &rc); PROV_LOG ("++++ New Instance with NULL object path : (%s)", strCMPIStatus (rc)); handle = objPath1->hdl; objPath1->hdl=NULL; instance = CMNewInstance(_broker, objPath1, &rc); PROV_LOG ("++++ New Instance with object path handle set to NULL: (%s)", strCMPIStatus (rc)); objPath1->hdl = handle; objPath = make_ObjectPath(_broker, _Namespace, _ClassName); instance = CMNewInstance(_broker, objPath, &rc); PROV_LOG ("++++ New Instance creation status: (%s)", strCMPIStatus (rc)); instance1 = CMClone(instance, &rc); instanceErr = CMClone(instance, &rc); cmpiStr = CMNewString(_broker, NULL, &rc); PROV_LOG ("++++ Status of mbNewString with NULL parameter:(%s)", strCMPIStatus (rc)); err = CMNewCMPIError(_broker, "abc", "abc", "abc", 4, 5, 6, rc1); if (err) { PROV_LOG ("++++ CMNewCMPIError called with null rc"); } cmpiDateTime = CMNewDateTimeFromChars(_broker, "datetime", &rc); PROV_LOG ("++++ Status of CMNewDateTimeFromChars with junk parameter:(%s)", strCMPIStatus (rc)); if (!CMClassPathIsA(_broker, NULL, NULL, &rc)) { PROV_LOG ("++++ Error Status of CMClassPathIsA:(%s)", strCMPIStatus (rc)); } if (!CMClassPathIsA(_broker, objPath, NULL, &rc)) { PROV_LOG ("++++ Error Status of CMClassPathIsA:(%s)", strCMPIStatus (rc)); } illegal = "$"; if (!CMClassPathIsA(_broker, objPath, illegal, &rc)) { PROV_LOG ("++++ Error Status of CMClassPathIsA:(%s)", strCMPIStatus (rc)); } rc = CMLogMessage(_broker, 2, "TestProvider", "Testing Severity 2 in TestCMPIBrokerEnc", NULL); PROV_LOG ("++++ Status of CMLogMessage with Severity 2:(%s)", strCMPIStatus (rc)); rc = CMLogMessage(_broker, 3, "TestProvider", "Testing Severity 3 in TestCMPIBrokerEnc", NULL); PROV_LOG ("++++ Status of CMLogMessage with Severity 3:(%s)", strCMPIStatus (rc)); rc = CMLogMessage(_broker, 4, "TestProvider", "Testing Severity 4 in TestCMPIBrokerEnc", NULL); PROV_LOG ("++++ Status of CMLogMessage with Severity 4:(%s)", strCMPIStatus (rc)); rc = CMTraceMessage(_broker, 2, "CMPIProvider", "Tracing for level 2", NULL); PROV_LOG ("++++ Status of CMTraceMessage with level 2:(%s)", strCMPIStatus (rc)); rc = CMTraceMessage(_broker, 3, "CMPIProvider", "Tracing for level 3", NULL); PROV_LOG ("++++ Status of CMTraceMessage with level 3:(%s)", strCMPIStatus (rc)); rc = CMTraceMessage(_broker, 4, "CMPIProvider", "Tracing for level 4", NULL); PROV_LOG ("++++ Status of CMTraceMessage with level 4:(%s)", strCMPIStatus (rc)); cmpiStr = CMNewString(_broker, "Tracing for level 5", &rc); rc = CMTraceMessage(_broker, 5, "CMPIProvider", NULL, cmpiStr); PROV_LOG ("++++ Status of CMTraceMessage with level 5:(%s)", strCMPIStatus (rc)); CMRelease(cmpiStr); PROV_LOG ("++++ Calling mbEncToString function "); type = CDToString (_broker, _broker, &rc); PROV_LOG ("++++ Error status of mbEncToString with wrong object path:" " (%s)", strCMPIStatus (rc)); type = CDToString (_broker, NULL, &rc); PROV_LOG ("++++ Error status of mbEncToString with NULL parameter:" " (%s)", strCMPIStatus (rc)); type = CDToString (_broker, type, &rc); PROV_LOG ("++++ Passing CMPIString to mbEncToString successes : (%s)", strCMPIStatus (rc)); type = CDToString (_broker, objPath, &rc); PROV_LOG ("++++ Passing CMPIObjectPath to mbEncToString successes : (%s)", strCMPIStatus (rc)); handle = objPath1->hdl; objPath1->hdl = NULL; type = CDToString (_broker, objPath1, &rc); if ( rc.rc == CMPI_RC_ERR_INVALID_PARAMETER) { PROV_LOG ("++++ Error status of mbEncToString with object path with " "NULL handle: (%s)", strCMPIStatus (rc)); } objPath1->hdl = handle; val.boolean = 1; rc = CMSetProperty (instance, "Boolean", &val, CMPI_boolean); PROV_LOG ("++++ Status of CMSetProperty of type CMPI_boolean : (%s)", strCMPIStatus (rc)); val.uint8 = 8; rc = CMSetProperty (instance, "Uint8", &val, CMPI_uint8); PROV_LOG ("++++ Status of CMSetProperty of type CMPI_uint8 : (%s)", strCMPIStatus (rc)); val.uint16 = 16; rc = CMSetProperty (instance, "Uint16", &val, CMPI_uint16); PROV_LOG ("++++ Status of CMSetProperty of type CMPI_uint16 : (%s)", strCMPIStatus (rc)); val.uint32 = 32; rc = CMSetProperty (instance, "Uint32", &val, CMPI_uint32); PROV_LOG ("++++ Status of CMSetProperty of type CMPI_uint32 : (%s)", strCMPIStatus (rc)); val.uint64 = 64; rc = CMSetProperty (instance, "Uint64", &val, CMPI_uint64); PROV_LOG ("++++ Status of CMSetProperty of type CMPI_uint64 : (%s)", strCMPIStatus (rc)); val.sint8 = -8; rc = CMSetProperty (instance, "Sint8", &val, CMPI_sint8); PROV_LOG ("++++ Status of CMSetProperty of type CMPI_sint8 : (%s)", strCMPIStatus (rc)); val.sint16 = -16; rc = CMSetProperty (instance, "Sint16", &val, CMPI_sint16); PROV_LOG ("++++ Status of CMSetProperty of type CMPI_sint16 : (%s)", strCMPIStatus (rc)); val.sint32 = -32; rc = CMSetProperty (instance, "Sint32", &val, CMPI_sint32); PROV_LOG ("++++ Status of CMSetProperty of type CMPI_sint32 : (%s)", strCMPIStatus (rc)); val.sint64 = -64; rc = CMSetProperty (instance, "Sint64", &val, CMPI_sint64); PROV_LOG ("++++ Status of CMSetProperty of type CMPI_sint64 : (%s)", strCMPIStatus (rc)); val.real32 = 32.32; rc = CMSetProperty (instance, "Real32", &val, CMPI_real32); PROV_LOG ("++++ Status of CMSetProperty of type CMPI_real32 : (%s)", strCMPIStatus (rc)); val.real64 = 64.64; rc = CMSetProperty (instance, "Real64", &val, CMPI_real64); PROV_LOG ("++++ Status of CMSetProperty of type CMPI_real64 : (%s)", strCMPIStatus (rc)); val.char16 = 'c'; rc = CMSetProperty (instance, "Char16", &val, CMPI_char16); PROV_LOG ("++++ Status of CMSetProperty of type CMPI_char16 : (%s)", strCMPIStatus (rc)); cmpiDateTime = CMNewDateTime (_broker, &rc); val.dateTime = cmpiDateTime; rc = CMSetProperty (instance, "DateTime", &val, CMPI_dateTime); PROV_LOG ("++++ Status of CMSetProperty of type CMPI_dateTime : (%s)", strCMPIStatus (rc)); val.ref = objPath; rc = CMSetProperty (instance, "Ref", &val, CMPI_ref); PROV_LOG ("++++ Status of CMSetProperty of type CMPI_ref : (%s)", strCMPIStatus (rc)); val.inst = instance1; rc = CMSetProperty (instance, "Instance", &val, CMPI_instance); PROV_LOG ("++++ Status of CMSetProperty of type CMPI_instance : (%s)", strCMPIStatus (rc)); type = CDToString (_broker, instance, &rc); PROV_LOG ("++++ Passing CMPIInstance to mbEncToString successes : (%s)", strCMPIStatus (rc)); args = CMNewArgs(_broker, &rc); PROV_LOG ("++++ Status of CMNewArgs : (%s)", strCMPIStatus (rc)); type = CDToString (_broker, args, &rc); PROV_LOG ("++++ Passing CMPIArgs to mbEncToString successes : (%s)", strCMPIStatus (rc)); PROV_LOG ("++++ Calling mbEncGetType function "); rc1 = NULL; type = CDGetType (_broker, NULL, rc1); if (!type) { PROV_LOG ("++++ Error calling mbEncGetType with NULL rc"); } rc1 = NULL; funcTable = instanceErr->ft; instanceErr->ft = NULL; type = CDGetType (_broker, instanceErr, rc1); if (!type) { PROV_LOG ("++++ Error calling mbEncGetType with wrong parameter and" " NULL rc"); } type = CDGetType (_broker, instanceErr, &rc); PROV_LOG ("++++ Error status of mbEncGetType with wrong input : (%s)", strCMPIStatus (rc)); instanceErr->ft = funcTable; type = CDGetType (_broker, NULL, &rc); PROV_LOG ("++++ Error status of mbEncGetType with NULL input : (%s)", strCMPIStatus (rc)); type = CDGetType (_broker, instance, &rc); PROV_LOG ("++++ Status of mbEncGetType with input of type CMPIInstance" " : (%s) type(%s)", strCMPIStatus (rc), CMGetCharsPtr(type, NULL)); type = CDGetType (_broker, objPath, &rc); PROV_LOG ("++++ Status of mbEncGetType with input of type CMPIObjectPath:" " (%s) type(%s)", strCMPIStatus (rc), CMGetCharsPtr(type, NULL)); cmpiStr = CMNewString(_broker, "Test1", & rc); type = CDGetType (_broker, cmpiStr, &rc); PROV_LOG ("++++ Status of mbEncGetType with input of type CMPIString:" " (%s) type(%s)", strCMPIStatus (rc), CMGetCharsPtr(type, NULL)); type = CDGetType (_broker, _broker, &rc); PROV_LOG ("++++ Status of mbEncGetType with input of type CMPIBroker:" " (%s) type(%s)", strCMPIStatus (rc), CMGetCharsPtr(type, NULL)); cmpiArray = CMNewArray(_broker, cmpiCnt,cmpiType, &rc); type = CDGetType (_broker, cmpiArray, &rc); PROV_LOG ("++++ Status of mbEncGetType with input of type CMPIArray:" " (%s) type(%s)", strCMPIStatus (rc), CMGetCharsPtr(type, NULL)); type = CDGetType (_broker, cmpiDateTime, &rc); PROV_LOG ("++++ Status of mbEncGetType with input of type CMPIDateTime:" " (%s) type(%s)", strCMPIStatus (rc), CMGetCharsPtr(type, NULL)); type = CDGetType (_broker, ctx, &rc); PROV_LOG ("++++ Status of mbEncGetType with input of type CMPIContext:" " (%s) type(%s)", strCMPIStatus (rc), CMGetCharsPtr(type, NULL)); type = CDGetType (_broker, rslt, &rc); PROV_LOG ("++++ Status of mbEncGetType with input of type CMPIResult:" " (%s) type(%s)", strCMPIStatus (rc), CMGetCharsPtr(type, NULL)); rc1 = NULL; selExp = CMNewSelectExp(_broker, "SELECT c,b FROM TestCMPI_Indication WHERE c='c' OR b=1", "WQL", NULL, rc1); PROV_LOG ("++++ CMNewSelectExp with rc set to NULL Called"); selExp = CMNewSelectExp(_broker, "SELECT c,b FROM TestCMPI_Indication", "WQL", NULL, &rc); PROV_LOG ("++++ Status of CMNewSelectExp: (%s) ", strCMPIStatus (rc)); type = CDGetType (_broker, selExp, &rc); PROV_LOG ("++++ Status of mbEncGetType with input of type CMPISelectExp:" " (%s) type(%s)", strCMPIStatus (rc), CMGetCharsPtr(type, NULL)); handle = objPath1->hdl; objPath1->hdl = NULL; rc = CMRelease(objPath1); PROV_LOG ("++++ Status of CMRelease(objPath1): (%s)", strCMPIStatus (rc)); objPath1->hdl = handle; rc = CMRelease(objPath1); PROV_LOG ("++++ Status of CMRelease(objPath1): (%s)", strCMPIStatus (rc)); objPath1 = CMNewObjectPath(_broker, "test/TestProvider", "TestCMPI_Instance", &rc); PROV_LOG ("++++ Status of CMNewObjectPath for TestCMPI_Instance : (%s)", strCMPIStatus (rc)); PROV_LOG_CLOSE(); cmpiEnum = CBEnumInstances(_broker, ctx, objPath1, NULL, &rc); PROV_LOG_OPEN (_ClassName, _ProviderLocation); PROV_LOG ("++++ Status of CBEnumInstances : (%s)", strCMPIStatus (rc)); type = CDGetType (_broker, cmpiEnum, &rc); PROV_LOG ("++++ Status of mbEncGetType with input of type CMPIEnumeration:" " (%s) type(%s)", strCMPIStatus (rc), CMGetCharsPtr(type, NULL)); type = CDGetType (_broker, args, &rc); PROV_LOG ("++++ Status of mbEncGetType with input of type CMPIArgs:" " (%s) type(%s)", strCMPIStatus (rc), CMGetCharsPtr(type, NULL)); PROV_LOG ("++++ Calling mbEncIsOfType function "); bol = CDIsOfType (_broker, NULL, "No object", rc1); if(!bol) { PROV_LOG ("++++Calling mbEncIsOfType with NULL rc and wrong" " parameters"); } bol = CDIsOfType (_broker, instance, "CMPIInstance", rc1); if(!bol) { PROV_LOG ("++++ Calling mbEncIsOfType with NULL rc"); } bol = CDIsOfType (_broker, NULL, "No object", &rc); PROV_LOG ("++++ Error Status of mbEncIsOfType : (%s)", strCMPIStatus (rc)); bol = CDIsOfType (_broker, instance, "CMPIInstance", &rc); if ( bol ) { PROV_LOG ("++++ CDIsOfType for CMPIInstance status is (%s) : %d", strCMPIStatus (rc), bol); } bol = CDIsOfType (_broker, instance, "CMPI", &rc); if ( !bol ) { PROV_LOG ("++++ CDIsOfType for CMPIInstance status is (%s) : %d", strCMPIStatus (rc), bol); } bol = CDIsOfType (_broker, objPath, "CMPIObjectPath", &rc); if (bol) { PROV_LOG ("++++ CDIsOfType for CMPIObjectPath status is (%s) : %d", strCMPIStatus (rc), bol); } bol = CDIsOfType (_broker, objPath, "CMPI", &rc); if (!bol) { PROV_LOG ("++++ CDIsOfType for CMPIObjectPath status is (%s) : %d", strCMPIStatus (rc), bol); } bol = CDIsOfType (_broker, cmpiDateTime, "CMPIDateTime", &rc); if (bol) { PROV_LOG ("++++ CDIsOfType for CMPIDateTime status is (%s) : %d", strCMPIStatus (rc), bol); } bol = CDIsOfType (_broker, cmpiDateTime, "CMPI", &rc); if (!bol) { PROV_LOG ("++++ CDIsOfType for CMPIDateTime status is (%s) : %d", strCMPIStatus (rc), bol); } bol = CDIsOfType (_broker, cmpiStr, "CMPIString", &rc); if (bol) { PROV_LOG ("++++ CDIsOfType for CMPIString status is (%s) : %d", strCMPIStatus (rc), bol); } bol = CDIsOfType (_broker, cmpiStr, "CMPI", &rc); if (!bol) { PROV_LOG ("++++ CDIsOfType for CMPIString status is (%s) : %d", strCMPIStatus (rc), bol); } bol = CDIsOfType (_broker, _broker, "CMPIBroker", &rc); if (bol) { PROV_LOG ("++++ CDIsOfType for CMPIBroker status is (%s) : %d", strCMPIStatus (rc), bol); } bol = CDIsOfType (_broker, _broker, "CMPI", &rc); if (!bol) { PROV_LOG ("++++ CDIsOfType for CMPIBroker status is (%s) : %d", strCMPIStatus (rc), bol); } bol = CDIsOfType (_broker, cmpiArray, "CMPIArray", &rc); if (bol) { PROV_LOG ("++++ CDIsOfType for CMPIArray status is (%s) : %d", strCMPIStatus (rc), bol); } bol = CDIsOfType (_broker, cmpiArray, "CMPI", &rc); if (!bol) { PROV_LOG ("++++ CDIsOfType for CMPIArray status is (%s) : %d", strCMPIStatus (rc), bol); } bol = CDIsOfType (_broker, rslt, "CMPIResult", &rc); if (bol) { PROV_LOG ("++++ CDIsOfType for CMPIResult status is (%s) : %d", strCMPIStatus (rc), bol); } bol = CDIsOfType (_broker, rslt, "CMPI", &rc); if (!bol) { PROV_LOG ("++++ CDIsOfType for CMPIResult status is (%s) : %d", strCMPIStatus (rc), bol); } bol = CDIsOfType (_broker, ctx, "CMPIContext", &rc); if (bol) { PROV_LOG ("++++ CDIsOfType for CMPIContext status is (%s) : %d", strCMPIStatus (rc), bol); } bol = CDIsOfType (_broker, ctx, "CMPI", &rc); if (!bol) { PROV_LOG ("++++ CDIsOfType for CMPIContext status is (%s) : %d", strCMPIStatus (rc), bol); } bol = CDIsOfType (_broker, cmpiEnum, "CMPIEnumeration", &rc); if (bol) { PROV_LOG ("++++ CDIsOfType for CMPIEnumeration status is (%s) : %d", strCMPIStatus (rc), bol); } bol = CDIsOfType (_broker, cmpiEnum, "CMPI", &rc); if (!bol) { PROV_LOG ("++++ CDIsOfType for CMPIEnumeration status is (%s) : %d", strCMPIStatus (rc), bol); } /* Testcase to increase coverage in CMPI_Enumeration.cpp*/ rc = CMRelease(cmpiEnum); PROV_LOG ("++++ Status of CMRelease on cmpiEnum :(%s)", strCMPIStatus (rc)); /**********************************************************/ bol = CDIsOfType (_broker, selExp, "CMPISelectExp", &rc); if (bol) { PROV_LOG ("++++ CDIsOfType for CMPISelectExp status is (%s) : %d", strCMPIStatus (rc), bol); } bol = CDIsOfType (_broker, selExp, "CMPI", &rc); if (!bol) { PROV_LOG ("++++ CDIsOfType for CMPISelectExp status is (%s) : %d", strCMPIStatus (rc), bol); } bol = CDIsOfType (_broker, args, "CMPIArgs", &rc); if (bol) { PROV_LOG ("++++ CDIsOfType for CMPIArgs status is (%s) : %d", strCMPIStatus (rc), bol); } bol = CDIsOfType (_broker, args, "CMPI", &rc); if (!bol) { PROV_LOG ("++++ CdIsOfType for CMPIArgs status is (%s) : %d", strCMPIStatus (rc), bol); } type = CMGetMessage (_broker, "msgid", "Test 0 arguments", &rc, 0); PROV_LOG ("++++ Status of GetMessage with 0 arguments(%s) type (%s)", strCMPIStatus (rc), CMGetCharsPtr(type, NULL)); type = CMGetMessage (_broker, "msgid", "Test $0", &rc, CMFmtArgs1(CMFmtChars("one argument"))); PROV_LOG ("++++ Status of GetMessage with 1 arguments(%s) type (%s)", strCMPIStatus (rc), CMGetCharsPtr(type, NULL)); type = CMGetMessage (_broker, "msgid", "Test $0 $1", &rc, CMFmtArgs2(CMFmtChars("Sint32 ::"), CMFmtSint(-1))); PROV_LOG ("++++ Status of GetMessage with 2 arguments(%s) type (%s)", strCMPIStatus (rc), CMGetCharsPtr(type, NULL)); type = CMGetMessage (_broker, "msgid", "Test $0 $1, $2", &rc, CMFmtArgs3(CMFmtChars("Sint32, Uint32 ::"), CMFmtSint(-1), CMFmtUint(1))); PROV_LOG ("++++ Status of GetMessage with 3 arguments(%s) type (%s)", strCMPIStatus (rc), CMGetCharsPtr(type, NULL)); type = CMGetMessage (_broker, "msgid", "Test $0 $1, $2, $3", &rc, CMFmtArgs4(CMFmtChars("Sint32, Uint32, Sint64 ::"), CMFmtSint(-1), CMFmtUint(1), CMFmtSint64(-64))); PROV_LOG ("++++ Status of GetMessage with 4 arguments(%s) type (%s)", strCMPIStatus (rc), CMGetCharsPtr(type, NULL)); type = CMGetMessage (_broker, "msgid", "Test $0 $1, $2, $3, $4", &rc, CMFmtArgs5(CMFmtChars("Sint32, Uint32, Sint64, Uint64 ::"), CMFmtSint(-1), CMFmtUint(1), CMFmtSint64(-64), CMFmtUint64(64))); PROV_LOG ("++++ Status of GetMessage with 5 arguments(%s) type (%s)", strCMPIStatus (rc), CMGetCharsPtr(type, NULL)); type = CMGetMessage (_broker, "msgid", "Test $0 $1, $2, $3, $4, $5", &rc, CMFmtArgs6(CMFmtChars("Sint32, Uint32, Sint64, Uint64, Real64 ::"), CMFmtSint(-1), CMFmtUint(1), CMFmtSint64(-64), CMFmtUint64(64), CMFmtReal(64.64))); PROV_LOG ("++++ Status of GetMessage with 6 arguments(%s) type (%s)", strCMPIStatus (rc), CMGetCharsPtr(type, NULL)); type = CMGetMessage (_broker, "msgid", "Test $0 $1, $2, $3, $4, $5, $6", &rc, CMFmtArgs7(CMFmtChars("Sint32, Uint32, Sint64, Uint64, Real64," " Boolean:: "), CMFmtSint(-1), CMFmtUint(1), CMFmtSint64(-64), CMFmtUint64(64), CMFmtReal(64.64), CMFmtBoolean(1))); PROV_LOG ("++++ Status of GetMessage with 7 arguments(%s) type (%s)", strCMPIStatus (rc), CMGetCharsPtr(type, NULL)); type = CMGetMessage (_broker, "msgid", "Test $0 $1, $2, $3, $4, $5, $6, $7", &rc, CMFmtArgs8(CMFmtChars("Sint32, Uint32, Sint64, Uint64, Real64," " Boolean, chars:: "), CMFmtSint(-1), CMFmtUint(1), CMFmtSint64(-64), CMFmtUint64(64), CMFmtReal(64.64), CMFmtBoolean(1), CMFmtChars("chars"))); PROV_LOG ("++++ Status of GetMessage with 8 arguments(%s) type (%s)", strCMPIStatus (rc), CMGetCharsPtr(type, NULL)); type = CMGetMessage (_broker, "msgid", "Test $0 $1, $2, $3, $4, $5, $6, $7, $8", &rc, CMFmtArgs9(CMFmtChars("Sint32, Uint32, Sint64, Uint64, Real64," " Boolean, chars, String :: "), CMFmtSint(-1), CMFmtUint(1), CMFmtSint64(-64), CMFmtUint64(64), CMFmtReal(64.64), CMFmtBoolean(1), CMFmtChars("chars"), CMFmtString(cmpiStr))); PROV_LOG ("++++ Status of GetMessage with 9 arguments (%s) type (%s)", strCMPIStatus (rc), CMGetCharsPtr(type, NULL)); strcpy(path,"path"); rc = CMOpenMessageFile(_broker, path, &msgFileHandle); PROV_LOG ("++++ Status of CMOpenMessageFile (%s) ", strCMPIStatus (rc)); type = CMGetMessage2(_broker, "Common.CIMStatusCode.CIM_ERR_SUCCESS", msgFileHandle, "Test zero arguments", &rc, 0); PROV_LOG ("++++ Status of GetMessage2 with 0 argument (%s) type (%s)", strCMPIStatus (rc), CMGetCharsPtr(type, NULL)); type = CMGetMessage2(_broker, "Common.CIMStatusCode.CIM_ERR_SUCCESS", msgFileHandle, "Test $0", &rc, CMFmtArgs1(CMFmtChars("Single argument"))); PROV_LOG ("++++ Status of GetMessage2 with 1 argument (%s) type (%s)", strCMPIStatus (rc), CMGetCharsPtr(type, NULL)); type = CMGetMessage2(_broker, "Common.CIMStatusCode.CIM_ERR_SUCCESS", msgFileHandle, "Test $0 $1", &rc, CMFmtArgs2(CMFmtChars("Sint32 ::"),CMFmtSint(1))); PROV_LOG ("++++ Status of GetMessage2 with 2 arguments (%s) type (%s)", strCMPIStatus (rc), CMGetCharsPtr(type, NULL)); type = CMGetMessage2 (_broker, "Common.CIMStatusCode.CIM_ERR_SUCCESS", msgFileHandle, "Test $0 $1, $2", &rc, CMFmtArgs3(CMFmtChars("Sint32, Uint32 :: "), CMFmtSint(-1), CMFmtUint(1))); PROV_LOG ("++++ Status of GetMessage2 with 3 arguments (%s) type (%s)", strCMPIStatus (rc), CMGetCharsPtr(type, NULL)); type = CMGetMessage2 (_broker, "Common.CIMStatusCode.CIM_ERR_SUCCESS", msgFileHandle, "Test $0 $1, $2, $3", &rc, CMFmtArgs4(CMFmtChars("Sint32, Uint32, Sint64 :: "), CMFmtSint(-1), CMFmtUint(1), CMFmtSint64(-64))); PROV_LOG ("++++ Status of GetMessage2 with 4 arguments (%s) type (%s)", strCMPIStatus (rc), CMGetCharsPtr(type, NULL)); type = CMGetMessage2 (_broker, "Common.CIMStatusCode.CIM_ERR_SUCCESS", msgFileHandle, "Test $0 $1, $2, $3, $4", &rc, CMFmtArgs5(CMFmtChars("Sint32, Uint32, Sint64, Uint64 :: "), CMFmtSint(-1), CMFmtUint(1), CMFmtSint64(-64), CMFmtUint64(64))); PROV_LOG ("++++ Status of GetMessage2 with 5 arguments (%s) type (%s)", strCMPIStatus (rc), CMGetCharsPtr(type, NULL)); type = CMGetMessage2 (_broker, "Common.CIMStatusCode.CIM_ERR_SUCCESS", msgFileHandle, "Test $0 $1, $2, $3, $4, $5", &rc, CMFmtArgs6(CMFmtChars("Sint32, Uint32, Sint64, Uint64, Real64 :: "), CMFmtSint(-1), CMFmtUint(1), CMFmtSint64(-64), CMFmtUint64(64), CMFmtReal(64.64))); PROV_LOG ("++++ Status of GetMessage2 with 6 arguments (%s) type (%s)", strCMPIStatus (rc), CMGetCharsPtr(type, NULL)); type = CMGetMessage2 (_broker, "Common.CIMStatusCode.CIM_ERR_SUCCESS", msgFileHandle, "Test $0 $1, $2, $3, $4, $5, $6", &rc, CMFmtArgs7(CMFmtChars("Sint32, Uint32, Sint64, Uint64, Real64," " Boolean :: "), CMFmtSint(-1), CMFmtUint(1), CMFmtSint64(-64), CMFmtUint64(64), CMFmtReal(64.64), CMFmtBoolean(1))); PROV_LOG ("++++ Status of GetMessage2 with 7 arguments (%s) type (%s)", strCMPIStatus (rc), CMGetCharsPtr(type, NULL)); type = CMGetMessage2 (_broker, "Common.CIMStatusCode.CIM_ERR_SUCCESS", msgFileHandle, "Test $0 $1, $2, $3, $4, $5, $6, $7", &rc, CMFmtArgs8(CMFmtChars("Sint32, Uint32, Sint64, Uint64, Real64," " Boolean, chars :: "), CMFmtSint(-1), CMFmtUint(1), CMFmtSint64(-64), CMFmtUint64(64), CMFmtReal(64.64), CMFmtBoolean(1), CMFmtChars("chars"))); PROV_LOG ("++++ Status of GetMessage2 with 8 arguments (%s) type (%s)", strCMPIStatus (rc), CMGetCharsPtr(type, NULL)); type = CMGetMessage2 (_broker, "Common.CIMStatusCode.CIM_ERR_SUCCESS", msgFileHandle, "Test $0 $1, $2, $3, $4, $5, $6, $7, $8", &rc, CMFmtArgs9(CMFmtChars("Sint32, Uint32, Sint64, Uint64, Real64," " Boolean, chars, String :: "), CMFmtSint(-1), CMFmtUint(1), CMFmtSint64(-64), CMFmtUint64(64), CMFmtReal(64.64), CMFmtBoolean(1), CMFmtChars("chars"), CMFmtString(cmpiStr))); PROV_LOG ("++++ Status of GetMessage2 with 9 arguments (%s) type (%s)", strCMPIStatus (rc), CMGetCharsPtr(type, NULL)); rc = CMCloseMessageFile(_broker, msgFileHandle); PROV_LOG ("++++ Status of CMCloseMessageFile (%s) ", strCMPIStatus (rc)); CMRelease(instance1); CMRelease(instanceErr); return flag ; }
CMPIStatus TestCMPIErrorProviderInvokeMethod (CMPIMethodMI * mi, const CMPIContext * ctx, const CMPIResult * rslt, const CMPIObjectPath * ref, const char *methodName, const CMPIArgs * in, CMPIArgs * out) { CMPIString *class_name = NULL; CMPIStatus rc = { CMPI_RC_OK, NULL }; CMPIError *cmpiError; CMPIError *cmpiErrorClone; CMPICount i, arrSize; CMPIObjectPath *objPath = NULL; CMPIUint32 brokerCapabilities; /* CMPIError data */ const char* inOwningEntity = "ACME"; CMPIString* outOwningEntity; const char* inMsgID = "ACME0023"; CMPIString* outMsgID; const char* inMsg = "ACME0023 Need to restock Road Runner bait and traps."; CMPIString* outMsg; const CMPIErrorSeverity inSev = ErrorSevMedium; CMPIErrorSeverity outSev; const CMPIErrorProbableCause inPc = Equipment_Malfunction; CMPIErrorProbableCause outPc; const CMPIrc inCIMStatusCode = CMPI_RC_ERR_FAILED; CMPIrc outCIMStatusCode; const char * inCIMStatusCodeDesc = "another failed attempt at road " "runner elimination"; CMPIString* outCIMStatusCodeDesc; const CMPIErrorType inErrType = OtherErrorType; CMPIErrorType outErrType; const char* inOtherErrType = "Pervasive Coyote Incompetance"; CMPIString* outOtherErrType; const char* inPcd = "Incorrect use of equipment"; CMPIString* outPcd; CMPIArray *inRecActions; CMPIArray *outRecActions; CMPIArray *inMsgArgs; CMPIArray *outMsgArgs; CMPIValue raOne; CMPIValue raTwo; const char* inErrSource = "Acme bomb"; CMPIString* outErrSource; const CMPIErrorSrcFormat inErrSourceFormat = CMPIErrSrcOther; CMPIErrorSrcFormat outErrSourceFormat; const char* inOtherErrSourceFormat = "no idea"; CMPIString* outOtherErrSourceFormat; CMPIData retData; PROV_LOG_OPEN (_ClassName, _ProviderLocation); PROV_LOG ("Calling CBGetBrokerCapabilities"); brokerCapabilities = CBGetBrokerCapabilities(_broker); if (brokerCapabilities & CMPI_MB_Supports_Extended_Error) { PROV_LOG("CMPI_MB_Supports_Extended_Error Support : True"); } else { PROV_LOG("CMPI_MB_Supports_Extended_Error Support : False"); CMReturnWithString(CMPI_RC_ERR_NOT_SUPPORTED, CMNewString(_broker, "Extended error support not avilable", NULL)); } PROV_LOG ("--- %s CMPI InvokeMethod() called", _ClassName); class_name = CMGetClassName (ref, &rc); PROV_LOG ("InvokeMethod: checking for correct classname [%s]", CMGetCharsPtr (class_name,NULL)); PROV_LOG ("Calling CMNewCMPIError"); cmpiError = CMNewCMPIError(_broker, inOwningEntity, inMsgID, inMsg, inSev, inPc, inCIMStatusCode, &rc); PROV_LOG ("++++ (%s) CMNewCMPIError", strCMPIStatus (rc)); PROV_LOG ("Calling CMSetErrorType"); rc = CMSetErrorType(cmpiError, inErrType); PROV_LOG ("++++ (%s) CMSetErrorType", strCMPIStatus (rc)); PROV_LOG ("Calling CMSetOtherErrorType"); rc = CMSetOtherErrorType(cmpiError, inOtherErrType); PROV_LOG ("++++ (%s) CMSetOtherErrorType", strCMPIStatus (rc)); PROV_LOG ("Calling CMSetProbableCauseDescription"); rc = CMSetProbableCauseDescription(cmpiError, inPcd); PROV_LOG ("++++ (%s) CMSetProbableCauseDescription", strCMPIStatus (rc)); inRecActions = CMNewArray(_broker, 2, CMPI_string, &rc); PROV_LOG ("++++ (%s) CMNewArray", strCMPIStatus (rc)); raOne.string = CMNewString(_broker, "Fire coyote.", &rc); PROV_LOG ("++++ (%s) CMNewString", strCMPIStatus (rc)); rc = CMSetArrayElementAt(inRecActions, 0, &raOne, CMPI_string); PROV_LOG ("++++ (%s) CMSetArrayElementAt [0]", strCMPIStatus (rc)); raTwo.string = CMNewString(_broker, "Give peace a chance.", &rc); PROV_LOG ("++++ (%s) CMNewString", strCMPIStatus (rc)); rc = CMSetArrayElementAt(inRecActions, 1, &raTwo, CMPI_string); PROV_LOG ("++++ (%s) CMSetArrayElementAt [1]", strCMPIStatus (rc)); PROV_LOG ("Calling CMSetRecommendedActions"); rc = CMSetRecommendedActions(cmpiError, inRecActions); PROV_LOG ("++++ (%s) CMSetRecommendedActions", strCMPIStatus (rc)); PROV_LOG ("Calling CMSetErrorSource"); rc = CMSetErrorSource(cmpiError, inErrSource); PROV_LOG ("++++ (%s) CMSetErrorSource", strCMPIStatus (rc)); PROV_LOG ("Calling CMSetErrorSourceFormat"); rc = CMSetErrorSourceFormat(cmpiError, inErrSourceFormat); PROV_LOG ("++++ (%s) CMSetErrorSourceFormat", strCMPIStatus (rc)); PROV_LOG ("Calling CMSetOtherErrorSourceFormat"); rc = CMSetOtherErrorSourceFormat(cmpiError, inOtherErrSourceFormat); PROV_LOG ("++++ (%s) CMSetOtherErrorSourceFormat", strCMPIStatus (rc)); PROV_LOG ("Calling CMSetCIMStatusCodeDescription"); rc = CMSetCIMStatusCodeDescription(cmpiError, inCIMStatusCodeDesc); PROV_LOG ("++++ (%s) CMSetCIMStatusCodeDescription", strCMPIStatus (rc)); inMsgArgs = CMNewArray(_broker, 1, CMPI_string, &rc); PROV_LOG ("++++ (%s) CMNewArray", strCMPIStatus (rc)); raOne.string = CMNewString(_broker, "no real inserts", &rc); PROV_LOG ("++++ (%s) CMNewString", strCMPIStatus (rc)); rc = CMSetArrayElementAt(inMsgArgs, 0, &raOne, CMPI_string); PROV_LOG ("++++ (%s) CMSetArrayElementAt [0]", strCMPIStatus (rc)); PROV_LOG ("Calling CMSetMessageArguments"); rc = CMSetMessageArguments(cmpiError, inMsgArgs); PROV_LOG ("++++ (%s) CMSetMessageArguments", strCMPIStatus (rc)); PROV_LOG ("First clone the CMPIError."); cmpiErrorClone = CMClone(cmpiError, &rc); PROV_LOG ("++++ (%s) CMClone", strCMPIStatus (rc)); PROV_LOG ("Ok, reading back fields to verify"); PROV_LOG ("Calling CMGetErrorType"); outErrType = CMGetErrorType(cmpiErrorClone, &rc); PROV_LOG ("++++ (%s) CMGetErrorType (%d)", strCMPIStatus (rc), outErrType); PROV_LOG ("Calling CMGetOtherErrorType"); outOtherErrType = CMGetOtherErrorType(cmpiErrorClone, &rc); PROV_LOG ("++++ (%s) CMGetOtherErrorType (%s)", strCMPIStatus (rc), CMGetCharsPtr(outOtherErrType,NULL)); PROV_LOG ("Calling CMGetOwningEntity"); outOwningEntity = CMGetOwningEntity(cmpiErrorClone, &rc); PROV_LOG ("++++ (%s) CMGetOwningEntity (%s)", strCMPIStatus (rc), CMGetCharsPtr(outOwningEntity,NULL)); PROV_LOG ("Calling CMGetMessageID"); outMsgID = CMGetMessageID(cmpiErrorClone, &rc); PROV_LOG ("++++ (%s) CMGetMessageID (%s)", strCMPIStatus (rc), CMGetCharsPtr(outMsgID,NULL)); PROV_LOG ("Calling CMGetErrorMessage"); outMsg = CMGetErrorMessage(cmpiErrorClone, &rc); PROV_LOG ("++++ (%s) CMGetErrorMessage (%s)", strCMPIStatus (rc), CMGetCharsPtr(outMsg,NULL)); PROV_LOG ("Calling CMGetPerceivedSeverity"); outSev = CMGetPerceivedSeverity(cmpiErrorClone, &rc); PROV_LOG ("++++ (%s) CMGetPerceivedSeverity (%d)", strCMPIStatus (rc), outSev); PROV_LOG ("Calling CMGetProbableCause"); outPc = CMGetProbableCause(cmpiErrorClone, &rc); PROV_LOG ("++++ (%s) CMGetProbableCause (%d)", strCMPIStatus (rc), outPc); PROV_LOG ("Calling CMGetProbableCauseDescription"); outPcd = CMGetProbableCauseDescription(cmpiErrorClone, &rc); PROV_LOG ("++++ (%s) CMGetProbableCauseDescription (%s)", strCMPIStatus (rc), CMGetCharsPtr(outPcd,NULL)); PROV_LOG ("Calling CMGetRecommendedActions"); outRecActions = CMGetRecommendedActions(cmpiErrorClone, &rc); PROV_LOG ("++++ (%s) CMGetRecommendedActions", strCMPIStatus (rc)); arrSize = CMGetArrayCount(outRecActions, &rc); PROV_LOG ("++++ (%s) CMGetArrayCount (%d)", strCMPIStatus (rc), arrSize); for (i = 0 ; i < arrSize ; i++) { CMPIData dta = CMGetArrayElementAt(outRecActions, i, &rc); PROV_LOG ("++++ (%s) CMGetArrayElementAt (%d:%s)", strCMPIStatus (rc), i, CMGetCharsPtr(dta.value.string,NULL)); } PROV_LOG ("Calling CMGetErrorSource"); outErrSource = CMGetErrorSource(cmpiErrorClone, &rc); PROV_LOG ("++++ (%s) CMGetErrorSource (%s)", strCMPIStatus (rc), CMGetCharsPtr(outErrSource,NULL)); PROV_LOG ("Calling CMGetErrorSourceFormat"); outErrSourceFormat = CMGetErrorSourceFormat(cmpiErrorClone, &rc); PROV_LOG ("++++ (%s) CMGetErrorSourceFormat (%d)", strCMPIStatus (rc), outErrSourceFormat); PROV_LOG ("Calling CMGetOtherErrorSourceFormat"); outOtherErrSourceFormat = CMGetOtherErrorSourceFormat(cmpiErrorClone, &rc); PROV_LOG ("++++ (%s) CMGetOtherErrorSourceFormat (%s)", strCMPIStatus (rc), CMGetCharsPtr(outOtherErrSourceFormat,NULL)); PROV_LOG ("Calling CMGetCIMStatusCode"); outCIMStatusCode = CMGetCIMStatusCode(cmpiErrorClone, &rc); PROV_LOG ("++++ (%s) CMGetCIMStatusCode (%d)", strCMPIStatus (rc), outCIMStatusCode); PROV_LOG ("Calling CMGetCIMStatusCodeDescription"); outCIMStatusCodeDesc = CMGetCIMStatusCodeDescription(cmpiErrorClone, &rc); PROV_LOG ("++++ (%s) CMGetCIMStatusCodeDescription (%s)", strCMPIStatus (rc), CMGetCharsPtr(outCIMStatusCodeDesc,NULL)); PROV_LOG ("Calling CMGetMessageArguments"); outMsgArgs = CMGetMessageArguments(cmpiErrorClone, &rc); PROV_LOG ("++++ (%s) CMGetMessageArguments", strCMPIStatus (rc)); arrSize = CMGetArrayCount(outMsgArgs, &rc); PROV_LOG ("++++ (%s) CMGetArrayCount (%d)", strCMPIStatus (rc), arrSize); for (i = 0 ; i < arrSize ; i++) { CMPIData dta = CMGetArrayElementAt(outMsgArgs, i, &rc); PROV_LOG ("++++ (%s) CMGetArrayElementAt (%d:%s)", strCMPIStatus (rc), i, CMGetCharsPtr(dta.value.string,NULL)); } PROV_LOG ("Calling CMPIResultFT.returnData"); rc = (rslt)->ft->returnError (rslt, cmpiErrorClone); PROV_LOG ("++++ (%s) returnData", strCMPIStatus (rc)); PROV_LOG ("Releasing cloned CMPIError"); rc = CMRelease(cmpiErrorClone); PROV_LOG ("++++ (%s) CMClone", strCMPIStatus (rc)); //Test Error Paths PROV_LOG ("Testing for Error Paths in CMPI_Error.cpp"); PROV_LOG ("Calling CMNewCMPIError"); cmpiError = CMNewCMPIError(_broker, inOwningEntity, inMsgID, inMsg, inSev, inPc, inCIMStatusCode, &rc); PROV_LOG ("++++ (%s) CMNewCMPIError", strCMPIStatus (rc)); PROV_LOG ("Calling CMGetErrorType without setting the ErrorType"); outErrType = CMGetErrorType(cmpiError, &rc); if (!outErrType) { PROV_LOG ("++++ (%s) CMGetErrorType (%d)", strCMPIStatus (rc), outErrType); } PROV_LOG ("Calling CMGetOtherErrorType without setting the OtherErrorType"); outOtherErrType = CMGetOtherErrorType(cmpiError, &rc); if (outOtherErrType == NULL) { PROV_LOG ("++++ (%s) CMGetOtherErrorType", strCMPIStatus (rc)); } PROV_LOG ("Testing CMSetMessageArguments"); CMRelease(inMsgArgs); inMsgArgs = CMNewArray(_broker, 1, CMPI_uint32, &rc); PROV_LOG ("++++ (%s) CMNewArray inMsgArgs of CMPI_uint32 type", strCMPIStatus (rc)); raOne.uint32 = 32; rc = CMSetArrayElementAt(inMsgArgs, 0, &raOne, CMPI_uint32); PROV_LOG ("++++ (%s) CMSetArrayElementAt [0]", strCMPIStatus (rc)); PROV_LOG ("Calling CMSetMessageArguments with input array of uint32"); rc = CMSetMessageArguments(cmpiError, inMsgArgs); PROV_LOG ("++++ (%s) CMSetMessageArguments", strCMPIStatus (rc)); inMsgArgs->hdl = NULL; PROV_LOG ("Calling CMSetMessageArguments with input array with NULL handle"); rc = CMSetMessageArguments(cmpiError, inMsgArgs); PROV_LOG ("++++ (%s) CMSetMessageArguments", strCMPIStatus (rc)); PROV_LOG ("Testing CMSetRecommendedActions"); CMRelease(inRecActions); inRecActions = CMNewArray(_broker, 1, CMPI_uint32, &rc); PROV_LOG ("++++ (%s) CMNewArray inRecActions of CMPI_uint32", strCMPIStatus (rc)); raOne.uint32 = 32; rc = CMSetArrayElementAt(inRecActions, 0, &raOne, CMPI_uint32); PROV_LOG ("++++ (%s) CMSetArrayElementAt [0]", strCMPIStatus (rc)); PROV_LOG ("Calling CMSetRecommendedActions with input array of CMPI_uint32"); rc = CMSetRecommendedActions(cmpiError, inRecActions); PROV_LOG ("++++ (%s) CMSetRecommendedActions", strCMPIStatus (rc)); inRecActions->hdl = NULL; PROV_LOG ("Calling CMSetRecommendedActions with input array" " with NULL handle"); rc = CMSetRecommendedActions(cmpiError, inRecActions); PROV_LOG ("++++ (%s) CMSetRecommendedActions", strCMPIStatus (rc)); /* Cases when CMPIError object handle is NULL*/ cmpiError->hdl = NULL; PROV_LOG ("Clone the CMPIError with NULL handle."); cmpiErrorClone = CMClone(cmpiError, &rc); if (cmpiErrorClone == NULL) { PROV_LOG ("++++ (%s) CMClone", strCMPIStatus (rc)); } PROV_LOG ("Calling CMGetErrorType with NULL handle"); outErrType = CMGetErrorType(cmpiError, &rc); if (!outErrType) { PROV_LOG ("++++ (%s) CMGetErrorType (%d)", strCMPIStatus (rc), outErrType); } PROV_LOG ("Calling CMGetOtherErrorType with NULL handle"); outOtherErrType = CMGetOtherErrorType(cmpiError, &rc); if (outOtherErrType == NULL) { PROV_LOG ("++++ (%s) CMGetOtherErrorType ", strCMPIStatus (rc)); } PROV_LOG ("Calling CMGetOwningEntity with NULL handle"); outOwningEntity = CMGetOwningEntity(cmpiError, &rc); if (outOwningEntity == NULL) { PROV_LOG ("++++ (%s) CMGetOwningEntity ", strCMPIStatus (rc)); } PROV_LOG ("Calling CMGetMessageID with NULL handle"); outMsgID = CMGetMessageID(cmpiError, &rc); if (!outMsgID) { PROV_LOG ("++++ (%s) CMGetMessageID", strCMPIStatus (rc)); } PROV_LOG ("Calling CMGetErrorMessage with NULL handle"); outMsg = CMGetErrorMessage(cmpiError, &rc); if (!outMsg) { PROV_LOG ("++++ (%s) CMGetErrorMessage", strCMPIStatus (rc)); } PROV_LOG ("Calling CMGetPerceivedSeverity with NULL handle"); outSev = CMGetPerceivedSeverity(cmpiError, &rc); if (!outSev) { PROV_LOG ("++++ (%s) CMGetPerceivedSeverity (%d)", strCMPIStatus (rc), outSev); } PROV_LOG ("Calling CMGetProbableCause with NULL handle"); outPc = CMGetProbableCause(cmpiError, &rc); if (!outPc) { PROV_LOG ("++++ (%s) CMGetProbableCause (%d)", strCMPIStatus (rc), outPc); } PROV_LOG ("Calling CMGetProbableCauseDescription with NULL handle"); outPcd = CMGetProbableCauseDescription(cmpiError, &rc); if (!outPcd) { PROV_LOG ("++++ (%s) CMGetProbableCauseDescription ", strCMPIStatus (rc)); } PROV_LOG ("Calling CMGetRecommendedActions with NULL handle"); outRecActions = CMGetRecommendedActions(cmpiError, &rc); if (!outRecActions) { PROV_LOG ("++++ (%s) CMGetRecommendedActions", strCMPIStatus (rc)); } PROV_LOG ("Calling CMGetErrorSource with NULL handle"); outErrSource = CMGetErrorSource(cmpiError, &rc); if (!outErrSource) { PROV_LOG ("++++ (%s) CMGetErrorSource", strCMPIStatus (rc)); } PROV_LOG ("Calling CMGetErrorSourceFormat with NULL handle"); outErrSourceFormat = CMGetErrorSourceFormat(cmpiError, &rc); if (!outErrSourceFormat) { PROV_LOG ("++++ (%s) CMGetErrorSourceFormat (%d)", strCMPIStatus (rc), outErrSourceFormat); } PROV_LOG ("Calling CMGetOtherErrorSourceFormat with NULL handle"); outOtherErrSourceFormat = CMGetOtherErrorSourceFormat(cmpiError, &rc); if (!outOtherErrSourceFormat) { PROV_LOG ("++++ (%s) CMGetOtherErrorSourceFormat", strCMPIStatus (rc)); } PROV_LOG ("Calling CMGetCIMStatusCode with NULL handle"); outCIMStatusCode = CMGetCIMStatusCode(cmpiError, &rc); if (!outCIMStatusCode) { PROV_LOG ("++++ (%s) CMGetCIMStatusCode (%d)", strCMPIStatus (rc), outCIMStatusCode); } PROV_LOG ("Calling CMGetCIMStatusCodeDescription with NULL handle"); outCIMStatusCodeDesc = CMGetCIMStatusCodeDescription(cmpiError, &rc); if (!outCIMStatusCodeDesc) { PROV_LOG ("++++ (%s) CMGetCIMStatusCodeDescription", strCMPIStatus (rc)); } PROV_LOG ("Calling CMGetMessageArguments with NULL handle"); outMsgArgs = CMGetMessageArguments(cmpiError, &rc); if (!outMsgArgs) { PROV_LOG ("++++ (%s) CMGetMessageArguments", strCMPIStatus (rc)); } PROV_LOG ("Calling CMSetErrorType with NULL handle"); rc = CMSetErrorType(cmpiError, inErrType); PROV_LOG ("++++ (%s) CMSetErrorType", strCMPIStatus (rc)); PROV_LOG ("Calling CMSetOtherErrorType with NULL handle"); rc = CMSetOtherErrorType(cmpiError, inOtherErrType); PROV_LOG ("++++ (%s) CMSetOtherErrorType", strCMPIStatus (rc)); PROV_LOG ("Calling CMSetProbableCauseDescription with NULL handle"); rc = CMSetProbableCauseDescription(cmpiError, inPcd); PROV_LOG ("++++ (%s) CMSetProbableCauseDescription", strCMPIStatus (rc)); PROV_LOG ("Calling CMSetRecommendedActions with NULL handle"); rc = CMSetRecommendedActions(cmpiError, inRecActions); PROV_LOG ("++++ (%s) CMSetRecommendedActions", strCMPIStatus (rc)); PROV_LOG ("Calling CMSetErrorSource with NULL handle"); rc = CMSetErrorSource(cmpiError, inErrSource); PROV_LOG ("++++ (%s) CMSetErrorSource", strCMPIStatus (rc)); PROV_LOG ("Calling CMSetErrorSourceFormat with NULL handle"); rc = CMSetErrorSourceFormat(cmpiError, inErrSourceFormat); PROV_LOG ("++++ (%s) CMSetErrorSourceFormat", strCMPIStatus (rc)); PROV_LOG ("Calling CMSetOtherErrorSourceFormat with NULL handle"); rc = CMSetOtherErrorSourceFormat(cmpiError, inOtherErrSourceFormat); PROV_LOG ("++++ (%s) CMSetOtherErrorSourceFormat", strCMPIStatus (rc)); PROV_LOG ("Calling CMSetCIMStatusCodeDescription with NULL handle"); rc = CMSetCIMStatusCodeDescription(cmpiError, inCIMStatusCodeDesc); PROV_LOG ("++++ (%s) CMSetCIMStatusCodeDescription", strCMPIStatus (rc)); PROV_LOG ("Calling CMSetMessageArguments with NULL handle"); rc = CMSetMessageArguments(cmpiError, inMsgArgs); PROV_LOG ("++++ (%s) CMSetMessageArguments", strCMPIStatus (rc)); PROV_LOG_CLOSE(); // Test case to increase coverage in CMPI_Broker.cpp objPath = CMNewObjectPath (_broker, "test/TestProvider", "TestCMPI_Method", &rc); retData = CBInvokeMethod(_broker, ctx, objPath, "testReturn", in, out, &rc); PROV_LOG_OPEN (_ClassName, _ProviderLocation); if(retData.value.uint32 == 2 && rc.rc == CMPI_RC_OK) { PROV_LOG ("++++ (%s) CMInvokeMethod", strCMPIStatus (rc)); } PROV_LOG ("--- %s CMPI InvokeMethod() exited with CMPI_RC_ERR_FAILED", _ClassName); PROV_LOG_CLOSE(); CMReturnWithString(inCIMStatusCode, CMNewString(_broker, "TestError invokeMethod() expected failure", NULL)); }
CMPIStatus TestCMPIAssociationProviderReferenceNames( CMPIAssociationMI * mi, const CMPIContext * ctx, const CMPIResult * rslt, const CMPIObjectPath * ref, const char* resultClass, const char* role) { CMPIInstance * ci = NULL; CMPIObjectPath * op = NULL; CMPIObjectPath * rop = NULL; CMPIObjectPath * cop = NULL; CMPIEnumeration * en = NULL; CMPIData data ; const char * targetName = NULL; const char * _thisClassName; const char * _RefLeftClass = NULL; const char * _RefRightClass = NULL; CMPIStatus rc = {CMPI_RC_OK, NULL}; _thisClassName=_ClassName; PROV_LOG_OPEN (_thisClassName, _ProviderLocation); PROV_LOG ("\n\n********************* %s CMPI ReferenceNames() called", _thisClassName); /* get object path of the target class */ op = get_assoc_targetClass_ObjectPath( _broker, ref, _RefLeftClass, _RefRightClass, &rc); PROV_LOG (" New Object Path [%s]", CMGetCharsPtr (CMGetNameSpace (ref, &rc),NULL)); /* create new object path of association */ rop = CMNewObjectPath( _broker, CMGetCharsPtr(CMGetNameSpace(ref,&rc),NULL), _thisClassName, &rc ); /* upcall to CIMOM; call enumInstanceNames() of the target class */ en = CBEnumInstanceNames( _broker, ctx, op, &rc); /* as long as object path entries are found in the enumeration */ while( CMHasNext( en, &rc) ) { /* get the object path */ data = CMGetNext( en, &rc); /* create new instance of the association */ ci = CMNewInstance( _broker, rop, &rc); /* get name of the target class */ targetName = get_assoc_targetClass_Name( _broker, ref, _RefLeftClass, _RefRightClass, &rc); /* set the properties of the association instance depending on the * constellation of the source class (parameter ref) and the target * class (see targetName) */ if(strcmp (targetName, "CMPI_TEST_Person")== 0) { CMSetProperty( ci, "model", (CMPIValue*)&(data.value.ref), CMPI_ref ); CMSetProperty( ci, "driver", (CMPIValue*)&(ref), CMPI_ref ); } else if( strcmp( targetName,"CMPI_TEST_Vehicle") == 0 ) { CMSetProperty( ci, "model", (CMPIValue*)&(data.value.ref), CMPI_ref ); CMSetProperty( ci, "driver", (CMPIValue*)&(ref), CMPI_ref ); } /* get object path of association instance */ cop = CMGetObjectPath(ci,&rc); /* set namespace in object path of association */ CMSetNameSpace(cop,CMGetCharsPtr(CMGetNameSpace(ref,&rc),NULL)); /* and return the association object path as result of the * referenceNames() call */ CMReturnObjectPath( rslt, cop ); } PROV_LOG ("\n\n********************* %s CMPI ReferenceNames() exited", _thisClassName); PROV_LOG_CLOSE (); return rc; }