//***********************************************************
//
// SetIntegerPropOnObject()
//
// Set an integer property to the AAF object specified by pObj.
// The value of the property is specified in value.
//
// Returns:
//
// On Success: AAFRESULT_SUCCESS
// On Failure: An exception.
//
HRESULT AAFDomainUtils::SetIntegerPropOnObject(IAAFObject* pObj, aafUID_t* pClassID, aafUID_t* pPropID, const aafUID_t* pIntTypeID,
aafMemPtr_t pValue, aafUInt32 ValueSize, IAAFDictionary *dict)
{
AAFCheck hr;
// Create a property value from the supplied value (pValue)
IAAFTypeDef* pTD;
hr = dict->LookupTypeDef(*pIntTypeID, &pTD);
AutoRelease<IAAFTypeDef> r1( pTD );
IAAFTypeDefInt* pTDInt;
hr = pTD->QueryInterface(IID_IAAFTypeDefInt, (void**)&pTDInt);
AutoRelease<IAAFTypeDefInt> r2( pTDInt );
// Now create a property value object with that value.
IAAFPropertyValue* pPV;
hr = pTDInt->CreateValue(pValue, ValueSize, &pPV);
AutoRelease<IAAFPropertyValue> r3( pPV );
// Add the property to the target object.
// Get the class def for the object
IAAFClassDef* pCD;
hr = dict->LookupClassDef(*pClassID, &pCD);
AutoRelease<IAAFClassDef> r4( pCD );
IAAFPropertyDef* pPD;
hr = pCD->LookupPropertyDef(*pPropID, &pPD);
AutoRelease<IAAFPropertyDef> r5( pPD );
// Set the propeter value on the target object
hr = pObj->SetPropertyValue(pPD, pPV);
return AAFRESULT_SUCCESS;
}
static HRESULT TestPropertyValue (
testMode_t mode,
aafUID_constref fileKind,
testRawStorageType_t rawStorageType,
aafProductIdentification_constref productID)
{
// HRESULT hr = E_FAIL;
long hr = E_FAIL;
const size_t fileNameBufLen = 128;
aafWChar testFileName[ fileNameBufLen ] = L"";
GenerateTestFileName( productID.productName, fileKind, fileNameBufLen, testFileName );
IAAFFile* pFile = NULL;
if(mode == kAAFUnitTestReadWrite)
{
RemoveTestFile (testFileName);
checkResult (CreateTestFile( testFileName, fileKind, rawStorageType, productID, &pFile ));
assert (pFile);
}
else
{
checkResult (AAFFileOpenExistingRead(testFileName, 0, &pFile));
assert (pFile);
}
IAAFHeader * pHeader = NULL;
hr = pFile->GetHeader (&pHeader);
if (! SUCCEEDED (hr)) return hr;
assert (pHeader);
IAAFDictionary * pDict = NULL;
hr = pHeader->GetDictionary (&pDict);
if (! SUCCEEDED (hr)) return hr;
assert (pDict);
CAAFBuiltinDefs defs (pDict);
// Let's try to do something interesting with a type definition
IAAFTypeDefInt * pTypeDef = NULL;
hr = defs.tdInt32()->QueryInterface (IID_IAAFTypeDefInt, (void **) &pTypeDef);
if (! SUCCEEDED (hr)) return hr;
assert (pTypeDef);
if(mode == kAAFUnitTestReadWrite)
{
// Now attempt to create invalid property values; check for errors.
const aafInt32 forty_two = 42;
IAAFPropertyValue * pv = NULL;
// This is what a correct one would look like; we're not ready for that yet:
// hr = pTypeDef->CreateValue (&forty_two, 4, &pv);
// set this to -1 to see if it gets modified
pv = (IAAFPropertyValue *) (-1);
// Try null pVal
hr = pTypeDef->CreateValue (NULL, 4, &pv);
if (AAFRESULT_NULL_PARAM != hr)
return AAFRESULT_TEST_FAILED;
if ((IAAFPropertyValue *)(-1) != pv)
return AAFRESULT_TEST_FAILED;
// Try valSize too large
hr = pTypeDef->CreateValue ((aafMemPtr_t) &forty_two, 8, &pv);
if (AAFRESULT_BAD_SIZE != hr)
return AAFRESULT_TEST_FAILED;
if ((IAAFPropertyValue *)(-1) != pv)
return AAFRESULT_TEST_FAILED;
// Now try correct one
pv = NULL;
hr = pTypeDef->CreateValue ((aafMemPtr_t) &forty_two, 4, &pv);
if (! SUCCEEDED (hr)) return hr;
if (! pv)
return AAFRESULT_TEST_FAILED;
// That one worked; let's try one with a smaller init size (should
// also work)
pv->Release();
pv = NULL;
const aafInt16 fifty_seven = 57;
hr = pTypeDef->CreateValue ((aafMemPtr_t) &fifty_seven, 2, &pv);
if (! SUCCEEDED (hr)) return hr;
if (! pv)
return AAFRESULT_TEST_FAILED;
// cool. Now we should have a good property value whose value is 57.
// check GetType() for error condition
hr = pv->GetType (NULL);
if (AAFRESULT_NULL_PARAM != hr)
return AAFRESULT_TEST_FAILED;
// this GetType() call should work, and return the original type def.
IAAFTypeDef * propType = NULL;
hr = pv->GetType (&propType);
if (! SUCCEEDED (hr)) return hr;
if (! propType)
return AAFRESULT_TEST_FAILED;
// Convert both to IUnknown for comparison
IUnknown * pPropUnknown = NULL;
IUnknown * pTypeDefUnknown = NULL;
hr = propType->QueryInterface(IID_IUnknown, (void **)&pPropUnknown);
if (! SUCCEEDED (hr)) return hr;
assert (pPropUnknown);
hr = pTypeDef->QueryInterface(IID_IUnknown, (void **)&pTypeDefUnknown);
if (! SUCCEEDED (hr)) return hr;
assert (pTypeDefUnknown);
if (pPropUnknown != pTypeDefUnknown)
return AAFRESULT_TEST_FAILED;
// Test IsDefinedType ()
// (Currently only returns true.)
aafBool b = kAAFFalse;
hr = pv->IsDefinedType (&b);
if (! SUCCEEDED (hr)) return hr;
if (kAAFTrue != b)
return AAFRESULT_TEST_FAILED;
pTypeDefUnknown->Release();
pPropUnknown->Release();
pTypeDef->Release();
propType->Release();
pv->Release();
pDict->Release();
pHeader->Release();
hr = pFile->Save();
}
if (! SUCCEEDED (hr)) return hr;
hr = pFile->Close();
if (! SUCCEEDED (hr)) return hr;
pFile->Release();
return AAFRESULT_SUCCESS;
}
