static void ChangeWeakReference(
IAAFFiller * pFiller,
IAAFTypeDef * pTargetType)
{
IAAFObjectSP pObject;
checkResult(pFiller->QueryInterface(IID_IAAFObject, (void **)&pObject));
IAAFClassDefSP pClassDef;
checkResult(pObject->GetDefinition(&pClassDef));
IAAFPropertyDefSP pWeakRefPropertyDef;
checkResult(pClassDef->LookupPropertyDef(kAAFPropID_TestWeakReferenceToType, &pWeakRefPropertyDef));
// Get weak reference value from the filler object.
IAAFPropertyValueSP pWeakReferenceValue;
checkResult(pObject->GetPropertyValue(pWeakRefPropertyDef, &pWeakReferenceValue));
// Make sure the value's type definition is in fact a weak reference.
IAAFTypeDefSP pPropertyType;
checkResult(pWeakReferenceValue->GetType(&pPropertyType));
IAAFTypeDefWeakObjRefSP pWeakReferenceType;
checkResult(pPropertyType->QueryInterface(IID_IAAFTypeDefWeakObjRef, (void **)&pWeakReferenceType));
// Create the weak reference property value.
IAAFTypeDefObjectRefSP pObjectReferenceType;
checkResult(pWeakReferenceType->QueryInterface(IID_IAAFTypeDefObjectRef, (void **)&pObjectReferenceType));
// Make sure the target of the weak reference is a type definition.
checkResult(pObjectReferenceType->SetObject(pWeakReferenceValue, pTargetType));
}
static void CheckWeakReference(
IAAFFiller * pFiller,
IAAFMob * pTargetMob)
{
IAAFObjectSP pObject;
checkResult(pFiller->QueryInterface(IID_IAAFObject, (void **)&pObject));
IAAFClassDefSP pClassDef;
checkResult(pObject->GetDefinition(&pClassDef));
IAAFPropertyDefSP pWeakRefPropertyDef;
checkResult(pClassDef->LookupPropertyDef(kAAFPropID_TestWeakReferenceToMob, &pWeakRefPropertyDef));
// Get weak reference value from the filler object.
IAAFPropertyValueSP pWeakReferenceValue;
checkResult(pObject->GetPropertyValue(pWeakRefPropertyDef, &pWeakReferenceValue));
// Make sure the value's type definition is in fact a weak reference.
IAAFTypeDefSP pPropertyType;
checkResult(pWeakReferenceValue->GetType(&pPropertyType));
IAAFTypeDefWeakObjRefSP pWeakReferenceType;
checkResult(pPropertyType->QueryInterface(IID_IAAFTypeDefWeakObjRef, (void **)&pWeakReferenceType));
// Create the weak reference property value.
IAAFTypeDefObjectRefSP pObjectReferenceType;
checkResult(pWeakReferenceType->QueryInterface(IID_IAAFTypeDefObjectRef, (void **)&pObjectReferenceType));
// Make sure the target of the weak reference is a type definition.
IAAFMobSP pFoundTargetMob;
checkResult(pObjectReferenceType->GetObject(pWeakReferenceValue, IID_IAAFMob, (IUnknown **)&pFoundTargetMob));
// Verify that the object that was the target of the weak reference was the
// type that we were expecting.
checkExpression(EqualObjects(pFoundTargetMob, pTargetMob), AAFRESULT_TEST_FAILED);
}
static void Test_EssenceStreamPullWrite(
IAAFFile *pFile,
CAAFBuiltinDefs & defs)
{
IAAFTypeDefSP pTypeDef;
IAAFTypeDefStream3SP pTypeDefStream3;
// Get the direct access interfaces.
IAAFObjectSP pObject;
IAAFPropertyDefSP pDataPropertyDef;
IAAFPropertyDefSP pSampleIndexPropertyDef;
IAAFPropertyValueSP pStreamPropertyValue;
IAAFStreamAccess *cb = 0;
IAAFEssenceDataSP pEssenceData;
IAAFHeaderSP pHeader;
IAAFDictionarySP pDictionary;
IAAFSourceMobSP pSourceMob;
IAAFMobSP pMob;
IAAFEssenceDescriptorSP pEssenceDesciptor;
CheckResult (pFile->GetHeader (&pHeader));
CheckResult (pHeader->GetDictionary (&pDictionary));
// Create an EssenceData object and associated Mob
Test_CreateEssenceData(defs, pHeader, sMobID[2], sMobName[2], &pEssenceData);
// Normally we'd add the essence data object here and, with it attached,
// write essence to it. Instead establish a call back so that the data
// may be written later during save.
CheckResult(pEssenceData->QueryInterface(IID_IAAFObject, (void **)&pObject));
Test_LookupEssenceDataStreamPropertyDefinitions(pDictionary,
&pDataPropertyDef,
&pSampleIndexPropertyDef);
CheckResult(pObject->GetPropertyValue(pDataPropertyDef,
&pStreamPropertyValue));
CheckResult(pStreamPropertyValue->GetType(&pTypeDef));
CheckResult(pTypeDef->QueryInterface(IID_IAAFTypeDefStream3,
(void **)&pTypeDefStream3));
CheckResult(TestStreamAccess::Create(&cb));
CheckResult(pTypeDefStream3->SetCallback(pStreamPropertyValue, cb,
reinterpret_cast<aafMemPtr_t>(const_cast<char *>(sSmiley))));
cb->Release();
}
static HRESULT verifyContents (IAAFHeader* const pHeader, IAAFDictionary* const pDict,
const aafBoolean_t bMinimalTesting)
{
//CAAFBuiltinDefs defs (pDict);
HRESULT hr;
/////////////////////////////////////////
// Check the MOb stuff
IAAFMobSP spMob;
checkResult(pHeader->LookupMob (TEST_MobID, &spMob));
aafNumSlots_t numSlots = 0;
checkResult(spMob->CountSlots (&numSlots));
// we only put one in
assert (1 == numSlots);
IEnumAAFMobSlotsSP spSlotEnum;
checkResult(spMob->GetSlots (&spSlotEnum));
// Since we only put one in, just bother with the first one.
IAAFMobSlotSP spMobSlot;
checkResult(spSlotEnum->NextOne (&spMobSlot));
aafCharacter buf[128] = {0};
checkResult(spMobSlot->GetName(buf, 128));
checkExpression( wcscmp(buf, TEST_SLOT_NAME) == 0, AAFRESULT_TEST_FAILED );
aafSlotID_t slotid = {0};
checkResult(spMobSlot->GetSlotID(&slotid));
checkExpression( slotid == TEST_SLOT_ID, AAFRESULT_TEST_FAILED );
// Get the segment; it's got to be our filler.
IAAFSegmentSP spSegment;
checkResult(spMobSlot->GetSegment (&spSegment));
// Get filler interface
IAAFFillerSP spFill;
checkResult(spSegment->QueryInterface(IID_IAAFFiller,
(void**)&spFill));
//Make sure Property is preset! Can't do anything without it
//handy - QI filler for Object intf.
IAAFObjectSP spObj;
checkResult(spFill->QueryInterface(IID_IAAFObject, (void**)&spObj));
//Get the property def for Component::FA
IAAFClassDefSP spCD_comp;
checkResult(pDict->LookupClassDef(AUID_AAFComponent, &spCD_comp));
//From Class Def, get the Property Def
IAAFPropertyDefSP spPD_comp;
checkResult(spCD_comp->LookupPropertyDef(TEST_PROP_ID, &spPD_comp));
//Verify that optional property is not yet present in object
aafBoolean_t bIsPresent = kAAFFalse;
checkResult(spObj->IsPropertyPresent(spPD_comp, &bIsPresent));
checkExpression(bIsPresent == kAAFTrue, AAFRESULT_TEST_FAILED);
//////////////////////////////////////
//get the value
IAAFPropertyValueSP spPropVal;
checkResult(spObj->GetPropertyValue(spPD_comp, &spPropVal));
//Get the Fixed Array typedef
//first, get the Type Def from the Property def
IAAFTypeDefSP spTypeDef;
checkResult(spPD_comp->GetTypeDef(&spTypeDef));
//now get the FA intf
IAAFTypeDefFixedArraySP spFA;
checkResult(spTypeDef->QueryInterface(IID_IAAFTypeDefFixedArray, (void**)&spFA));
//get the array out of it ...
TEST_ELEM_t check_fa [TEST_FA_COUNT] = {0}; //init a checking variable
//IAAFTypeDefFixedArray::GetCount()
aafUInt32 check_count = 0;
checkResult(spFA->GetCount(&check_count));
checkExpression( check_count == TEST_FA_COUNT, AAFRESULT_TEST_FAILED );
//IAAFTypeDefFixedArray::GetType()
IAAFTypeDefSP spTestType;
checkResult(spFA->GetType(&spTestType));
//Look up our elem Type def
IAAFTypeDefSP spTD_elem;
checkResult(pDict->LookupTypeDef (TEST_ELEM_TYPE_ID, &spTD_elem));
//!!! checkExpression( AreUnksSame(spTestType, spTD_elem), AAFRESULT_TEST_FAILED );
//IAAFTypeDefFixedArray::GetCArray()
aafUInt32 i=0;
checkResult(spFA->GetCArray(spPropVal, (aafMemPtr_t) check_fa, sizeof(check_fa)));
//VERIFY values:
for (i=0; i<TEST_FA_COUNT; i++)
checkExpression( check_fa[i] == TEST_FA_VALUES[i], AAFRESULT_TEST_FAILED );
//At this point, the test is succesful for both the CREATE and READ (unscrambling of .aaf file) routines
if (bMinimalTesting)
// so, bail if we're called from CREATE
return S_OK;
///// READ routine .... continue with more tests ....................
//IAAFTypeDefFixedArray::GetElementValue
//Get 3rd index out of array
aafUInt32 test_index = 2;
IAAFPropertyValueSP spSomeVal;
checkResult(spFA->GetElementValue(spPropVal, test_index, &spSomeVal));
//Make sure both have same types ...
checkResult(spSomeVal->GetType(&spTestType));
//!!! checkExpression( AreUnksSame(spTestType, spTD_elem), AAFRESULT_TEST_FAILED );
//now, test spSomeVal for integer
IAAFTypeDefIntSP spSomeInt;
checkResult(spTestType->QueryInterface(IID_IAAFTypeDefInt, (void**)&spSomeInt));
TEST_ELEM_t some_int = -1;
checkResult(spSomeInt->GetInteger(spSomeVal, (aafMemPtr_t)&some_int, sizeof (some_int)));
checkExpression( some_int == TEST_FA_VALUES[test_index], AAFRESULT_TEST_FAILED );
//IAAFTypeDefFixedArray::SetCArray
const TEST_ELEM_t newArray[TEST_FA_COUNT] = {99, -99, 22, -22, 120};
checkResult(spFA->SetCArray (spPropVal, (aafMemPtr_t) newArray, sizeof(newArray)));
//Verify that the new values are set ....
// .... call GetCArray
checkResult(spFA->GetCArray(spPropVal, (aafMemPtr_t) check_fa, sizeof(check_fa)));
for (i=0; i<TEST_FA_COUNT; i++)
checkExpression( check_fa[i] == newArray[i], AAFRESULT_TEST_FAILED );
//Test IAAFTypeDefFixedArray::IAAFTypeDefArray::SetElementValue() ....
some_int = -13;
checkResult(spSomeInt->CreateValue((aafMemPtr_t)&some_int, sizeof (some_int), &spSomeVal));
//try to set the value out-of-bounds
hr = spFA->SetElementValue(spPropVal, 5, spSomeVal); //5 is one elem out of bounds
checkExpression( hr == AAFRESULT_BADINDEX, AAFRESULT_TEST_FAILED );
//Set the element to last index ...
checkResult(spFA->SetElementValue(spPropVal, 4, spSomeVal)); //4 is last index position
//Now get back the element ...
checkResult(spFA->GetElementValue(spPropVal, 4, &spSomeVal));
some_int = 0; //reset value
checkResult(spSomeInt->GetInteger(spSomeVal, (aafMemPtr_t)&some_int, sizeof (some_int)));
//verify retrieved integer
checkExpression( -13 == some_int , AAFRESULT_TEST_FAILED );
////
//IAAFTypeDefArray::CreateValueFromValues ()
const TEST_ELEM_t newsize_array[7] = {10, -20, 30, -44, 55, -360, 11};
aafUInt32 bad_count = 7;
IAAFPropertyValue * pSourceValArr[7];
//setup
for (i=0; i<bad_count; i++)
checkResult(spSomeInt->CreateValue((aafMemPtr_t)&newsize_array[i],
sizeof (some_int), &pSourceValArr[i]));
IAAFPropertyValueSP spTargetValArr;
hr = spFA->CreateValueFromValues(pSourceValArr, bad_count, &spTargetValArr );
checkExpression(AAFRESULT_DATA_SIZE == hr, AAFRESULT_TEST_FAILED);
//ok try again, with the correct count
aafUInt32 good_count = 5;
checkResult(spFA->CreateValueFromValues(pSourceValArr, good_count, &spTargetValArr ));
//done with creating Target ValArr; release Source ValArr elements
for (i=0; i<bad_count; i++)
pSourceValArr[i]->Release();
//verify spPropValArr values
TEST_ELEM_t check2_fa [5] = {0}; //init a checking variable
checkResult(spFA->GetCArray(spTargetValArr, (aafMemPtr_t) check2_fa, sizeof(check2_fa)));
for (i=0; i<good_count; i++)
checkExpression( check2_fa[i] == newsize_array[i], AAFRESULT_TEST_FAILED );
//another negative test ...
//check for bad size request : like, say 6 elements
const TEST_ELEM_t badSize_array[TEST_FA_COUNT+1] = {99, -2, 78, -12, 77, -55};
hr = spFA->SetCArray (spPropVal, (aafMemPtr_t) badSize_array, sizeof(badSize_array));
//we should have got back a BAD SIZE!!!!
checkExpression( hr == AAFRESULT_BAD_SIZE, AAFRESULT_TEST_FAILED );
return S_OK;
}//verifyContents()
