// For Increasing the Coverage of CMPIInstance static int _testInstance () { CMPIStatus rc = { CMPI_RC_OK, NULL }; CMPIInstance* instance = NULL; CMPIObjectPath* objPath = NULL; CMPIObjectPath* objPathFake = NULL; CMPIValue value; CMPIType type = CMPI_uint64; CMPIData retData; CMPIData returnedData1; const char* property_name = "s"; const char* origin = "origin"; void* handle; int flag = 1; value.uint64 = PEGASUS_UINT64_LITERAL(5000000000); PROV_LOG("++++ _testInstance"); objPath = make_ObjectPath(_broker, _Namespace, "TestCMPI_Instance"); instance = make_Instance(objPath); /* Test cases to increase coverage in instSetPropertyWithOrigin function */ /* Setting n64 property in class TestCMPI_Instance. So origin has been set to TestCMPI_Instance.*/ rc = CMSetPropertyWithOrigin(instance, "n64", &value, type, "TestCMPI_Instance"); if ( rc.rc == CMPI_RC_OK ) { PROV_LOG("++++ SetPropertyWithOrigin for n64 property status : (%s)", strCMPIStatus(rc)); } /* CMGetProperty is called to verify the value of the property just being set. */ retData = CMGetProperty(instance, "n64", &rc); if (retData.type == CMPI_uint64 && retData.value.uint64 == PEGASUS_UINT64_LITERAL(5000000000)) { PROV_LOG("++++ CMGetProperty for n64 property status : (%s)," "value (%"PEGASUS_64BIT_CONVERSION_WIDTH"u)", strCMPIStatus(rc), retData.value.uint64); } /* Setting non-member property of type CMPI_ref*/ type= CMPI_ref; value.ref = objPath; rc = CMSetPropertyWithOrigin(instance, "objPath", &value, type, origin); if ( rc.rc == CMPI_RC_OK ) { PROV_LOG("++++ SetPropertyWithOrigin status : (%s)",strCMPIStatus(rc)); } /* Setting non-memeber property of type other than CMPI_ref*/ value.uint32 = 32; type = CMPI_uint32; rc = CMSetPropertyWithOrigin(instance, "n32", &value, type, NULL); if ( rc.rc == CMPI_RC_OK ) { PROV_LOG("++++ SetPropertyWithOrigin status : (%s)",strCMPIStatus(rc)); } /* Testing error path for instGetProperty with NULL property name*/ returnedData1 = CMGetProperty(instance, NULL, &rc); if (rc.rc == CMPI_RC_ERR_INVALID_PARAMETER ) { PROV_LOG("++++ CMGetProperty with NULL property name status: (%s) ", strCMPIStatus(rc)); } /*-----------------------------------------------------------------------*/ /* Test cases to cover error paths for instSetObjectPath and instSetPropertyFilter*/ /* Testing error path by passing CMPIObjectPath with class name different from the classname for CMPIInstance in CMSetObjectPath*/ objPathFake = CMNewObjectPath(_broker, _Namespace, "TestCMPIInstance_Method", NULL); rc = CMSetObjectPath(instance, objPathFake); if ( rc.rc == CMPI_RC_ERR_FAILED || rc.rc == CMPI_RC_ERR_NOT_SUPPORTED) { PROV_LOG("++++ Test for CMSetObjectPath with wrong input passed"); } /* Testing error path by passing NULL to instSetObjectPath*/ rc = CMSetObjectPath(instance, NULL); if ( rc.rc == CMPI_RC_ERR_INVALID_PARAMETER || rc.rc == CMPI_RC_ERR_NOT_SUPPORTED) { PROV_LOG("++++ Test for CMSetObjectPath with NULL input passed "); } /* Testing error paths by setting handle to CMPIInstance to NULL and using that in calls to instSetObjectPath and instSetPropertyFilter*/ handle = instance->hdl; instance->hdl = NULL ; rc = CMSetObjectPath(instance, NULL); if ( rc.rc == CMPI_RC_ERR_INVALID_HANDLE || rc.rc == CMPI_RC_ERR_NOT_SUPPORTED) { PROV_LOG("++++ CMSetObjectPath with NULL handle for" " CMPIInstance passed"); } PROV_LOG("++++ CMSetObjectPath : (%s) ",strCMPIStatus(rc)); rc = CMSetPropertyFilter(instance,&property_name,NULL); if( rc.rc == CMPI_RC_ERR_INVALID_HANDLE ) { PROV_LOG("++++ CMSetPropertyFilter with NULL handle for CMPIInstance" " status : (%s)", strCMPIStatus (rc)); } instance->hdl = handle; /*-----------------------------------------------------------------------*/ return flag; } // _testInstance end
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); } }
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; }