CMPIStatus TestMethodProviderInvokeMethod(CMPIMethodMI * mi, const CMPIContext *ctx, const CMPIResult *rslt, const CMPIObjectPath * ref, const char *methodName, const CMPIArgs * in, CMPIArgs * out) { CMPIStatus rc = { CMPI_RC_OK, NULL }; CMPIString *className; CMPIData data; char result[80] = "Hello,"; const char *strCat; const char *name; char *argName = "Message"; CMPIString *str1; CMPIString *str2; CMPIValue val1, val2; /* * get the class name from object-path */ className = CMGetClassName(ref, &rc); /* * get a pointer to a C char* representation of this String. */ name = CMGetCharsPtr(className, &rc); if (!strcmp(name, _ClassName)) { if (!strcmp("SayHello", methodName)) { /* * gets the number of arguments contained in "in" Args. */ if (CMGetArgCount(in, &rc) > 0) { /* * gets a Name argument value */ data = CMGetArg(in, "Name", &rc); /* * check for data type and not null value of argument value * recieved */ if (data.type == CMPI_string && !(CMIsNullValue(data))) { strCat = CMGetCharsPtr(data.value.string, &rc); strcat(result, strCat); // strcat(result, "!"); /* * create the new string to return to client */ str1 = CMNewString(_broker, result, &rc); val1.string = str1; } } else { str1 = CMNewString(_broker, result, &rc); val1.string = str1; } /* * create string to add to an array */ str2 = CMNewString(_broker, "Have a good day", &rc); val2.string = str2; /* * Adds a value of str2 string to out array argument */ rc = CMAddArg(out, argName, &val2, CMPI_string); /* * For: 3048960 method array types not filled in Test provider. */ } else if (!strcmp("CheckArrayNoType", methodName)) { data = CMGetArg(in, "IntArray", &rc); CMPIType atype=data.value.array->ft->getSimpleType(data.value.array,&rc); sprintf(result,"Datatype is %s",paramType(atype)); str1 = CMNewString(_broker, result, &rc); val1.string = str1; /* * This method simulates various provider problems for testing. */ } else if (!strcmp("Misbehave", methodName)) { data = CMGetArg(in, "Action", &rc); const char *strval = NULL; if (data.type == CMPI_string && !(CMIsNullValue(data))) { strval = CMGetCharsPtr(data.value.string, &rc); sprintf(result, "data type is %s, value = %s", paramType(data.type), strval); if (!strcmp(strval,"hang")) { while(sleep(60)); /* to test req handler timeout, etc. */ } else if (!strcmp(strval,"abort")) { abort(); } else if (!strcmp(strval,"fpe")) { #pragma GCC diagnostic ignored "-Wdiv-by-zero" fprintf(stderr,"ouch! %d\n",1/0); #pragma GCC diagnostic warning "-Wdiv-by-zero" } else if (!strcmp(strval,"segfault")) { void (*crashme)(void) = NULL; crashme(); } /* * These tend to behave as if the condition were raised internally */ else if (!strcmp(strval,"sigabrt")) { kill(getpid(), SIGABRT); while(sleep(3)); /* slight pause to ensure we catch signal */ } else if (!strcmp(strval,"sigfpe")) { kill(getpid(), SIGFPE); while(sleep(3)); } else if (!strcmp(strval,"sigsegv")) { kill(getpid(), SIGSEGV); while(sleep(3)); } else if (!strcmp(strval,"sigusr1")) { kill(getpid(), SIGUSR1); /* as if we received a signal from stopBroker() */ while(sleep(3)); } else if (!strcmp(strval,"sigkill")) { kill(getpid(), SIGKILL); /* this is currently not handled by providerDrv*/ while(sleep(3)); } else { sprintf(result, "Action not recognized: %s", strval); fprintf(stderr, "+++ cmpiTestMethodProvider: Action not recognized \"%s\"\n", strval); } /* * create the new string to return to client */ str1 = CMNewString(_broker, result, &rc); val1.string = str1; } } else { sprintf(result, "Unknown method name: %s", methodName); fprintf(stderr, "+++ cmpiTestMethodProvider: Unknown method name \"%s\"\n", methodName); str1 = CMNewString(_broker, result, &rc); val1.string = str1; } } CMReturnData(rslt, (CMPIValue *) & val1, CMPI_string); CMReturnDone(rslt); return rc; }
CMPIStatus TestInstanceProviderExecQuery ( CMPIInstanceMI * mi, const CMPIContext * ctx, const CMPIResult * rslt, const CMPIObjectPath * referencePath, const char *query, const char *lang) { CMPIStatus rc = { CMPI_RC_OK, NULL }; CMPIStatus rc_Eval = { CMPI_RC_OK, NULL }; CMPIStatus rc_Clone = { CMPI_RC_OK, NULL }; CMPIStatus rc_Array = { CMPI_RC_OK, NULL }; CMPISelectExp *se_def = NULL; CMPICount cnt = 0; CMPIArray *projection = NULL; unsigned int j = 0; CMPIBoolean evalRes; CMPIData arr_data; CMPIInstance *instance1; CMPIObjectPath *cop1; CMPIData data; CMPIValue value1; const char* prop_name; CMPIData retProp; /*create the select expression */ se_def = CMNewSelectExp (_broker, query, lang, &projection, &rc_Clone); if (se_def) { /*loop over instances in array to evaluate for requested properties */ for (j = 0; j < numOfInst ; j++) { /*check for validity of Instance,that its not deleted */ if(valid[j] == 1) { /*get the element from array */ arr_data = CMGetArrayElementAt( clone_arr_ptr, j, &rc); /*Evaluate the instance using this select expression */ evalRes = CMEvaluateSelExp(se_def,arr_data.value.inst, &rc_Eval); if (evalRes) { /*check if any of properties are requested */ if (projection) { /*get number of properties requested */ cnt = CMGetArrayCount (projection, &rc_Array); /*if count is not equal to number of properties of instance */ if(cnt == 1) { /*check for the properties, requested */ data = CMGetArrayElementAt( projection, 0, &rc_Array); prop_name = CMGetCharsPtr ( data.value.string, &rc); /*create the new instance that has to be returned */ cop1 = CMNewObjectPath( _broker, "root/cimv2", _ClassName, &rc); instance1 = CMNewInstance(_broker, cop1, &rc); /*if property name is "Identifier", gets its value from instance */ if(!strcmp(prop_name, "Identifier")) { retProp = CMGetProperty( arr_data.value.inst, "Identifier", &rc); value1.uint8 = retProp.value.uint8; CMSetProperty( instance1, "Identifier", (CMPIValue *)&value1, CMPI_uint8); } /*if property name is "Message", gets its value from instance */ if(!strcmp(prop_name, "Message")) { retProp = CMGetProperty( arr_data.value.inst, "Message", &rc); value1.string = retProp.value.string; CMSetProperty( instance1, "Message", (CMPIValue *)&value1, CMPI_string); } /*if the query is evaluated return instance */ CMReturnInstance (rslt, instance1); } } else { CMReturnInstance(rslt, arr_data.value.inst); } } } } } CMReturnDone (rslt); CMReturn (CMPI_RC_OK); }
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; }
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)); }
static int _testCMPIInstance() { CMPIStatus rc = { CMPI_RC_OK, NULL }; CMPIInstance *instance = NULL; CMPIInstance *clonedInstance = NULL; CMPIObjectPath *objPath = NULL; CMPIObjectPath *newObjPath = NULL; CMPIObjectPath *returnedObjPath = NULL; CMPIData returnedData1; CMPIData returnedData2; CMPIData clonedData1; CMPIString *returnedName = NULL; unsigned int count = 0; const char *name1 = "firstPropertyName"; CMPIValue value1; const char *name2 = "secondPropertyName"; CMPIValue value2; CMPIType type = CMPI_uint64; CMPIBoolean dataEqual = 0; CMPIBoolean objectPathEqual = 0; CMPIBoolean cloneSuccessful = 0; CMPIString *beforeObjPath = NULL; CMPIString *afterObjPath = NULL; const char *beforeString = NULL; const char *afterString = NULL; objPath = make_ObjectPath(_broker, _Namespace, _ClassName); instance = make_Instance(objPath); value1.uint32 = 10; rc = CMSetProperty(instance, name1, &value1, type); value2.uint32 = 20; rc = CMSetProperty(instance, name2, &value2, type); count = CMGetPropertyCount(instance, &rc); returnedData1 = CMGetProperty(instance, name1, &rc); if (returnedData1.value.uint32 == 10) { dataEqual = 1; } returnedData2 = CMGetPropertyAt(instance, 2, &returnedName, &rc); if (returnedData2.value.uint32 == 20) { dataEqual = 1; } newObjPath = make_ObjectPath(_broker, _Namespace, _ClassName); returnedObjPath = CMGetObjectPath(instance, &rc); beforeObjPath = CMObjectPathToString(returnedObjPath, &rc); beforeString = CMGetCharsPtr(beforeObjPath, &rc); rc = CMSetNameSpace(newObjPath, "newNamespace"); rc = CMSetObjectPath(instance, newObjPath); returnedObjPath = CMGetObjectPath(instance, &rc); afterObjPath = CMObjectPathToString(returnedObjPath, &rc); afterString = CMGetCharsPtr(afterObjPath, &rc); afterString = CMGetCharsPtr(CMGetNameSpace(returnedObjPath, &rc), &rc); if (strcmp("newNamespace", afterString) == 0) { objectPathEqual = 1; } clonedInstance = instance->ft->clone(instance, &rc); clonedData1 = CMGetProperty(clonedInstance, name1, &rc); rc = clonedInstance->ft->release(clonedInstance); if (returnedData1.value.uint32 == clonedData1.value.uint32) { cloneSuccessful = 1; } else { cloneSuccessful = 0; } CMGetProperty(instance, "noProperty", &rc); if (rc.rc != CMPI_RC_ERR_NO_SUCH_PROPERTY) { return 1; } CMGetPropertyAt(instance, 100, &returnedName, &rc); if (rc.rc != CMPI_RC_ERR_NO_SUCH_PROPERTY) { return 1; } rc = instance->ft->release(instance); return 0; }
static int _testCMPIObjectPath() { CMPIStatus rc = { CMPI_RC_OK, NULL }; CMPIObjectPath *objPath = NULL; CMPIObjectPath *clonedObjPath = NULL; CMPIObjectPath *otherObjPath = NULL; CMPIObjectPath *fakeObjPath = NULL; const char *hostName = "HOSTNAME"; const char *nameSpace = "root/dummy"; const char *className = "classname"; CMPIString *returnedHostname = NULL; CMPIBoolean equalHostname = 0; CMPIString *returnedNamespace = NULL; CMPIBoolean equalNamespace = 0; CMPIString *returnedClassName; CMPIBoolean equalClassName = 0; CMPIString *returnedObjectPath; CMPIBoolean cloneSuccessful = 0; CMPIBoolean getKeySuccessful = 0; CMPIBoolean getKeyCountSuccessful = 0; CMPIBoolean getKeyAtSuccessful = 0; const char *objectPath1 = NULL; const char *objectPath2 = NULL; CMPIData data; CMPIValue value; unsigned int keyCount = 0; objPath = make_ObjectPath(_broker, _Namespace, _ClassName); rc = CMSetHostname(objPath, hostName); returnedHostname = CMGetHostname(objPath, &rc); if (strcmp(hostName, CMGetCharsPtr(returnedHostname, &rc)) == 0) { equalHostname = 1; } rc = CMSetNameSpace(objPath, nameSpace); returnedNamespace = CMGetNameSpace(objPath, &rc); if (strcmp(nameSpace, CMGetCharsPtr(returnedNamespace, &rc)) == 0) { equalNamespace = 1; } rc = CMSetClassName(objPath, className); returnedClassName = CMGetClassName(objPath, &rc); if (strcmp(className, CMGetCharsPtr(returnedClassName, &rc)) == 0) { equalClassName = 1; } otherObjPath = make_ObjectPath(_broker, _Namespace, _ClassName); returnedNamespace = CMGetNameSpace(otherObjPath, &rc); rc = CMSetNameSpaceFromObjectPath(otherObjPath, objPath); returnedNamespace = CMGetNameSpace(otherObjPath, &rc); if (strcmp(nameSpace, CMGetCharsPtr(returnedNamespace, &rc)) == 0) { equalNamespace = 1; } returnedHostname = CMGetHostname(otherObjPath, &rc); rc = CMSetHostAndNameSpaceFromObjectPath(otherObjPath, objPath); returnedHostname = CMGetHostname(otherObjPath, &rc); if (strcmp(hostName, CMGetCharsPtr(returnedHostname, &rc)) == 0) { equalHostname = 1; } returnedObjectPath = CMObjectPathToString(objPath, &rc); objectPath1 = CMGetCharsPtr(returnedObjectPath, &rc); clonedObjPath = objPath->ft->clone(objPath, &rc); returnedObjectPath = CMObjectPathToString(clonedObjPath, &rc); rc = clonedObjPath->ft->release(clonedObjPath); objectPath2 = CMGetCharsPtr(returnedObjectPath, &rc); if (strcmp(objectPath1, objectPath2) == 0) { cloneSuccessful = 1; } else { cloneSuccessful = 0; } fakeObjPath = CMNewObjectPath(_broker, "root#cimv2", "Sample_Instance", &rc); rc = CMAddKey(fakeObjPath, "ElementName", (CMPIValue *) "Fake", CMPI_chars); rc = CMAddKey(otherObjPath, "ElementName1", (CMPIValue *) "otherObjPath", CMPI_chars); data = CMGetKey(fakeObjPath, "ElementName", &rc); if (strcmp(CMGetCharsPtr(data.value.string, &rc), "Fake") == 0) { getKeySuccessful = 1; } keyCount = CMGetKeyCount(fakeObjPath, &rc); if (keyCount == 1) { getKeyCountSuccessful = 1; } data = CMGetKeyAt(fakeObjPath, 0, NULL, &rc); if (rc.rc == 0) { getKeyAtSuccessful = 1; } value.uint16 = 67; rc = CMAddKey(fakeObjPath, "Numeric_key_unsigned", (CMPIValue *) & value, CMPI_uint16); data = CMGetKey(fakeObjPath, "Numeric_key_unsigned", &rc); value.sint16 = -67; rc = CMAddKey(fakeObjPath, "Numeric_key_signed", (CMPIValue *) & value, CMPI_sint16); data = CMGetKey(fakeObjPath, "Numeric_key_signed", &rc); value.boolean = 1; rc = CMAddKey(fakeObjPath, "Boolean_key", (CMPIValue *) & value, CMPI_boolean); data = CMGetKey(fakeObjPath, "Boolean_key", &rc); CMGetKeyAt(objPath, 500, NULL, &rc); if (rc.rc != CMPI_RC_ERR_NO_SUCH_PROPERTY) { return 1; } rc = objPath->ft->release(objPath); rc = fakeObjPath->ft->release(fakeObjPath); return 0; }
static int _testCMPIDateTime() { CMPIStatus rc = { CMPI_RC_OK, NULL }; CMPIBoolean isInterval = 0; CMPIBoolean interval = 0; CMPIBoolean cloneSuccessful = 0; CMPIBoolean binaryDateTimeEqual = 0; CMPIDateTime *dateTime = NULL; CMPIDateTime *new_dateTime = NULL; CMPIDateTime *clonedDateTime = NULL; CMPIDateTime *dateTimeFromBinary = NULL; CMPIUint64 dateTimeInBinary = UINT64_LITERAL(1150892800000000); CMPIUint64 returnedDateTimeInBinary = 0; CMPIString *stringDate = NULL; CMPIString *clonedStringDate = NULL; const char *normalString = NULL; const char *clonedString = NULL; void *dtptr; dateTime = CMNewDateTime(_broker, &rc); if (dateTime == NULL) { return 1; } dateTimeFromBinary = CMNewDateTimeFromBinary(_broker, dateTimeInBinary, interval, &rc); returnedDateTimeInBinary = CMGetBinaryFormat(dateTimeFromBinary, &rc); if (dateTimeInBinary == returnedDateTimeInBinary) { binaryDateTimeEqual = 1; } isInterval = CMIsInterval(dateTime, &rc); interval = 1; new_dateTime = CMNewDateTimeFromBinary(_broker, dateTimeInBinary, interval, &rc); isInterval = CMIsInterval(new_dateTime, &rc); clonedDateTime = dateTime->ft->clone(dateTime, &rc); stringDate = CMGetStringFormat(dateTime, &rc); clonedStringDate = CMGetStringFormat(clonedDateTime, &rc); rc = clonedDateTime->ft->release(clonedDateTime); normalString = CMGetCharsPtr(stringDate, &rc); clonedString = CMGetCharsPtr(clonedStringDate, &rc); if (strcmp(normalString, clonedString) == 0) { cloneSuccessful = 1; } dtptr = dateTime->hdl; dateTime->hdl = NULL; CMGetBinaryFormat(dateTime, &rc); if (rc.rc != CMPI_RC_ERR_INVALID_HANDLE) { return 1; } dateTime->ft->clone(dateTime, &rc); if (rc.rc != CMPI_RC_ERR_INVALID_HANDLE) { return 1; } CMGetStringFormat(dateTime, &rc); if (rc.rc != CMPI_RC_ERR_INVALID_HANDLE) { return 1; } rc = dateTime->ft->release(dateTime); if (rc.rc != CMPI_RC_ERR_INVALID_HANDLE) { return 1; } dateTime->hdl = dtptr; rc = dateTime->ft->release(dateTime); return 0; }
static int _testSimpleTypes() { CMPIArgs *args_ptr = NULL; CMPIStatus rc = { CMPI_RC_OK, NULL }; CMPIStatus rc1 = { CMPI_RC_OK, NULL }; int i, flag, size; CMPIValue value; CMPIValue value1; CMPIData data; CMPIData dataInst; CMPIData retDataInst; CMPIString *retNamespace = NULL; CMPIString *retClassname = NULL; CMPIObjectPath *objPath = make_ObjectPath(_broker, _Namespace, _ClassName); const char *str1; const char *str2; struct array_types { CMPIType element_type; char *typeName; char *args_name; } types_arr[] = { { CMPI_instance, "CMPI_instance", "CMPI_instance"}, { CMPI_ref, "CMPI_ref", "CMPI_ref"}}; size = 2; flag = 1; for (i = 0; i < size; i++) { args_ptr = CMNewArgs(_broker, &rc); switch (types_arr[i].element_type) { case CMPI_ref: value.ref = CMNewObjectPath(_broker, "root/cimv2", "Sample_Instance", &rc); break; case CMPI_instance: value.inst = make_Instance(objPath); value1.uint32 = 20; rc = CMSetProperty(value.inst, "Property1", &value1, CMPI_uint32); break; } rc = CMAddArg(args_ptr, types_arr[i].args_name, (CMPIValue *) & value, types_arr[i].element_type); data = CMGetArg(args_ptr, types_arr[i].args_name, &rc); switch (types_arr[i].element_type) { case CMPI_ref: retNamespace = CMGetNameSpace(data.value.ref, &rc); retClassname = CMGetClassName(data.value.ref, &rc1); if ((rc.rc == CMPI_RC_OK) && (rc1.rc == CMPI_RC_OK)) { str1 = CMGetCharsPtr(retNamespace, &rc); str2 = CMGetCharsPtr(retClassname, &rc1); if ((rc.rc == CMPI_RC_OK) && (rc1.rc == CMPI_RC_OK)) { if ((strcmp(str1, "root/cimv2")) || (strcmp(str2, "Sample_Instance"))) { flag = 0; } } else { flag = 0; } } else { flag = 0; } rc = CMRelease(value.ref); break; case CMPI_instance: retDataInst = CMGetProperty(data.value.inst, "Property1", &rc); dataInst = CMGetProperty(value.inst, "Property1", &rc); if (retDataInst.value.uint32 != dataInst.value.uint32) { flag = 0; } rc = CMRelease(value.inst); break; } if (data.type == types_arr[i].element_type && flag) { } rc = CMRelease(args_ptr); } return flag; }
static int _testArrayTypes() { struct array_types { CMPIType element_type; CMPIType typeA; char *typeName; char *typeAName; char *args_name; } types_arr[] = { { CMPI_uint32, CMPI_uint32A, "CMPI_uint32", "CMPI_uint32A", "CMPI_uint32_array"}, { CMPI_uint16, CMPI_uint16A, "CMPI_uint16", "CMPI_uint16A", "CMPI_uint16_array"}, { CMPI_uint8, CMPI_uint8A, "CMPI_uint8", "CMPI_uint8A", "CMPI_uint8_array"}, { CMPI_uint64, CMPI_uint64A, "CMPI_uint64", "CMPI_uint64A", "CMPI_uint64_array"}, { CMPI_sint32, CMPI_sint32A, "CMPI_sint32", "CMPI_sint32A", "CMPI_sint32_array"}, { CMPI_sint16, CMPI_sint16A, "CMPI_sint16", "CMPI_sint16A", "CMPI_sint16_array"}, { CMPI_sint8, CMPI_sint8A, "CMPI_sint8", "CMPI_sint8A", "CMPI_sint8_array"}, { CMPI_sint64, CMPI_sint64A, "CMPI_sint64", "CMPI_sint64A", "CMPI_sint64_array"}, { CMPI_real32, CMPI_real32A, "CMPI_real32", "CMPI_real32A", "CMPI_real32_array"}, { CMPI_real64, CMPI_real64A, "CMPI_real64", "CMPI_real64A", "CMPI_real64_array"}, { CMPI_char16, CMPI_char16A, "CMPI_char16", "CMPI_char16A", "CMPI_char16_array"}, { CMPI_boolean, CMPI_booleanA, "CMPI_boolean", "CMPI_booleanA", "CMPI_boolean_array"}, { CMPI_string, CMPI_stringA, "CMPI_string", "CMPI_stringA", "CMPI_string_array"}, { CMPI_dateTime, CMPI_dateTimeA, "CMPI_dateTime", "CMPI_dateTimeA", "CMPI_dateTime_array"}, { CMPI_ref, CMPI_refA, "CMPI_ref", "CMPI_refA", "CMPI_ref_array"}, { CMPI_instance, CMPI_instanceA, "CMPI_instance", "CMPI_instanceA", "CMPI_instance_array"}, { CMPI_null, CMPI_ARRAY, "Invalid", "InvalidArray", "Invalid_array"}}; int i, flag, size; CMPIStatus rc = { CMPI_RC_OK, NULL }; CMPIStatus rc1 = { CMPI_RC_OK, NULL }; CMPIArray *arr = NULL; CMPIString *retNamespace = NULL; CMPIString *retClassname = NULL; CMPIValue value, value1; CMPIData data; CMPIData arr_data; CMPIData dataInst; CMPIData retDataInst; CMPIArgs *args_ptr = NULL; CMPIObjectPath *objPath = make_ObjectPath(_broker, _Namespace, _ClassName); CMPIUint64 datetime1, datetime2; const char *str1; const char *str2; size = 17; for (i = 0; i < size; i++) { args_ptr = CMNewArgs(_broker, &rc); switch (types_arr[i].element_type) { case CMPI_uint32: value.uint32 = 56; break; case CMPI_uint16: value.uint16 = 32; break; case CMPI_uint8: value.uint8 = 56; break; case CMPI_uint64: value.uint64 = 32; break; case CMPI_sint32: value.sint32 = -56; break; case CMPI_sint16: value.sint16 = -32; break; case CMPI_sint8: value.sint8 = -56; break; case CMPI_sint64: value.sint64 = -32; break; case CMPI_real32: value.real32 = (CMPIReal32) -32.78; break; case CMPI_real64: value.real64 = -899.32; break; case CMPI_char16: value.char16 = 'k'; break; case CMPI_string: value.string = CMNewString(_broker, "string", &rc); break; case CMPI_boolean: value.boolean = 1; break; case CMPI_dateTime: value.dateTime = CMNewDateTime(_broker, &rc); break; case CMPI_ref: value.ref = CMNewObjectPath(_broker, "root/cimv2", "Sample_Instance", &rc); break; case CMPI_null: value.args = NULL; break; case CMPI_instance: value.inst = make_Instance(objPath); value1.uint32 = 20; rc = CMSetProperty(value.inst, "Property1", &value1, CMPI_uint32); break; } arr = NULL; rc = CMAddArg(args_ptr, "EmptyArray", (CMPIValue *) & arr, types_arr[i].typeA); arr = CMNewArray(_broker, 1, types_arr[i].element_type, &rc); rc = CMSetArrayElementAt(arr, 0, &value, types_arr[i].element_type); rc = CMAddArg(args_ptr, types_arr[i].args_name, (CMPIValue *) & arr, types_arr[i].typeA); flag = 1; if ((types_arr[i].element_type) != CMPI_null) { data = CMGetArg(args_ptr, types_arr[i].args_name, &rc); arr_data = CMGetArrayElementAt(data.value.array, 0, &rc); switch (types_arr[i].element_type) { case CMPI_uint32: if (arr_data.value.uint32 != value.uint32) { flag = 0; } break; case CMPI_uint16: if (arr_data.value.uint16 != value.uint16) { flag = 0; } break; case CMPI_uint8: if (arr_data.value.uint8 != value.uint8) { flag = 0; } break; case CMPI_uint64: if (arr_data.value.uint64 != value.uint64) { flag = 0; } break; case CMPI_sint32: if (arr_data.value.sint32 != value.sint32) { flag = 0; } break; case CMPI_sint16: if (arr_data.value.sint16 != value.sint16) { flag = 0; } break; case CMPI_sint8: if (arr_data.value.sint8 != value.sint8) { flag = 0; } break; case CMPI_sint64: if (arr_data.value.sint64 != value.sint64) { flag = 0; } break; case CMPI_real32: if (arr_data.value.real32 != value.real32) { flag = 0; } break; case CMPI_real64: if (arr_data.value.real64 != value.real64) { flag = 0; } break; case CMPI_char16: if (arr_data.value.char16 != value.char16) { flag = 0; } break; case CMPI_string: str1 = CMGetCharsPtr(arr_data.value.string, &rc); str2 = CMGetCharsPtr(value.string, &rc1); if ((rc.rc != CMPI_RC_OK) || (rc1.rc != CMPI_RC_OK) || strcmp(str1, str2)) { flag = 0; } break; case CMPI_boolean: if (arr_data.value.boolean != value.boolean) { flag = 0; } break; case CMPI_dateTime: datetime1 = CMGetBinaryFormat(arr_data.value.dateTime, &rc); datetime2 = CMGetBinaryFormat(value.dateTime, &rc1); if ((rc.rc != CMPI_RC_OK) || (rc1.rc != CMPI_RC_OK) || (datetime1 != datetime2)) { flag = 0; } rc = CMRelease(value.dateTime); break; case CMPI_ref: retNamespace = CMGetNameSpace(arr_data.value.ref, &rc); retClassname = CMGetClassName(arr_data.value.ref, &rc1); if ((rc.rc == CMPI_RC_OK) && (rc1.rc == CMPI_RC_OK)) { str1 = CMGetCharsPtr(retNamespace, &rc); str2 = CMGetCharsPtr(retClassname, &rc1); if ((rc.rc == CMPI_RC_OK) && (rc1.rc == CMPI_RC_OK)) { if ((strcmp(str1, "root/cimv2")) || (strcmp(str2, "TestCMPI_Instance"))) { flag = 0; } } else { flag = 0; } } else { flag = 0; } rc = CMRelease(value.ref); break; case CMPI_instance: retDataInst = CMGetProperty(arr_data.value.inst, "Property1", &rc); dataInst = CMGetProperty(value.inst, "Property1", &rc); if (retDataInst.value.uint32 != dataInst.value.uint32) { flag = 0; } rc = CMRelease(value.inst); break; } if (data.type == types_arr[i].typeA && flag) { } } rc = CMRelease(arr); rc = CMRelease(args_ptr); } return flag; }
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)); 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); } }