able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/com/ole32/stg/props/utest/testcase.cxx
CryptoAlgo Inc b3cac27891 Add source files
2020-09-26 16:20:57 +08:00

9006 lines
310 KiB
C++
Raw Blame History

//+============================================================================
//
// File: TestCase.cxx
//
// Description:
// This file provides all of the actual test-cases for the
// PropTest DRT. Each test is a function, with a "test_"
// prefix.
//
//+============================================================================
#include "pch.cxx"
#include <ddeml.h> // For CP_WINUNICODE
#include "propstm.hxx"
#include "propstg.hxx"
#include "stgint.h"
EXTERN_C const IID
IID_IStorageTest = { /* 40621cf8-a17f-11d1-b28d-00c04fb9386d */
0x40621cf8,
0xa17f,
0x11d1,
{0xb2, 0x8d, 0x00, 0xc0, 0x4f, 0xb9, 0x38, 0x6d}
};
//+---------------------------------------------------------------
//
// Function: test_WriteReadAllProperties
//
// Synopsis: This test simply creates two new property
// sets in a new file (one Ansi and one Unicode),
// writes all the properties in g_rgcpropvarAll,
// reads them back, and verifies that it reads what
// it wrote.
//
// Inputs: [LPOLESTR] ocsDir (in)
// The directory in which a file can be created.
//
// Outputs: None.
//
//+---------------------------------------------------------------
void
test_WriteReadAllProperties( LPOLESTR ocsDir )
{
OLECHAR ocsFile[ MAX_PATH ];
FMTID fmtidAnsi, fmtidUnicode;
UINT ExpectedCodePage;
IStorage *pstg = NULL, *psubstg = NULL;
IStream *pstm = NULL;
IPropertySetStorage *ppropsetstg = NULL;
IPropertyStorage *ppropstgAnsi = NULL, *ppropstgUnicode = NULL;
CPropVariant rgcpropvar[ CPROPERTIES_ALL ];
CPropVariant rgcpropvarAnsi[ CPROPERTIES_ALL ];
CPropVariant rgcpropvarUnicode[ CPROPERTIES_ALL ];
CPropVariant rgcpropvarBag[ CPROPERTIES_ALL ];
CPropVariant rgcpropvarDefault[ 2 ];
CPropSpec rgcpropspecDefault[ 2 ];
IPropertySetStorage *pPropSetStg = NULL;
IPropertyStorage *pPropStg = NULL;
IPropertyBagEx *pbag = NULL;
ULONG ulIndex;
ULONG cPropertiesAll = CPROPERTIES_ALL;
Status( "Simple Write/Read Test\n" );
// ----------
// Initialize
// ----------
// Generate FMTIDs.
UuidCreate( &fmtidAnsi );
UuidCreate( &fmtidUnicode );
// Generate a filename from the directory name.
ocscpy( ocsFile, ocsDir );
ocscat( ocsFile, OLESTR( "AllProps.stg" ));
// ----------------
// Create a docfile
// ----------------
Check( S_OK, g_pfnStgCreateStorageEx( ocsFile,
STGM_CREATE | STGM_READWRITE | STGM_SHARE_EXCLUSIVE,
DetermineStgFmt( g_enumImplementation ),
0L,
NULL,
NULL,
DetermineStgIID( g_enumImplementation ),
(void**) &pstg )); //(void**) &ppropsetstg ));
Check( S_OK, pstg->QueryInterface( IID_IPropertySetStorage, (void**) &ppropsetstg ));
// Create the Property Storages
Check( S_OK, ppropsetstg->Create( fmtidAnsi,
&CLSID_NULL,
( (g_Restrictions & RESTRICT_UNICODE_ONLY) ? PROPSETFLAG_DEFAULT : PROPSETFLAG_ANSI )
|
( (g_Restrictions & RESTRICT_SIMPLE_ONLY) ? PROPSETFLAG_DEFAULT: PROPSETFLAG_NONSIMPLE ),
STGM_CREATE | STGM_READWRITE | STGM_SHARE_EXCLUSIVE,
&ppropstgAnsi ));
Check( S_OK, ppropsetstg->Create( fmtidUnicode,
&CLSID_NULL,
(g_Restrictions & RESTRICT_SIMPLE_ONLY) ? PROPSETFLAG_DEFAULT: PROPSETFLAG_NONSIMPLE,
STGM_READWRITE | STGM_SHARE_EXCLUSIVE,
&ppropstgUnicode ));
// Get a property bag. This is also a convenient place to test that we can QI between
// the storage and bag.
IStorage *pstg2 = NULL;
IPropertyBagEx *pbag2 = NULL;
IUnknown *punk1 = NULL;
IUnknown *punk2 = NULL;
Check( S_OK, pstg->QueryInterface( IID_IPropertyBagEx, reinterpret_cast<void**>(&pbag) ));
Check( S_OK, pbag->QueryInterface( DetermineStgIID( g_enumImplementation ), reinterpret_cast<void**>(&pstg2) ));
Check( S_OK, pstg2->QueryInterface( IID_IPropertyBagEx, reinterpret_cast<void**>(&pbag2) ));
Check( TRUE, pbag == pbag2 && pstg == pstg2 );
RELEASE_INTERFACE(pbag2);
RELEASE_INTERFACE(pstg2);
Check( S_OK, pstg->QueryInterface( IID_IUnknown, reinterpret_cast<void**>(&punk1) ));
Check( S_OK, pbag->QueryInterface( IID_IUnknown, reinterpret_cast<void**>(&punk2) ));
Check( TRUE, punk1 == punk2 );
RELEASE_INTERFACE(punk1);
RELEASE_INTERFACE(punk2);
// Write some simple properties
Check( S_OK, ppropstgAnsi->WriteMultiple( CPROPERTIES_ALL_SIMPLE,
g_rgcpropspecAll,
g_rgcpropvarAll,
PID_FIRST_USABLE ));
// Verify the format version is 0
CheckFormatVersion(ppropstgAnsi, 0);
// Write to all property sets.
Check( S_OK, ppropstgAnsi->WriteMultiple( cPropertiesAll,
g_rgcpropspecAll,
g_rgcpropvarAll,
PID_FIRST_USABLE ));
Check( S_OK, ResetRGPropVar( g_rgcpropvarAll ));
// Verify that the format is now version 1, since we wrote a VersionedStream property
CheckFormatVersion(ppropstgAnsi, 1);
Check( S_OK, ppropstgUnicode->WriteMultiple( cPropertiesAll,
g_rgcpropspecAll,
g_rgcpropvarAll,
PID_FIRST_USABLE ));
Check( S_OK, ResetRGPropVar( g_rgcpropvarAll ));
Check( S_OK, pbag->WriteMultiple( cPropertiesAll,
g_rgoszpropnameAll,
g_rgcpropvarAll ));
Check( S_OK, ResetRGPropVar( g_rgcpropvarAll ));
// Close and re-open everything
RELEASE_INTERFACE(pstg);
RELEASE_INTERFACE(ppropsetstg);
RELEASE_INTERFACE(ppropstgAnsi);
RELEASE_INTERFACE(ppropstgUnicode);
Check( 0, pbag->Release() );
pbag = NULL;
Check( S_OK, g_pfnStgOpenStorageEx( ocsFile,
STGM_READWRITE | STGM_SHARE_EXCLUSIVE,
DetermineStgFmt( g_enumImplementation ),
0L,
NULL,
NULL,
DetermineStgIID( g_enumImplementation ),
(void**) &pstg )); //(void**) &ppropsetstg ));
Check( S_OK, pstg->QueryInterface( IID_IPropertySetStorage, (void**) &ppropsetstg ));
// Create the Property Storages
Check( S_OK, ppropsetstg->Open( fmtidAnsi,
STGM_READWRITE | STGM_SHARE_EXCLUSIVE,
&ppropstgAnsi ));
Check( S_OK, ppropsetstg->Open( fmtidUnicode,
STGM_READWRITE | STGM_SHARE_EXCLUSIVE,
&ppropstgUnicode ));
Check( S_OK, pstg->QueryInterface( IID_IPropertyBagEx, reinterpret_cast<void**>(&pbag) ));
// Read and verify the auto-generated properties.
rgcpropspecDefault[0] = static_cast<PROPID>(PID_CODEPAGE);
rgcpropspecDefault[1] = static_cast<PROPID>(PID_LOCALE);
Check( S_OK, ppropstgAnsi->ReadMultiple( 2, rgcpropspecDefault, rgcpropvarDefault ));
ExpectedCodePage = (g_Restrictions & RESTRICT_UNICODE_ONLY) ? CP_WINUNICODE : GetACP();
Check( TRUE, VT_I2 == rgcpropvarDefault[0].vt );
Check( TRUE, ExpectedCodePage == (UINT) rgcpropvarDefault[0].iVal );
Check( TRUE, VT_UI4 == rgcpropvarDefault[1].vt );
Check( TRUE, GetUserDefaultLCID() == rgcpropvarDefault[1].ulVal );
Check( S_OK, ppropstgUnicode->ReadMultiple( 2, rgcpropspecDefault, rgcpropvarDefault ));
ExpectedCodePage = CP_WINUNICODE;
Check( TRUE, VT_I2 == rgcpropvarDefault[0].vt );
Check( TRUE, ExpectedCodePage == (UINT) rgcpropvarDefault[0].iVal );
Check( TRUE, VT_UI4 == rgcpropvarDefault[1].vt );
Check( TRUE, GetUserDefaultLCID() == rgcpropvarDefault[1].ulVal );
// Read from all property sets
Check( S_OK, ppropstgAnsi->ReadMultiple( cPropertiesAll,
g_rgcpropspecAll,
rgcpropvarAnsi ));
Check( S_OK, ppropstgUnicode->ReadMultiple( cPropertiesAll,
g_rgcpropspecAll,
rgcpropvarUnicode ));
Check( S_OK, pbag->ReadMultiple( cPropertiesAll, g_rgoszpropnameAll, rgcpropvarBag, NULL ));
// Compare the properties
for( int i = 0; i < (int)cPropertiesAll; i++ )
{
Check( TRUE, rgcpropvarAnsi[i] == g_rgcpropvarAll[i] );
Check( TRUE, rgcpropvarUnicode[i] == g_rgcpropvarAll[i] );
Check( TRUE, rgcpropvarBag[i] == g_rgcpropvarAll[i] );
}
// Show that we can delete everything
Check( S_OK, ppropstgAnsi->DeleteMultiple( cPropertiesAll, g_rgcpropspecAll ));
Check( S_OK, ppropstgUnicode->DeleteMultiple( cPropertiesAll, g_rgcpropspecAll ));
Check( S_OK, pbag->DeleteMultiple( cPropertiesAll, g_rgoszpropnameAll, 0 ));
// Re-write the properties, because it's convenient for debug sometimes
// to have a file around with lots of properties in it.
Check( S_OK, ppropstgAnsi->WriteMultiple( cPropertiesAll,
g_rgcpropspecAll,
g_rgcpropvarAll,
PID_FIRST_USABLE ));
Check( S_OK, ResetRGPropVar( g_rgcpropvarAll ));
Check( S_OK, ppropstgUnicode->WriteMultiple( cPropertiesAll,
g_rgcpropspecAll,
g_rgcpropvarAll,
PID_FIRST_USABLE ));
Check( S_OK, ResetRGPropVar( g_rgcpropvarAll ));
RELEASE_INTERFACE(pstg);
RELEASE_INTERFACE(ppropsetstg);
RELEASE_INTERFACE(ppropstgAnsi);
RELEASE_INTERFACE(ppropstgUnicode);
Check( 0, pbag->Release() );
pbag = NULL;
} // test_WriteReadProperties
BOOL
StgConvertPropertyToVariantWrapper(
IN SERIALIZEDPROPERTYVALUE const *pprop,
IN USHORT CodePage,
OUT PROPVARIANT *pvar,
IN PMemoryAllocator *pma,
OUT NTSTATUS *pstatus )
{
BOOL boolRet = FALSE;
*pstatus = STATUS_SUCCESS;
__try
{
boolRet = g_pfnStgConvertPropertyToVariant( pprop, CodePage, pvar, pma );
// boolRet = RtlConvertPropertyToVariant( pprop, CodePage, pvar, pma );
}
__except( EXCEPTION_EXECUTE_HANDLER )
{
*pstatus = GetExceptionCode();
}
return( boolRet );
}
ULONG
StgPropertyLengthAsVariantWrapper( SERIALIZEDPROPERTYVALUE *pprop, ULONG cbprop, USHORT CodePage, BYTE flags,
NTSTATUS *pstatus )
{
ULONG cbRet = 0;
*pstatus = STATUS_SUCCESS;
__try
{
cbRet = g_pfnStgPropertyLengthAsVariant( pprop, cbprop, CodePage, 0 );
// cbRet = PropertyLengthAsVariant( pprop, cbprop, CodePage, 0 );
}
__except( EXCEPTION_EXECUTE_HANDLER )
{
*pstatus = GetExceptionCode();
}
return( cbRet );
}
SERIALIZEDPROPERTYVALUE *
StgConvertVariantToPropertyWrapper(
IN PROPVARIANT const *pvar,
IN USHORT CodePage,
OPTIONAL OUT SERIALIZEDPROPERTYVALUE *pprop,
IN OUT ULONG *pcb,
IN PROPID pid,
IN BOOLEAN fVector,
OPTIONAL OUT ULONG *pcIndirect,
OUT NTSTATUS *pstatus )
{
SERIALIZEDPROPERTYVALUE * ppropRet = NULL;
*pstatus = STATUS_SUCCESS;
__try
{
ppropRet = g_pfnStgConvertVariantToProperty( pvar, CodePage, pprop, pcb, pid, fVector, pcIndirect );
// ppropRet = RtlConvertVariantToProperty( pvar, CodePage, pprop, pcb, pid, fVariantVectorOrArray, pcIndirect );
}
__except( EXCEPTION_EXECUTE_HANDLER )
{
*pstatus = GetExceptionCode();
}
return( ppropRet );
}
void
test_PidIllegal( IStorage *pstg )
{
IPropertySetStorage *ppropsetstg = NULL;
IPropertyStorage *ppropstg = NULL;
ULONG cRefsOriginal = GetRefCount(pstg);
CPropVariant rgcpropvarWrite[3], rgcpropvarRead[3];
CPropSpec rgcpropspec[3];
PROPID rgpropid[3];
LPOLESTR rgoszNames[3] = { NULL, NULL, NULL };
// Get an IPropertyStorage
Check( S_OK, pstg->QueryInterface( IID_IPropertySetStorage, reinterpret_cast<void**>(&ppropsetstg) ));
Check( S_OK, ppropsetstg->Create( FMTID_NULL, NULL, PROPSETFLAG_DEFAULT,
STGM_CREATE|STGM_SHARE_EXCLUSIVE|STGM_READWRITE,
&ppropstg ));
// Write a PID_ILLEGAL property. Since it's ignored, nothing should be written.
rgcpropvarWrite[0] = (long) 1234;
rgcpropspec[0] = PID_ILLEGAL;
Check( S_OK, ppropstg->WriteMultiple( 1, rgcpropspec, rgcpropvarWrite, PID_FIRST_USABLE ));
Check( S_FALSE, ppropstg->ReadMultiple( 1, rgcpropspec, rgcpropvarRead ));
// Write several normal properties
SHORT sOriginal = 1234;
LPOLESTR oszOriginalName = OLESTR("Second");
rgcpropvarWrite[0] = (long) 5678;
rgcpropvarWrite[1] = sOriginal;
rgcpropvarWrite[2] = (float) 23.5;
rgcpropspec[0] = OLESTR("First");
rgcpropspec[1] = oszOriginalName;
rgcpropspec[2] = OLESTR("Third");
Check( S_OK, ppropstg->WriteMultiple( 3, rgcpropspec, rgcpropvarWrite, PID_FIRST_USABLE ));
Check( S_OK, ppropstg->ReadMultiple( 3, rgcpropspec, rgcpropvarRead ));
Check( TRUE, rgcpropvarWrite[0] == rgcpropvarRead[0] );
Check( TRUE, rgcpropvarWrite[1] == rgcpropvarRead[1] );
Check( TRUE, rgcpropvarWrite[2] == rgcpropvarRead[2] );
// Re-write the properties except for one. The value of that property shouldn't change,
// nor should its name.
rgcpropvarWrite[0] = (short) 1234;
rgcpropvarWrite[1] = (long) 5678;
rgcpropvarWrite[2] = (double) 12.4;
rgcpropspec[1] = PID_ILLEGAL;
Check( S_OK, ppropstg->WriteMultiple( 3, rgcpropspec, rgcpropvarWrite, PID_FIRST_USABLE ));
rgcpropspec[1] = oszOriginalName;
Check( S_OK, ppropstg->ReadMultiple( 3, rgcpropspec, rgcpropvarRead ));
Check( TRUE, rgcpropvarWrite[0] == rgcpropvarRead[0] );
Check( TRUE, CPropVariant(sOriginal) == rgcpropvarRead[1] );
Check( TRUE, rgcpropvarWrite[2] == rgcpropvarRead[2] );
rgpropid[0] = PID_FIRST_USABLE;
rgpropid[1] = PID_FIRST_USABLE + 1;
rgpropid[2] = PID_FIRST_USABLE + 2;
Check( S_OK, ppropstg->ReadPropertyNames( 3, rgpropid, rgoszNames ));
Check( 0, wcscmp( rgcpropspec[0].lpwstr, rgoszNames[0] ));
Check( 0, wcscmp( oszOriginalName, rgoszNames[1] ));
Check( 0, wcscmp( rgcpropspec[2].lpwstr, rgoszNames[2] ));
for( int i = 0; i < 3; i++ )
{
CoTaskMemFree( rgoszNames[i] );
rgoszNames[i] = NULL;
}
// Re-write the names, again skipping one of them.
rgoszNames[0] = OLESTR("Updated first");
rgoszNames[1] = OLESTR("Updated second");
rgoszNames[2] = OLESTR("Updated third");
rgpropid[1] = PID_ILLEGAL;
Check( S_OK, ppropstg->WritePropertyNames( 3, rgpropid, rgoszNames ));
rgoszNames[0] = rgoszNames[1] = rgoszNames[2] = NULL;
rgpropid[1] = PID_FIRST_USABLE + 1;
Check( S_OK, ppropstg->ReadPropertyNames( 3, rgpropid, rgoszNames ));
Check( 0, wcscmp( rgoszNames[0], OLESTR("Updated first") ));
Check( 0, wcscmp( rgoszNames[1], oszOriginalName ));
Check( 0, wcscmp( rgoszNames[2], OLESTR("Updated third") ));
// Re-write just the one name, but skipping it.
rgpropid[1] = PID_ILLEGAL;
CoTaskMemFree( rgoszNames[1] );
rgoszNames[1] = OLESTR("Write just the second");
Check( S_OK, ppropstg->WritePropertyNames( 1, &rgpropid[1], &rgoszNames[1] ));
rgoszNames[1] = NULL;
rgpropid[1] = PID_FIRST_USABLE + 1;
Check( S_OK, ppropstg->ReadPropertyNames( 1, &rgpropid[1], &rgoszNames[1] ));
Check( 0, wcscmp( rgoszNames[1], oszOriginalName ));
// Exit
for( i = 0; i < 3; i++ )
CoTaskMemFree( rgoszNames[i] );
Check( 0, RELEASE_INTERFACE(ppropstg) );
Check( cRefsOriginal, RELEASE_INTERFACE(ppropsetstg) );
}
void
test_PropertyLengthAsVariant( )
{
Status( "StgPropertyLengthAsVariant, StgConvert*\n" );
ULONG i = 0;
BYTE *rgb = new BYTE[ 8192 ];
Check( TRUE, NULL != rgb );
CPropVariant rgcpropvar[ 7 ];
ULONG rgcbExpected[ 7 ];
CPropVariant *rgcpropvarSafeArray = NULL;
SAFEARRAY *rgpsa[3];
SAFEARRAYBOUND rgsaBounds[] = { {2,0}, {3,10}, {4,20} }; // [0..1], [10..12], [20..23]
ULONG cDims = sizeof(rgsaBounds)/sizeof(rgsaBounds[0]);
ULONG cElems = 0;
rgcpropvar[i] = (long) 1234; // VT_I4
rgcbExpected[i] = 0;
i++;
rgcpropvar[i].SetBSTR( OLESTR("Hello, world") ); // Creates a copy
rgcbExpected[i] = sizeof(OLESTR("Hello, world")) + sizeof(ULONG);
i++;
rgcpropvar[i][2] = (short) 2; // VT_VECTOR | VT_I2
rgcpropvar[i][1] = (short) 1;
rgcpropvar[i][0] = (short) 0;
rgcbExpected[i] = 3 * sizeof(short);
i++;
rgcpropvar[i][1] = (PROPVARIANT) CPropVariant( (unsigned long) 4 ); // VT_VECTOR | VT_VARIANT
rgcpropvar[i][0] = (PROPVARIANT) CPropVariant( (BSTR) OLESTR("Hi there") );
rgcbExpected[i] = 2 * sizeof(PROPVARIANT) + sizeof(OLESTR("Hi there")) + sizeof(ULONG);
i++;
rgpsa[0] = SafeArrayCreateEx( VT_I4, 3, rgsaBounds, NULL );
Check( TRUE, NULL != rgpsa[0] );
cElems = CalcSafeArrayElementCount( rgpsa[0] );
rgcbExpected[i+0] = sizeof(SAFEARRAY) - sizeof(SAFEARRAYBOUND)
+ 3 * sizeof(SAFEARRAYBOUND)
+ cElems * sizeof(LONG);
rgpsa[1] = SafeArrayCreateEx( VT_BSTR, 3, rgsaBounds, NULL );
Check( TRUE, NULL != rgpsa[1] );
rgcbExpected[i+1] = sizeof(SAFEARRAY) - sizeof(SAFEARRAYBOUND)
+ 3 * sizeof(SAFEARRAYBOUND)
+ cElems * sizeof(BSTR);
rgpsa[2] = SafeArrayCreateEx( VT_VARIANT, 3, rgsaBounds, NULL );
Check( TRUE, NULL != rgpsa[2] );
rgcbExpected[i+2] = sizeof(SAFEARRAY) - sizeof(SAFEARRAYBOUND)
+ 3 * sizeof(SAFEARRAYBOUND)
+ cElems * sizeof(PROPVARIANT);
rgcpropvarSafeArray = new CPropVariant[ cElems ];
Check( FALSE, NULL == rgcpropvar );
for( ULONG j = 0; j < cElems; j++ )
{
LONG rgIndices[3];
CalcSafeArrayIndices( j, rgIndices, rgsaBounds, cDims );
LONG lVal = static_cast<LONG>(j);
Check( S_OK, SafeArrayPutElement( rgpsa[0], rgIndices, &lVal ));
BSTR bstrVal = SysAllocString( OLESTR("0 BSTR Val") );
*bstrVal = OLESTR('0') + static_cast<OLECHAR>(j);
Check( S_OK, SafeArrayPutElement( rgpsa[1], rgIndices, bstrVal ));
rgcbExpected[i+1] += ocslen(bstrVal) + sizeof(OLECHAR) + sizeof(ULONG);
if( j & 1 )
rgcpropvarSafeArray[j] = (long) j;
else
{
rgcpropvarSafeArray[j].SetBSTR( bstrVal );
rgcbExpected[i+2] += ocslen(bstrVal)*sizeof(OLECHAR) + sizeof(OLECHAR) + sizeof(ULONG);
}
Check( S_OK, SafeArrayPutElement( rgpsa[2], rgIndices, &rgcpropvarSafeArray[j] ));
SysFreeString( bstrVal );
}
rgcpropvar[i].vt = VT_ARRAY | VT_I4;
reinterpret_cast<VARIANT*>(&rgcpropvar[i])->parray = rgpsa[0];
i++;
rgcpropvar[i].vt = VT_ARRAY | VT_BSTR;
reinterpret_cast<VARIANT*>(&rgcpropvar[i])->parray = rgpsa[1];
i++;
rgcpropvar[i].vt = VT_ARRAY | VT_VARIANT;
reinterpret_cast<VARIANT*>(&rgcpropvar[i])->parray = rgpsa[2];
i++;
Check( sizeof(rgcpropvar)/sizeof(rgcpropvar[0]), i );
for( i = 0; i < sizeof(rgcpropvar)/sizeof(rgcpropvar[0]); i++ )
{
PropTestMemoryAllocator ma;
SERIALIZEDPROPERTYVALUE *pprop = NULL;
CPropVariant cpropvarOut;
ULONG cbWritten = 8192, cbAsVariant = 0;
NTSTATUS status;
ULONG cIndirect;
pprop = StgConvertVariantToPropertyWrapper(
&rgcpropvar[i], CP_WINUNICODE,
reinterpret_cast<SERIALIZEDPROPERTYVALUE*>(rgb),
&cbWritten, PID_FIRST_USABLE,
FALSE,
&cIndirect,
&status );
Check( TRUE, NT_SUCCESS(status) );
Check( TRUE, NULL != pprop );
cbAsVariant = StgPropertyLengthAsVariantWrapper(
reinterpret_cast<SERIALIZEDPROPERTYVALUE*>(rgb),
cbWritten, CP_WINUNICODE, 0, &status );
Check( TRUE, NT_SUCCESS(status) );
// Check that the cbAsVariant is at least big enough. Also sanity check that
// it's not huge. We use a fudge multiple of 3 for this because the
// StgPropertyLengthAsVariant can way overestimate (primarily because it
// doesn't know if BSTRs will need conversion).
Check( TRUE, cbAsVariant >= rgcbExpected[i] );
Check( TRUE, cbAsVariant <= rgcbExpected[i]*3 );
// Check that we can convert back to a PropVariant
// (False because it's not an indirect property we're converting)
Check( FALSE, StgConvertPropertyToVariantWrapper( reinterpret_cast<SERIALIZEDPROPERTYVALUE*>(rgb),
CP_WINUNICODE, &cpropvarOut,
&ma, &status ));
Check( TRUE, NT_SUCCESS(status) );
Check( TRUE, cpropvarOut == rgcpropvar[i] );
}
g_pfnFreePropVariantArray( cElems, rgcpropvarSafeArray );
delete[] rgcpropvarSafeArray;
g_pfnFreePropVariantArray( sizeof(rgcpropvar)/sizeof(rgcpropvar[0]), rgcpropvar );
delete[] rgb;
}
void
test_LargePropertySet( IStorage *pstg )
{
FMTID fmtid;
IPropertySetStorage *pPropSetStg = NULL;
IPropertyStorage *pPropStg = NULL;
STATPROPSETSTG statpropsetstg;
CPropSpec cpropspec;
PROPVARIANT propvar;
Status( "Large property sets\n" );
Check( S_OK, pstg->QueryInterface( IID_IPropertySetStorage, reinterpret_cast<void**>(&pPropSetStg) ));
// Create a new property set.
UuidCreate( &fmtid );
Check( S_OK, pPropSetStg->Create( fmtid, NULL,
PROPSETFLAG_DEFAULT,
STGM_CREATE|STGM_SHARE_EXCLUSIVE|STGM_READWRITE,
&pPropStg ));
// Create a big property to write. Make it just about the max, 1M
// (it's hard to make it exactly the right size, because it depends on the
// size of the propset header, overallocs, etc.).
propvar.vt = VT_BLOB;
propvar.blob.cbSize = 1023 * 1024;
propvar.blob.pBlobData = new BYTE[ propvar.blob.cbSize ];
Check( FALSE, NULL == propvar.blob.pBlobData );
cpropspec = OLESTR("Name");
// Write this big property
Check( S_OK, pPropStg->WriteMultiple( 1, &cpropspec, &propvar, PID_FIRST_USABLE ));
// Create a slightly too large property set.
PropVariantClear( &propvar );
delete propvar.blob.pBlobData;
propvar.vt = VT_BLOB;
propvar.blob.cbSize = 1024 * 1024;
propvar.blob.pBlobData = new BYTE[ propvar.blob.cbSize ];
Check( FALSE, NULL == propvar.blob.pBlobData );
// Write this too-big property
Check( STG_E_MEDIUMFULL, pPropStg->WriteMultiple( 1, &cpropspec, &propvar, PID_FIRST_USABLE ));
delete propvar.blob.pBlobData;
RELEASE_INTERFACE( pPropStg );
}
void
test_VersionOneNames( IStorage *pstg )
{
FMTID fmtidInsensitive, fmtidSensitive, fmtidLongNames;
IPropertySetStorage *pPropSetStg = NULL;
IPropertyStorage *pPropStg = NULL;
STATPROPSETSTG statpropsetstg;
CPropSpec rgcpropspec[2];
CPropVariant rgcpropvarWrite[2], rgcpropvarRead[2];
LPOLESTR rgposzNames[2] = { NULL, NULL };
PROPID rgpropid[2] = { PID_FIRST_USABLE, PID_FIRST_USABLE+1 };
Status( "PROPSETFLAG_CASE_SENSITIVE flag and long names\n" );
Check( S_OK, pstg->QueryInterface( IID_IPropertySetStorage, reinterpret_cast<void**>(&pPropSetStg) ));
UuidCreate( &fmtidInsensitive );
UuidCreate( &fmtidSensitive );
UuidCreate( &fmtidLongNames );
// Make two passes, Unicode first, then Ansi.
for( int iPass = 0; iPass < 2; iPass++ )
{
DWORD propsetflagAnsi = 0 == iPass ? 0 : PROPSETFLAG_ANSI;
ULONG cbLongPropertyName = 1020 * 1024;
ULONG cchLongPropertyName = 0 == iPass ? cbLongPropertyName/sizeof(OLECHAR) : cbLongPropertyName;
// ------------------------
// Case insensitive propset
// ------------------------
Check( S_OK, pPropSetStg->Create( fmtidInsensitive, NULL,
PROPSETFLAG_DEFAULT | propsetflagAnsi,
STGM_CREATE|STGM_SHARE_EXCLUSIVE|STGM_READWRITE,
&pPropStg ));
// This should still be a version zero (original) propery set.
CheckFormatVersion( pPropStg, 0);
rgcpropspec[0] = OLESTR("Name");
rgcpropspec[1] = OLESTR("name");
rgcpropvarWrite[0] = (long) 0;
rgcpropvarWrite[1] = (short) 1;
// Write two properties with the same name (their the same because this is a
// case-insensitive property set).
Check( S_OK, pPropStg->WriteMultiple( 2, rgcpropspec, rgcpropvarWrite, PID_FIRST_USABLE ));
// Read the names back.
Check( S_OK, pPropStg->ReadPropertyNames( 2, rgpropid, rgposzNames ));
// Since we really only wrote one property, we should only get one name back
// Note that we get back the first name, but it's the second value!
Check( 0, ocscmp( rgcpropspec[0].lpwstr, rgposzNames[0] ));
Check( TRUE, NULL == rgposzNames[1] );
delete[] rgposzNames[0];
rgposzNames[0] = NULL;
// Double check that we really one wrote one property (the second).
Check( S_OK, pPropStg->ReadMultiple( 2, rgcpropspec, rgcpropvarRead ));
Check( TRUE, VT_I2 == rgcpropvarRead[0].VarType() && rgcpropvarRead[0] == CPropVariant((short) 1) );
Check( TRUE, VT_I2 == rgcpropvarRead[1].VarType() && rgcpropvarRead[1] == CPropVariant((short) 1) );
Check( S_OK, pPropStg->Stat( &statpropsetstg ));
Check( 0, statpropsetstg.grfFlags & PROPSETFLAG_CASE_SENSITIVE );
RELEASE_INTERFACE( pPropStg );
g_pfnFreePropVariantArray( 2, rgcpropvarRead );
// ----------------------
// Case sensitive propset
// ----------------------
Check( S_OK, pPropSetStg->Create( fmtidSensitive, NULL,
PROPSETFLAG_CASE_SENSITIVE | propsetflagAnsi,
STGM_CREATE|STGM_SHARE_EXCLUSIVE|STGM_READWRITE,
&pPropStg ));
// Case-sensitivity requires a version 1 property set.
CheckFormatVersion( pPropStg, 1 );
// Write the two names that differ only by case.
Check( S_OK, pPropStg->WriteMultiple( 2, rgcpropspec, rgcpropvarWrite, PID_FIRST_USABLE ));
// Read the names back and validate.
Check( S_OK, pPropStg->ReadPropertyNames( 2, rgpropid, rgposzNames ));
Check( TRUE, !ocscmp( rgcpropspec[0].lpwstr, rgposzNames[0] ));
Check( TRUE, !ocscmp( rgcpropspec[1].lpwstr, rgposzNames[1] ));
delete[] rgposzNames[0]; rgposzNames[0] = NULL;
delete[] rgposzNames[1]; rgposzNames[1] = NULL;
// Read the values and validate them too.
Check( S_OK, pPropStg->ReadMultiple( 2, rgcpropspec, rgcpropvarRead ));
Check( TRUE, VT_I4 == rgcpropvarRead[0].VarType() && rgcpropvarRead[0] == CPropVariant((long) 0) );
Check( TRUE, VT_I2 == rgcpropvarRead[1].VarType() && rgcpropvarRead[1] == CPropVariant((short) 1) );
g_pfnFreePropVariantArray( 2, rgcpropvarRead );
Check( S_OK, pPropStg->Stat( &statpropsetstg ));
Check( PROPSETFLAG_CASE_SENSITIVE, statpropsetstg.grfFlags & PROPSETFLAG_CASE_SENSITIVE );
RELEASE_INTERFACE( pPropStg );
// -----------------------
// Propset with long names
// -----------------------
Check( S_OK, pPropSetStg->Create( fmtidLongNames, NULL,
PROPSETFLAG_DEFAULT | propsetflagAnsi,
STGM_CREATE|STGM_SHARE_EXCLUSIVE|STGM_READWRITE,
&pPropStg ));
// So far we haven't done anything that requires a post-original property set.
CheckFormatVersion( pPropStg, 0 );
// Write a short name, validate it, and validate that the format version doesn't change.
rgcpropspec[0] = OLESTR("A short name");
Check( S_OK, pPropStg->WriteMultiple( 1, rgcpropspec, rgcpropvarWrite, PID_FIRST_USABLE ));
Check( S_OK, pPropStg->ReadPropertyNames( 1, rgpropid, rgposzNames )); // PROPID == 2
Check( TRUE, !ocscmp( rgcpropspec[0].lpwstr, rgposzNames[0] ));
CheckFormatVersion( pPropStg, 0 );
delete[] rgposzNames[0]; rgposzNames[0] = NULL;
// Now create a really, really, long name.
rgcpropspec[0].Alloc( cchLongPropertyName );
for( ULONG i = 0; i < cchLongPropertyName; i++ )
rgcpropspec[0][i] = OLESTR('a') + ( static_cast<OLECHAR>(i) % 26 );
rgcpropspec[0][cchLongPropertyName-1] = OLESTR('\0');
// Write this long name.
Check( S_OK, pPropStg->WriteMultiple( 1, rgcpropspec, rgcpropvarWrite, PID_FIRST_USABLE ));
// The property set's format version should have been automatically bumped up.
CheckFormatVersion( pPropStg, 1);
// Read the property using the long name
Check( S_OK, pPropStg->ReadMultiple( 1, rgcpropspec, rgcpropvarRead ));
Check( TRUE, rgcpropvarWrite[0] == rgcpropvarRead[0] );
rgcpropvarRead[0].Clear();
// Read and validate the property name.
Check( S_OK, pPropStg->ReadPropertyNames( 1, &rgpropid[1], rgposzNames )); // PROPID == 3
Check( TRUE, !ocscmp( rgcpropspec[0].lpwstr, rgposzNames[0] ));
delete[] rgposzNames[0]; rgposzNames[0] = NULL;
// Try to write a long, different name.
rgcpropspec[0][0] = OLESTR('#');
Check( STG_E_MEDIUMFULL, pPropStg->WriteMultiple( 1, rgcpropspec, rgcpropvarWrite, PID_FIRST_USABLE ));
RELEASE_INTERFACE( pPropStg );
} // for( int iPass = 0; iPass < 2; iPass++ )
RELEASE_INTERFACE( pPropSetStg );
} // test_VersionOneNames()
void
test_MultipleReader( LPOLESTR ocsDir )
{
OLECHAR ocsFile[ MAX_PATH ];
IPropertyBagEx *pBag1 = NULL, *pBag2 = NULL;
CPropVariant rgcpropvarRead1[ CPROPERTIES_ALL ], rgcpropvarRead2[ CPROPERTIES_ALL ];
OLECHAR oszPropertyName[] = OLESTR("Simple property");
IEnumSTATPROPBAG *penum = NULL;
STATPROPBAG rgstatpropbag[ CPROPERTIES_ALL + 1];
ULONG cEnum = 0;
Status( "Multiple stgm_read|stgm_deny_write\n" );
ocscpy( ocsFile, ocsDir );
ocscat( ocsFile, OLESTR("test_MultipleReader") );
Check( S_OK, g_pfnStgCreateStorageEx( ocsFile,
STGM_CREATE | STGM_READWRITE | STGM_SHARE_EXCLUSIVE,
DetermineStgFmt( g_enumImplementation ),
0L, NULL, NULL,
IID_IPropertyBagEx,
reinterpret_cast<void**>(&pBag1) ));
Check( S_OK, pBag1->WriteMultiple( CPROPERTIES_ALL,
g_rgoszpropnameAll,
g_rgcpropvarAll ));
Check( S_OK, ResetRGPropVar( g_rgcpropvarAll ));
Check( 0, RELEASE_INTERFACE(pBag1) );
Check( S_OK, g_pfnStgOpenStorageEx( ocsFile,
STGM_READ | STGM_SHARE_DENY_WRITE,
STGFMT_ANY,
0L, NULL, NULL,
IID_IPropertyBagEx,
reinterpret_cast<void**>(&pBag1) ));
Check( S_OK, g_pfnStgOpenStorageEx( ocsFile,
STGM_READ | STGM_SHARE_DENY_WRITE,
STGFMT_ANY,
0L, NULL, NULL,
IID_IPropertyBagEx,
reinterpret_cast<void**>(&pBag2) ));
Check( S_OK, pBag2->Enum( NULL, 0, &penum )); //OLESTR(""), 0, &penum ));
Check( S_OK, penum->Next( CPROPERTIES_ALL, rgstatpropbag, &cEnum ));
Check( CPROPERTIES_ALL, cEnum );
Check( S_OK, pBag1->ReadMultiple( CPROPERTIES_ALL, g_rgoszpropnameAll,
rgcpropvarRead1, NULL ));
Check( S_OK, pBag2->ReadMultiple( CPROPERTIES_ALL, g_rgoszpropnameAll,
rgcpropvarRead2, NULL ));
for( int i = 0; i < CPROPERTIES_ALL; i++ )
{
Check( TRUE, rgcpropvarRead1[i] == g_rgcpropvarAll[i] );
Check( TRUE, rgcpropvarRead2[i] == g_rgcpropvarAll[i] );
delete[] rgstatpropbag[i].lpwstrName;
rgstatpropbag[i].lpwstrName = NULL;
}
Check( 0, RELEASE_INTERFACE(penum) );
Check( 0, RELEASE_INTERFACE(pBag1) );
Check( 0, RELEASE_INTERFACE(pBag2) );
return;
} // test_MultipleReader
void
test_Robustness(OLECHAR *poszDir)
{
if( PROPIMP_NTFS != g_enumImplementation ) return;
Status( "NTFS property set robustness\n" );
HRESULT hr = S_OK;
IStorage *pStorage = NULL;
IPropertySetStorage *pPropSetStg = NULL;
IPropertyStorage *pPropStg = NULL;
IStorageTest *pPropStgTest = NULL;
IStream *pStm = NULL;
FMTID fmtid;
STATSTG statstg;
OLECHAR oszFile[ MAX_PATH ];
OLECHAR oszName[ MAX_PATH ];
OLECHAR oszUpdateName[ MAX_PATH ];
CPropSpec rgcpropspec[2];
CPropVariant rgcpropvarWrite[2], rgcpropvarRead[2];
ocscpy( oszFile, poszDir );
ocscat( oszFile, OLESTR("test_Robustness") );
// Create a property set and put a property into it.
Check( S_OK, g_pfnStgCreateStorageEx( oszFile, STGM_READWRITE|STGM_CREATE|STGM_SHARE_EXCLUSIVE,
DetermineStgFmt(g_enumImplementation),
0, NULL, NULL,
DetermineStgIID( g_enumImplementation ),
reinterpret_cast<void**>(&pStorage) ));
Check( S_OK, pStorage->QueryInterface( IID_IPropertySetStorage,
reinterpret_cast<void**>(&pPropSetStg) ));
UuidCreate( &fmtid );
Check( S_OK, pPropSetStg->Create( fmtid, NULL, PROPSETFLAG_DEFAULT,
STGM_CREATE|STGM_READWRITE|STGM_SHARE_EXCLUSIVE,
&pPropStg ));
rgcpropspec[0] = OLESTR("Property Name");
rgcpropspec[1] = OLESTR("Second property name");
rgcpropvarWrite[0] = static_cast<long>(23);
rgcpropvarWrite[1] = OLESTR("Second property value");
Check( S_OK, pPropStg->WriteMultiple( 1, &rgcpropspec[0], &rgcpropvarWrite[0], PID_FIRST_USABLE ));
Check( 0, RELEASE_INTERFACE(pPropStg) );
// Rename the property set's stream to "Updt_*", and create any empty stream
// in its place. This simulates a crash during the flush of a property set.
RtlGuidToPropertySetName( &fmtid, oszName );
oszName[ 0 ] = OC_PROPSET0;
wcscpy( oszUpdateName, OLESTR("Updt_") );
wcscat( oszUpdateName, oszName );
Check( S_OK, pStorage->RenameElement( oszName, oszUpdateName ));
Check( S_OK, pStorage->CreateStream( oszName, STGM_READWRITE|STGM_SHARE_EXCLUSIVE, 0, 0, &pStm ));
Check( 0, RELEASE_INTERFACE(pStm) );
// Open the property set in read-only mode, and verify that we can still ready
// the property. Since we're opening in read-only, the streams should remain
// unchanged.
Check( S_OK, pPropSetStg->Open( fmtid, STGM_READ|STGM_SHARE_EXCLUSIVE, &pPropStg ));
Check( S_OK, pPropStg->ReadMultiple( 1, &rgcpropspec[0], &rgcpropvarRead[0] ));
Check( TRUE, rgcpropvarWrite[0] == rgcpropvarRead[0] );
Check( 0, RELEASE_INTERFACE(pPropStg) );
// Verify that the streams do not appear to have been changed.
Check( S_OK, pStorage->OpenStream( oszName, NULL, STGM_READ|STGM_SHARE_EXCLUSIVE, 0, &pStm ));
Check( S_OK, pStm->Stat( &statstg, STATFLAG_NONAME ));
Check( TRUE, CULargeInteger(0) == CULargeInteger(statstg.cbSize) );
Check( 0, RELEASE_INTERFACE(pStm) );
Check( S_OK, pStorage->OpenStream( oszUpdateName, NULL, STGM_READ|STGM_SHARE_EXCLUSIVE, 0, &pStm ));
Check( S_OK, pStm->Stat( &statstg, STATFLAG_NONAME ));
Check( FALSE, CULargeInteger(0) == CULargeInteger(statstg.cbSize) );
Check( 0, RELEASE_INTERFACE(pStm) );
// Now open the property set for write. This should cause the problem to be fixed.
Check( S_OK, pPropSetStg->Open( fmtid, STGM_READWRITE|STGM_SHARE_EXCLUSIVE, &pPropStg ));
// Read the property back
Check( S_OK, pPropStg->ReadMultiple( 1, &rgcpropspec[0], &rgcpropvarRead[0] ));
Check( TRUE, rgcpropvarWrite[0] == rgcpropvarRead[0] );
// Write another property and read both properties back
Check( S_OK, pPropStg->WriteMultiple( 1, &rgcpropspec[1], &rgcpropvarWrite[1], PID_FIRST_USABLE ));
Check( S_OK, pPropStg->ReadMultiple( 2, &rgcpropspec[0], &rgcpropvarRead[0] ));
Check( TRUE, rgcpropvarWrite[0] == rgcpropvarRead[0] );
Check( TRUE, rgcpropvarWrite[1] == rgcpropvarRead[1] );
rgcpropvarRead[1].Clear();
Check( 0, RELEASE_INTERFACE(pPropStg) );
// Verify that the streams look corrected.
Check( S_OK, pStorage->OpenStream( oszName, NULL, STGM_READ|STGM_SHARE_EXCLUSIVE, 0, &pStm ));
Check( S_OK, pStm->Stat( &statstg, STATFLAG_NONAME ));
Check( TRUE, CULargeInteger(0) != CULargeInteger(statstg.cbSize) );
Check( 0, RELEASE_INTERFACE(pStm) );
Check( STG_E_FILENOTFOUND, pStorage->OpenStream( oszUpdateName, NULL, STGM_READ|STGM_SHARE_EXCLUSIVE, 0, &pStm ));
// Write/read after disabling the stream-rename
Check( S_OK, pPropSetStg->Create( fmtid, NULL, PROPSETFLAG_DEFAULT, STGM_READWRITE|STGM_SHARE_EXCLUSIVE|STGM_CREATE, &pPropStg ));
hr = pPropStg->QueryInterface( IID_IStorageTest, reinterpret_cast<void**>(&pPropStgTest) );
if( SUCCEEDED(hr) )
Check( S_OK, pPropStgTest->UseNTFS4Streams( TRUE ));
if( E_NOINTERFACE == hr )
{
Status( " ... Partially skipping, IStorageTest not available (free build?)\n" );
}
else
{
Check( STG_E_FILENOTFOUND, pStorage->OpenStream( oszUpdateName, NULL, STGM_READ|STGM_SHARE_EXCLUSIVE, 0, &pStm ));
Check( S_OK, pPropStg->WriteMultiple( 2, &rgcpropspec[0], &rgcpropvarWrite[0], PID_FIRST_USABLE ));
Check( STG_E_FILENOTFOUND, pStorage->OpenStream( oszUpdateName, NULL, STGM_READ|STGM_SHARE_EXCLUSIVE, 0, &pStm ));
Check( S_OK, pPropStg->Commit( STGC_DEFAULT ));
Check( STG_E_FILENOTFOUND, pStorage->OpenStream( oszUpdateName, NULL, STGM_READ|STGM_SHARE_EXCLUSIVE, 0, &pStm ));
RELEASE_INTERFACE( pPropStgTest );
Check( STG_E_FILENOTFOUND, pStorage->OpenStream( oszUpdateName, NULL, STGM_READ|STGM_SHARE_EXCLUSIVE, 0, &pStm ));
Check( 0, RELEASE_INTERFACE(pPropStg) );
Check( S_OK, pPropSetStg->Open( fmtid, STGM_READ|STGM_SHARE_DENY_WRITE, &pPropStg ));
Check( STG_E_FILENOTFOUND, pStorage->OpenStream( oszUpdateName, NULL, STGM_READ|STGM_SHARE_EXCLUSIVE, 0, &pStm ));
Check( S_OK, pPropStg->ReadMultiple( 2, rgcpropspec, rgcpropvarRead ));
Check( STG_E_FILENOTFOUND, pStorage->OpenStream( oszUpdateName, NULL, STGM_READ|STGM_SHARE_EXCLUSIVE, 0, &pStm ));
Check( TRUE, rgcpropvarWrite[0] == rgcpropvarRead[0] );
Check( TRUE, rgcpropvarWrite[1] == rgcpropvarRead[1] );
g_pfnFreePropVariantArray( 2, rgcpropvarRead );
}
// Write to the property set, then cause it to be shutdown and reverted.
Check( 0, RELEASE_INTERFACE(pPropStg) );
Check( S_OK, pPropSetStg->Open( fmtid, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, &pPropStg ));
rgcpropvarWrite[0] = OLESTR("Hello");
rgcpropvarWrite[1] = OLESTR("World");
Check( S_OK, pPropStg->WriteMultiple( 2, rgcpropspec, rgcpropvarWrite, PID_FIRST_USABLE ));
RELEASE_INTERFACE(pPropSetStg);
Check( 0, RELEASE_INTERFACE(pStorage) ); // Should flush the properties
Check( STG_E_REVERTED, pPropStg->ReadMultiple( 2, rgcpropspec, rgcpropvarRead ));
Check( 0, RELEASE_INTERFACE(pPropStg) );
Check( S_OK, g_pfnStgOpenStorageEx( oszFile, STGM_READ|STGM_SHARE_DENY_WRITE,
STGFMT_ANY,
0, NULL, NULL,
IID_IPropertySetStorage,
reinterpret_cast<void**>(&pPropSetStg) ));
Check( S_OK, pPropSetStg->Open( fmtid, STGM_READ|STGM_SHARE_EXCLUSIVE, &pPropStg ));
Check( S_OK, pPropStg->ReadMultiple( 2, rgcpropspec, rgcpropvarRead ));
Check( TRUE, rgcpropvarWrite[0] == rgcpropvarRead[0] );
Check( TRUE, rgcpropvarWrite[1] == rgcpropvarRead[1] );
Check( 0, RELEASE_INTERFACE(pPropStg) );
g_pfnFreePropVariantArray( 2, rgcpropvarRead );
//
// Exit
//
RELEASE_INTERFACE(pPropSetStg);
g_pfnFreePropVariantArray( 2, rgcpropvarWrite );
g_pfnFreePropVariantArray( 2, rgcpropvarRead );
} // test_Robustness
void
test_EmptyBag( OLECHAR *poszDir )
{
OLECHAR oszFile[ MAX_PATH ];
IStorage *pstg = NULL;
IPropertyBagEx *pbag = NULL;
PROPVARIANT propvar;
IEnumSTATPROPBAG *penum = NULL;
STATPROPBAG statpropbag;
ULONG cFetched;
ocscpy( oszFile, poszDir );
ocscat( oszFile, OLESTR("test_EmptyBag") );
Check( S_OK, g_pfnStgCreateStorageEx( oszFile,
STGM_CREATE | STGM_READWRITE | STGM_SHARE_EXCLUSIVE,
DetermineStgFmt( g_enumImplementation ),
0L,
NULL,
NULL,
IID_IPropertyBagEx,
(void**) &pbag ));
PropVariantInit( &propvar );
OLECHAR *poszName = OLESTR("test");
Check( S_FALSE, pbag->ReadMultiple( 1, &poszName, &propvar, NULL ));
Check( VT_EMPTY, propvar.vt );
Check( S_OK, pbag->Enum( OLESTR(""), 0, &penum ));
Check( S_FALSE, penum->Next( 1, &statpropbag, &cFetched ));
Check( 0, cFetched );
Check( 0, RELEASE_INTERFACE(penum));
Check( 0, RELEASE_INTERFACE(pbag));
} // test_EmptyBag
void
test_BagDelete( IStorage *pstg )
{
HRESULT hr = S_OK;
IPropertyBagEx *pbag = NULL;
IEnumSTATPROPBAG* penum = NULL;
ULONG cFetched;
ULONG i, j;
OLECHAR * rgoszDelete[2];
// Note that some of these names only differ by case, which is legal in a bag
OLECHAR *rgoszNames[] = { OLESTR("www.microsoft.com/bag/test?prop1"),
OLESTR("www.microsoft.com/bag/test?PROP1"),
OLESTR("www.microsoft.com/bag/2test?prop1"),
OLESTR("www.microsoft.com/bag2/test?prop1") };
CPropVariant rgcpropvarRead[ ELEMENTS(rgoszNames) + 1 ];
STATPROPBAG rgstatpropbag[ ELEMENTS(rgoszNames) + 1 ];
Status( "Property bag deletions\n" );
Check( S_OK, pstg->QueryInterface( IID_IPropertyBagEx, reinterpret_cast<void**>(&pbag) ));
DeleteBagExProperties( pbag, OLESTR("") );
// ------------------------------------------
// Delete bag2/test?prop1 by name & by prefix
// ------------------------------------------
for( i = 0; i < 2; i++ )
{
ULONG cFetchedExpected;
switch(i)
{
case 0:
// Delete by name
rgoszDelete[0] = OLESTR("www.microsoft.com/bag2/test?prop1");
cFetchedExpected = ELEMENTS(rgoszNames) - 1;
break;
case 1:
// Delete by prefix
rgoszDelete[0] = OLESTR("www.microsoft.com/bag2/test");
cFetchedExpected = ELEMENTS(rgoszNames) - 1;
break;
default:
Check( FALSE, TRUE ); //Check( FALSE, 0 == OLESTR("Invalid switch") );
} // switch(i)
Check( S_OK, pbag->WriteMultiple( ELEMENTS(rgoszNames), rgoszNames, g_rgcpropvarAll ));
Check( S_OK, ResetRGPropVar( g_rgcpropvarAll ));
DeleteBagExProperties( pbag, rgoszDelete[0] );
Check( S_OK, pbag->Enum( OLESTR(""), 0, &penum ));
Check( ELEMENTS(rgoszNames) == cFetchedExpected ? S_OK : S_FALSE,
penum->Next( ELEMENTS(rgoszNames), rgstatpropbag, &cFetched ));
Check( TRUE, cFetchedExpected == cFetched );
RELEASE_INTERFACE(penum);
for( j = 0; j < cFetched; j++ )
{
Check( TRUE, !wcscmp(rgoszNames[j], rgstatpropbag[j].lpwstrName) );
delete [] rgstatpropbag[j].lpwstrName;
}
} // for( i = 0; i < 2; i++ )
// -----------------------------------------------
// Delete the two "/bag/test" properties by prefix
// -----------------------------------------------
rgoszDelete[0] = OLESTR("www.microsoft.com/bag/test");
Check( S_OK, pbag->WriteMultiple( ELEMENTS(rgoszNames), rgoszNames, g_rgcpropvarAll ));
Check( S_OK, ResetRGPropVar( g_rgcpropvarAll ));
DeleteBagExProperties( pbag, rgoszDelete[0] );
Check( S_OK, pbag->Enum( OLESTR(""), 0, &penum ));
Check( S_FALSE, penum->Next( ELEMENTS(rgoszNames), rgstatpropbag, &cFetched ));
Check( TRUE, 2 == cFetched );
RELEASE_INTERFACE(penum);
for( j = 0; j < cFetched; j++ )
{
Check( TRUE, !wcscmp(rgoszNames[j+2], rgstatpropbag[j].lpwstrName) );
delete [] rgstatpropbag[j].lpwstrName;
}
/*
// -------------------------
// Delete all the properties
// -------------------------
rgoszDelete[0] = NULL;
Check( S_OK, pbag->WriteMultiple( ELEMENTS(rgoszNames), rgoszNames, g_rgcpropvarAll ));
Check( S_OK, ResetRGPropVar( g_rgcpropvarAll ));
Check( S_OK, pbag->Delete( OLESTR(""), DELETEPROPERTY_MASK));
Check( S_OK, pbag->Enum( OLESTR(""), 0, &penum ));
Check( S_FALSE, penum->Next( ELEMENTS(rgoszNames), rgstatpropbag, &cFetched ));
Check( TRUE, 0 == cFetched );
RELEASE_INTERFACE(penum);
*/
pbag->Release();
} // test_BagDelete
void
test_IPropertyBag( IStorage *pstg )
{
Status( "IPropertyBag\n" );
IPropertyBagEx *pbagex = NULL;
IPropertyBag *pbag = NULL;
ULONG cRefsOriginal = GetRefCount( pstg );
Check( S_OK, pstg->QueryInterface( IID_IPropertyBagEx, reinterpret_cast<void**>(&pbagex) ));
DeleteBagExProperties( pbagex, OLESTR("") );
RELEASE_INTERFACE(pbagex);
Check( S_OK, pstg->QueryInterface( IID_IPropertyBag, reinterpret_cast<void**>(&pbag) ));
VARIANT varWrite, varRead;
VariantInit( &varWrite );
VariantInit( &varRead );
varWrite.vt = VT_I4;
varWrite.lVal = 1234;
Check( S_OK, pbag->Write( OLESTR("Variant I4"), &varWrite ));
Check( S_OK, pbag->Read( OLESTR("Variant I4"), &varRead, NULL ));
Check( TRUE, varWrite.vt == varRead.vt );
Check( TRUE, varWrite.lVal == varRead.lVal );
Check( cRefsOriginal, RELEASE_INTERFACE(pbag) );
}
void
test_BagVtUnknown( IStorage *pstg )
{
HRESULT hr = S_OK;
IPropertyBagEx *pbag = NULL;
ULONG cRefsOriginal = 0;
Status( "VT_UNKNOWN in an IPropertyBagEx\n" );
pstg->AddRef();
cRefsOriginal = pstg->Release();
Check( S_OK, pstg->QueryInterface( IID_IPropertyBagEx, reinterpret_cast<void**>(&pbag) ));
DeleteBagExProperties( pbag, OLESTR("") );
CObjectWithPersistStorage *pStgObjectWritten = NULL, *pStgObjectRead = NULL;
CObjectWithPersistStream *pStmObjectWritten = NULL, *pStmObjectRead = NULL;
pStgObjectWritten = new CObjectWithPersistStorage( OLESTR("VtUnknown-Storage") );
pStgObjectRead = new CObjectWithPersistStorage();
pStmObjectWritten = new CObjectWithPersistStream( OLESTR("VtUnknown-Stream") );
pStmObjectRead = new CObjectWithPersistStream();
Check( TRUE, NULL != pStgObjectWritten && NULL != pStgObjectRead );
Check( TRUE, NULL != pStmObjectWritten && NULL != pStmObjectRead );
VARIANT rgvarRead[2], rgvarWritten[2];
VariantInit( &rgvarRead[0] );
VariantInit( &rgvarRead[1] );
VariantInit( &rgvarWritten[0] );
VariantInit( &rgvarWritten[1] );
rgvarWritten[0].vt = VT_UNKNOWN;
rgvarWritten[0].punkVal = static_cast<IUnknown*>(pStgObjectWritten);
rgvarWritten[1].vt = VT_BYREF | VT_UNKNOWN;
IUnknown *punkByRefVal = static_cast<IUnknown*>(pStmObjectWritten);
rgvarWritten[1].ppunkVal = &punkByRefVal;
rgvarRead[0].vt = VT_UNKNOWN;
rgvarRead[0].punkVal = static_cast<IUnknown*>(pStgObjectRead);
rgvarRead[1].vt = VT_UNKNOWN;
rgvarRead[1].punkVal = static_cast<IUnknown*>(pStmObjectRead);
OLECHAR *rgoszName[2] = { OLESTR("VtUnknown (persisted as Storage)"),
OLESTR("ByRef VtUnknown (persisted as Stream)") };
Check( S_OK, pbag->WriteMultiple( 2, rgoszName, reinterpret_cast<PROPVARIANT*>(rgvarWritten) ));
Check( S_OK, pbag->ReadMultiple( 2, rgoszName, reinterpret_cast<PROPVARIANT*>(rgvarRead), NULL ));
Check( TRUE, *pStgObjectRead == *pStgObjectWritten );
Check( TRUE, *pStmObjectRead == *pStmObjectWritten );
Check( 0, RELEASE_INTERFACE( pStgObjectRead ));
Check( 0, RELEASE_INTERFACE( pStmObjectRead ));
PROPVARIANT rgpropvarReadRaw[2];
PropVariantInit( &rgpropvarReadRaw[0] );
PropVariantInit( &rgpropvarReadRaw[1] );
Check( S_OK, pbag->ReadMultiple( 2, rgoszName, rgpropvarReadRaw, NULL ));
Check( VT_STORED_OBJECT, rgpropvarReadRaw[0].vt );
Check( VT_STREAMED_OBJECT, rgpropvarReadRaw[1].vt );
STATSTG statstg;
Check( S_OK, rgpropvarReadRaw[0].pStorage->Stat( &statstg, STATFLAG_NONAME ));
Check( TRUE, statstg.clsid == pStgObjectWritten->GetClassID() );
Check( 0, RELEASE_INTERFACE( pStgObjectWritten ));
Check( S_OK, PropVariantClear( &rgpropvarReadRaw[0] ));
CLSID clsid;
ULONG cbRead;
Check( S_OK, rgpropvarReadRaw[1].pStream->Read( &clsid, sizeof(clsid), &cbRead ));
Check( sizeof(clsid), cbRead );
Check( TRUE, clsid == pStmObjectWritten->GetClassID() );
Check( 0, RELEASE_INTERFACE( pStmObjectWritten ));
Check( S_OK, PropVariantClear( &rgpropvarReadRaw[1] ));
Check( cRefsOriginal, RELEASE_INTERFACE(pbag) );
} // test_BagVtUnknown
void
test_BagEnum( IStorage *pstg )
{
IPropertyBagEx *pbag = NULL;
IEnumSTATPROPBAG *penum = NULL;
ULONG cFetched;
ULONG i;
const OLECHAR * rgoszDelete[] = { OLESTR("") };
const OLECHAR *rgoszNames[] = { OLESTR("www.microsoft.com/bag/test?prop1"),
OLESTR("www.microsoft.com/bag/test?prop2"),
OLESTR("www.microsoft.com/bag/2test?prop1"),
OLESTR("www.microsoft.com/bag2/test?prop1") };
STATPROPBAG rgstatpropbag[ ELEMENTS(rgoszNames) + 1 ];
Status( "Property bag enumeration\n" );
// Initialize the bag
Check( S_OK, pstg->QueryInterface( IID_IPropertyBagEx, reinterpret_cast<void**>(&pbag) ));
DeleteBagExProperties( pbag, OLESTR("") );
Check( S_OK, pbag->WriteMultiple( ELEMENTS(rgoszNames), rgoszNames, g_rgcpropvarAll ));
Check( S_OK, ResetRGPropVar( g_rgcpropvarAll ));
// Try to enum n+1 elements (to get an S_FALSE)
Check( S_OK, pbag->Enum( NULL, 0, &penum ));
Check( S_FALSE, penum->Next( ELEMENTS(rgstatpropbag), rgstatpropbag, &cFetched ));
Check( TRUE, ELEMENTS(rgoszNames) == cFetched );
for( i = 0; i < cFetched; i++ )
delete [] rgstatpropbag[i].lpwstrName;
RELEASE_INTERFACE(penum);
// Try to enum n elements (should get an S_OK)
Check( S_OK, pbag->Enum( OLESTR(""), 0, &penum ));
Check( S_OK, penum->Next( ELEMENTS(rgoszNames), rgstatpropbag, &cFetched ));
Check( TRUE, ELEMENTS(rgoszNames) == cFetched );
for( i = 0; i < cFetched; i++ )
delete [] rgstatpropbag[i].lpwstrName;
RELEASE_INTERFACE(penum);
// Enum a subset
Check( S_OK, pbag->Enum( OLESTR("www.microsoft.com/bag/test"), 0, &penum ));
Check( S_FALSE, penum->Next( ELEMENTS(rgoszNames), rgstatpropbag, &cFetched ));
Check( TRUE, 2 == cFetched );
for( i = 0; i < cFetched; i++ )
delete [] rgstatpropbag[i].lpwstrName;
RELEASE_INTERFACE(penum);
// Enum a non-extant subset
Check( S_OK, pbag->Enum( OLESTR("dummy"), 0, &penum ));
Check( S_FALSE, penum->Next( ELEMENTS(rgoszNames), rgstatpropbag, &cFetched ));
Check( TRUE, 0 == cFetched );
RELEASE_INTERFACE(penum);
// Enum a single property
Check( S_OK, pbag->Enum( OLESTR("www.microsoft.com/bag/test?prop1"), 0, &penum ));
Check( S_FALSE, penum->Next( 2, rgstatpropbag, &cFetched ));
Check( 1, cFetched );
delete[] rgstatpropbag[0].lpwstrName;
rgstatpropbag[0].lpwstrName = NULL;
RELEASE_INTERFACE(penum);
RELEASE_INTERFACE(pbag);
} // test_BagEnum
void
test_BagCoercion( IStorage *pstg )
{
IPropertyBag *pbag = NULL;
IPropertyBagEx *pbagX = NULL;
const OLECHAR *rgosz[2];
PROPVARIANT rgpropvar[2];
Status( "Property bag coercion\n" );
// Get a bag and a bagex, and clean the bag.
Check( S_OK, pstg->QueryInterface( IID_IPropertyBag,
reinterpret_cast<void**>(&pbag) ));
Check( S_OK, pstg->QueryInterface( IID_IPropertyBagEx,
reinterpret_cast<void**>(&pbagX) ));
DeleteBagExProperties( pbagX, OLESTR("") );
// Initialize the bag with some properties
rgpropvar[0].vt = VT_I2;
rgpropvar[0].iVal = 2;
rgosz[0] = OLESTR("www.microsoft.com/test/i2");
rgpropvar[1].vt = VT_UI2;
rgpropvar[1].uiVal = 3;
rgosz[1] = OLESTR("www.microsoft.com/test/ui2");
Check( S_OK, pbagX->WriteMultiple( 2, rgosz, rgpropvar ));
g_pfnFreePropVariantArray( 2, rgpropvar );
// Read back the properties as (U)I4s with explicit coercion
rgpropvar[0].vt = VT_I4;
rgpropvar[1].vt = VT_UI4;
Check( S_OK, pbagX->ReadMultiple( 2, rgosz, rgpropvar, NULL ));
Check( TRUE, VT_I4 == rgpropvar[0].vt && 2 == rgpropvar[0].lVal );
Check( TRUE, VT_UI4 == rgpropvar[1].vt && 3 == rgpropvar[1].ulVal );
// This is an unrelated test, but while we're here, let's verify that we
// can't write a PropVariant (non-Variant) type through the Bag interface.
rgpropvar[0].vt= VT_I8;
rgpropvar[0].hVal.QuadPart = 1;
Check( STG_E_INVALIDPARAMETER, pbag->Write( rgosz[0],
reinterpret_cast<VARIANT*>(&rgpropvar[0]) ));
//--------
rgpropvar[0].vt = VT_LPSTR;
rgpropvar[0].pszVal = "Hello, world";
rgpropvar[1].vt = VT_I4;
rgpropvar[1].iVal = 123;
Check( S_OK, pbagX->WriteMultiple( 2, rgosz, rgpropvar ));
rgpropvar[0].vt = VT_EMPTY;
rgpropvar[0].pszVal = NULL;
rgpropvar[1].vt = VT_EMPTY;
rgpropvar[1].iVal = -1;
Check( S_OK, pbagX->ReadMultiple( 2, rgosz, rgpropvar, NULL ));
Check( TRUE, VT_LPSTR == rgpropvar[0].vt
&& 0==strcmp( "Hello, world", rgpropvar[0].pszVal ) );
Check( TRUE, VT_I4 == rgpropvar[1].vt && 123 == rgpropvar[1].iVal );
g_pfnFreePropVariantArray( 2, rgpropvar );
//-------- Coercing Variant to Variant ------------------
rgpropvar[0].vt = VT_I4;
rgpropvar[0].lVal = 123;
rgpropvar[1].vt = VT_I4;
rgpropvar[1].lVal = 123;
Check( S_OK, pbagX->WriteMultiple( 2, rgosz, rgpropvar ));
rgpropvar[0].vt = VT_BSTR;
rgpropvar[1].vt = VT_I4;
Check( S_OK, pbagX->ReadMultiple( 2, rgosz, rgpropvar, NULL ));
Check( TRUE, VT_BSTR == rgpropvar[0].vt
&& !wcscmp( L"123", rgpropvar[0].bstrVal ));
Check( TRUE, VT_I4 == rgpropvar[1].vt && 123 == rgpropvar[1].iVal );
g_pfnFreePropVariantArray( 2, rgpropvar );
//-------- Coercing PropVariant To PropVariant ------------
#define TEST_I8_VAL ((LONGLONG)1024*1000*1000*1000+42);
rgpropvar[0].vt = VT_LPWSTR;
rgpropvar[0].pwszVal = L"-312";
rgpropvar[1].vt = VT_I8;
rgpropvar[1].hVal.QuadPart = TEST_I8_VAL;
Check( S_OK, pbagX->WriteMultiple( 2, rgosz, rgpropvar ));
rgpropvar[0].vt = VT_I4;
rgpropvar[0].pszVal = NULL;
rgpropvar[1].vt = VT_LPWSTR;
rgpropvar[1].hVal.QuadPart = -1;
Check( S_OK, pbagX->ReadMultiple(2, rgosz, rgpropvar, NULL ) );
Check( TRUE, VT_I4 == rgpropvar[0].vt && -312 == rgpropvar[0].lVal );
Check( TRUE, VT_LPWSTR == rgpropvar[1].vt
&& !wcscmp( L"1024000000042", rgpropvar[1].pwszVal ) );
g_pfnFreePropVariantArray( 2, rgpropvar );
//-------- Implcit Coercion PropVariant To Variant ------------
rgpropvar[0].vt = VT_I8;
rgpropvar[0].hVal.QuadPart = -666;
rgpropvar[1].vt = VT_VECTOR | VT_LPSTR;
rgpropvar[1].calpstr.cElems = 5;
rgpropvar[1].calpstr.pElems = new LPSTR[5];
rgpropvar[1].calpstr.pElems[0] = "Thirty Days hath September,";
rgpropvar[1].calpstr.pElems[1] = "April, June and No Wonder?";
rgpropvar[1].calpstr.pElems[2] = "All the Rest Have Thirty One";
rgpropvar[1].calpstr.pElems[3] = "Except my dear Grand Mother.";
rgpropvar[1].calpstr.pElems[4] = "She Has a Bright Red Tricycle.";
Check( S_OK, pbagX->WriteMultiple( 2, rgosz, rgpropvar ));
delete rgpropvar[1].calpstr.pElems;
PropVariantInit(&rgpropvar[0]);
PropVariantInit(&rgpropvar[1]);
rgpropvar[0].vt = VT_EMPTY;
rgpropvar[1].vt = VT_EMPTY;
Check( S_OK, pbag->Read(rgosz[0], (VARIANT*)&rgpropvar[0], NULL ) );
Check( S_OK, pbag->Read(rgosz[1], (VARIANT*)&rgpropvar[1], NULL ) );
Check( TRUE, VT_I4 == rgpropvar[0].vt && -666 == rgpropvar[0].lVal );
Check( TRUE, (VT_BSTR|VT_ARRAY) == rgpropvar[1].vt );
g_pfnFreePropVariantArray( 2, rgpropvar );
//
// UnCoercible.
//
rgpropvar[0].vt = VT_UNKNOWN;
rgpropvar[0].iVal = 42; // GARBAGE value; untouched in the error path
Check( DISP_E_TYPEMISMATCH, pbagX->ReadMultiple( 1, rgosz, rgpropvar, NULL ));
Check( TRUE, VT_UNKNOWN == rgpropvar[0].vt && 42==rgpropvar[0].iVal );
RELEASE_INTERFACE(pbagX);
RELEASE_INTERFACE(pbag);
} // test_BagCoercion
#define LOAD_VARIANT(var,vartype,field,value) (var).field = (value); (var).vt = vartype
void
test_ByRef( IStorage *pstg )
{
HRESULT hr = S_OK;
IPropertySetStorage *pPropSetStg = NULL;
IPropertyStorage *pPropStg = NULL;
FMTID fmtid;
Status( "ByRef Variants\n" );
UuidCreate( &fmtid );
Check( S_OK, pstg->QueryInterface( IID_IPropertySetStorage, reinterpret_cast<void**>(&pPropSetStg) ));
Check( S_OK, pPropSetStg->Create( fmtid, NULL, PROPSETFLAG_DEFAULT,
STGM_CREATE|STGM_READWRITE|STGM_SHARE_EXCLUSIVE,
&pPropStg ));
PROPVARIANT rgvarWrite[17], rgvarRead[17];
CPropSpec rgcpropspec[17];
BYTE bVal = 1;
LOAD_VARIANT(rgvarWrite[0], VT_UI1|VT_BYREF, pbVal, &bVal);
rgcpropspec[0] = OLESTR("VT_UI1|VT_BYREF");
SHORT iVal = 2;
LOAD_VARIANT(rgvarWrite[1], VT_I2|VT_BYREF, piVal, &iVal );
rgcpropspec[1] = OLESTR("VT_I2|VY_BYREF");
LONG lVal = 3;
LOAD_VARIANT(rgvarWrite[2], VT_I4|VT_BYREF, plVal, &lVal );
rgcpropspec[2] = OLESTR("VT_I4|VY_BYREF");
FLOAT fltVal = (float)4.1;
LOAD_VARIANT(rgvarWrite[3], VT_R4|VT_BYREF, pfltVal, &fltVal );
rgcpropspec[3] = OLESTR("VT_I4|VT_BYREF");
DOUBLE dblVal = 5.2;
LOAD_VARIANT(rgvarWrite[4], VT_R8|VT_BYREF, pdblVal, &dblVal );
rgcpropspec[4] = OLESTR("VT_R8|VT_BYREF");
VARIANT_BOOL boolVal = VARIANT_TRUE;
LOAD_VARIANT(rgvarWrite[5], VT_BOOL|VT_BYREF, pboolVal, &boolVal );
rgcpropspec[5] = OLESTR("VT_BOOL|VT_BYREF");
SCODE scode = 6;
LOAD_VARIANT(rgvarWrite[6], VT_ERROR|VT_BYREF, pscode, &scode );
rgcpropspec[6] = OLESTR("VT_ERROR|VT_BYREF");
CY cyVal = { 7 };
LOAD_VARIANT(rgvarWrite[7], VT_CY|VT_BYREF, pcyVal, &cyVal );
rgcpropspec[7] = OLESTR("VT_CY|VT_BYREF");
DATE date = 8;
LOAD_VARIANT(rgvarWrite[8], VT_DATE|VT_BYREF, pdate, &date );
rgcpropspec[8] = OLESTR("VT_DATE|VT_BYREF");
BSTR bstrVal = SysAllocString( OLESTR("9") );
LOAD_VARIANT(rgvarWrite[9], VT_BSTR|VT_BYREF, pbstrVal, &bstrVal );
rgcpropspec[9] = OLESTR("VT_BSTR|VT_BYREF");
DECIMAL decVal = { 10, 9, 8, 7, 6 };
LOAD_VARIANT(rgvarWrite[10], VT_DECIMAL|VT_BYREF, pdecVal, &decVal );
rgcpropspec[10] = OLESTR("VT_DECIMAL|VT_BYREF");
CHAR cVal = 11;
LOAD_VARIANT(rgvarWrite[11], VT_I1 | VT_BYREF, pcVal, &cVal );
rgcpropspec[11] = OLESTR("VT_I1|VT_BYREF");
USHORT uiVal = 12;
LOAD_VARIANT(rgvarWrite[12], VT_UI2 | VT_BYREF, puiVal, &uiVal );
rgcpropspec[12] = OLESTR("VT_UI2|VT_BYREF");
ULONG ulVal = 13;
LOAD_VARIANT(rgvarWrite[13], VT_UI4 | VT_BYREF, pulVal, &ulVal );
rgcpropspec[13] = OLESTR("VT_UI4|VT_BYREF");
INT intVal = 14;
LOAD_VARIANT(rgvarWrite[14], VT_INT | VT_BYREF, pintVal, &intVal );
rgcpropspec[14] = OLESTR("VT_INT|VT_BYREF");
UINT uintVal = 15;
LOAD_VARIANT(rgvarWrite[15], VT_UINT | VT_BYREF, puintVal, &uintVal );
rgcpropspec[15] = OLESTR("VT_UINT | VT_BYREF");
CPropVariant cpropvarVal = (long) 16;
Check( VT_I4, cpropvarVal.vt );
LOAD_VARIANT(rgvarWrite[16], VT_VARIANT| VT_BYREF, pvarVal, &cpropvarVal );
rgcpropspec[16] = OLESTR("VT_VARIANT | VT_BYREF");
Check( S_OK, pPropStg->WriteMultiple( sizeof(rgvarWrite)/sizeof(rgvarWrite[0]),
rgcpropspec,
reinterpret_cast<PROPVARIANT*>(rgvarWrite),
PID_FIRST_USABLE ));
for( int i = 0; i < sizeof(rgvarRead)/sizeof(rgvarRead[0]); i++ )
PropVariantInit( &rgvarRead[i] );
Check( S_OK, pPropStg->ReadMultiple( sizeof(rgvarRead)/sizeof(rgvarRead[0]),
rgcpropspec,
reinterpret_cast<PROPVARIANT*>(rgvarRead) ));
Check( VT_UI1, rgvarRead[0].vt );
Check( TRUE, rgvarRead[0].bVal == *rgvarWrite[0].pbVal );
Check( VT_I2, rgvarRead[1].vt );
Check( TRUE, rgvarRead[1].iVal == *rgvarWrite[1].piVal );
Check( VT_I4, rgvarRead[2].vt );
Check( TRUE, rgvarRead[2].lVal == *rgvarWrite[2].plVal );
Check( VT_R4, rgvarRead[3].vt );
Check( TRUE, rgvarRead[3].fltVal == *rgvarWrite[3].pfltVal );
Check( VT_R8, rgvarRead[4].vt );
Check( TRUE, rgvarRead[4].dblVal == *rgvarWrite[4].pdblVal );
Check( VT_BOOL, rgvarRead[5].vt );
Check( TRUE, rgvarRead[5].boolVal == *rgvarWrite[5].pboolVal );
Check( VT_ERROR, rgvarRead[6].vt );
Check( TRUE, rgvarRead[6].scode == *rgvarWrite[6].pscode );
Check( VT_CY, rgvarRead[7].vt );
Check( 0, memcmp( &rgvarRead[7].cyVal, rgvarWrite[7].pcyVal, sizeof(CY) ));
Check( VT_DATE, rgvarRead[8].vt );
Check( TRUE, rgvarRead[8].date == *rgvarWrite[8].pdate );
Check( VT_BSTR, rgvarRead[9].vt );
Check( 0, ocscmp( rgvarRead[9].bstrVal, *rgvarWrite[9].pbstrVal ));
Check( VT_DECIMAL, rgvarRead[10].vt );
Check( 0, memcmp( &rgvarRead[10].decVal.scale, &rgvarWrite[10].pdecVal->scale,
sizeof(decVal) - sizeof(decVal.wReserved) ));
Check( VT_I1, rgvarRead[11].vt );
Check( TRUE, rgvarRead[11].cVal == *rgvarWrite[11].pcVal );
Check( VT_UI2, rgvarRead[12].vt );
Check( TRUE, rgvarRead[12].uiVal == *rgvarWrite[12].puiVal );
Check( VT_UI4, rgvarRead[13].vt );
Check( TRUE, rgvarRead[13].ulVal == *rgvarWrite[13].pulVal );
Check( VT_INT, rgvarRead[14].vt );
Check( TRUE, rgvarRead[14].intVal == *rgvarWrite[14].pintVal );
Check( VT_UINT, rgvarRead[15].vt );
Check( TRUE, rgvarRead[15].uintVal == *rgvarWrite[15].puintVal );
Check( VT_I4, rgvarRead[16].vt );
Check( TRUE, rgvarRead[16].lVal == rgvarWrite[16].pvarVal->lVal );
Check( 0, RELEASE_INTERFACE(pPropStg) );
RELEASE_INTERFACE(pPropSetStg);
g_pfnFreePropVariantArray( sizeof(rgvarRead)/sizeof(rgvarRead[0]), rgvarRead );
SysFreeString( bstrVal );
}
void
test_SettingLocalization( IStorage *pstg )
{
HRESULT hr = S_OK;
IPropertySetStorage *pPropSetStg = NULL;
IPropertyStorage *pPropStg = NULL;
FMTID fmtid;
CPropVariant rgcpropvarWrite[3], rgcpropvarRead[3];
CPropSpec rgcpropspec[3];
ULONG cRefsOriginal = GetRefCount( pstg );
Status( "Changing localization properties\n" );
UuidCreate( &fmtid );
Check( S_OK, pstg->QueryInterface( IID_IPropertySetStorage, reinterpret_cast<void**>(&pPropSetStg) ));
for( int i = 0; i < 2; i++ )
{
// Create a unicode or ansi property set
Check( S_OK, pPropSetStg->Create( fmtid, NULL,
0 == i ? PROPSETFLAG_DEFAULT : PROPSETFLAG_ANSI,
STGM_CREATE|STGM_READWRITE|STGM_SHARE_EXCLUSIVE,
&pPropStg ));
// ---------------------------
// Change the codepage to Ansi
// ---------------------------
// Set the codepage. This should work because it's currently empty
// (note that it's also currently Unicode). Set it to GetACP+1 just
// to be sure that we can set a non-default codepage.
rgcpropspec[0] = PID_CODEPAGE;
rgcpropvarWrite[0] = (short) (GetACP() + 1);
Check( S_OK, pPropStg->WriteMultiple( 1, rgcpropspec, rgcpropvarWrite, PID_FIRST_USABLE ));
Check( S_OK, pPropStg->ReadMultiple( 1, rgcpropspec, rgcpropvarRead ));
Check( TRUE, rgcpropvarWrite[0] == rgcpropvarRead[0] );
// Now set the codepage to GetACP so that we can work on it.
rgcpropvarWrite[0] = (short) GetACP();
Check( S_OK, pPropStg->WriteMultiple( 1, rgcpropspec, rgcpropvarWrite, PID_FIRST_USABLE ));
Check( S_OK, pPropStg->ReadMultiple( 1, rgcpropspec, rgcpropvarRead ));
Check( TRUE, rgcpropvarWrite[0] == rgcpropvarRead[0] );
// Write some named properties. The VT_LPSTR shouldn't get converted to Unicode
// now that this is an Ansi property set.
rgcpropvarWrite[0] = "Hello, world";
rgcpropvarWrite[1].SetBSTR( OLESTR("How are you?") );
rgcpropspec[0] = PID_FIRST_USABLE;
rgcpropspec[1] = OLESTR("Second property name");
Check( S_OK, pPropStg->WriteMultiple( 2, rgcpropspec, rgcpropvarWrite, PID_FIRST_USABLE ));
Check( S_OK, pPropStg->ReadMultiple( 2, rgcpropspec, rgcpropvarRead ));
Check( TRUE, rgcpropvarWrite[0] == rgcpropvarRead[0] );
Check( TRUE, rgcpropvarWrite[1] == rgcpropvarRead[1] );
g_pfnFreePropVariantArray( 2, rgcpropvarRead );
// If we stat the IPropertyStorage, it should call itself Ansi.
STATPROPSETSTG statpropsetstg;
Check( S_OK, pPropStg->Stat( &statpropsetstg ));
Check( PROPSETFLAG_ANSI, PROPSETFLAG_ANSI & statpropsetstg.grfFlags );
// Verify that we can close and re-open it and everything's still the same.
Check( 0, RELEASE_INTERFACE(pPropStg) );
Check( S_OK, pPropSetStg->Open( fmtid, STGM_READWRITE|STGM_SHARE_EXCLUSIVE, &pPropStg ));
Check( S_OK, pPropStg->ReadMultiple( 2, rgcpropspec, rgcpropvarRead ));
Check( TRUE, rgcpropvarWrite[0] == rgcpropvarRead[0] );
Check( TRUE, rgcpropvarWrite[1] == rgcpropvarRead[1] );
g_pfnFreePropVariantArray( 2, rgcpropvarRead );
Check( S_OK, pPropStg->Stat( &statpropsetstg ));
Check( PROPSETFLAG_ANSI, PROPSETFLAG_ANSI & statpropsetstg.grfFlags );
// ------------------------------
// Change the codepage to Unicode
// ------------------------------
// Clear out the property set.
PROPID propidDictionary = PID_DICTIONARY;
Check( S_OK, pPropStg->DeleteMultiple( 2, rgcpropspec ));
Check( S_OK, pPropStg->DeletePropertyNames( 1, &propidDictionary ));
// Switch to Unicode
rgcpropvarWrite[0] = (short) CP_WINUNICODE;
rgcpropspec[0] = PID_CODEPAGE;
Check( S_OK, pPropStg->WriteMultiple( 1, rgcpropspec, rgcpropvarWrite, PID_FIRST_USABLE ));
Check( S_OK, pPropStg->ReadMultiple( 1, rgcpropspec, rgcpropvarRead ));
Check( TRUE, rgcpropvarRead[0] == rgcpropvarWrite[0] );
// Verify with a Stat
Check( S_OK, pPropStg->Stat( &statpropsetstg ));
Check( 0, PROPSETFLAG_ANSI & statpropsetstg.grfFlags );
// Write & read some properties again. This time the LPSTR should be converted.
rgcpropvarWrite[0] = "Hello, world";
rgcpropvarWrite[1].SetBSTR( OLESTR("How are you?") );
rgcpropspec[0] = PID_FIRST_USABLE;
rgcpropspec[1] = OLESTR("Second property name");
Check( S_OK, pPropStg->WriteMultiple( 2, rgcpropspec, rgcpropvarWrite, PID_FIRST_USABLE ));
Check( S_OK, pPropStg->ReadMultiple( 2, rgcpropspec, rgcpropvarRead ));
Check( TRUE, rgcpropvarWrite[0] == rgcpropvarRead[0] );
Check( TRUE, rgcpropvarWrite[1] == rgcpropvarRead[1] );
g_pfnFreePropVariantArray( 2, rgcpropvarRead );
// Close, reopen, and read/stat again
Check( 0, RELEASE_INTERFACE(pPropStg) );
Check( S_OK, pPropSetStg->Open( fmtid, STGM_READWRITE|STGM_SHARE_EXCLUSIVE, &pPropStg ));
Check( S_OK, pPropStg->ReadMultiple( 2, rgcpropspec, rgcpropvarRead ));
Check( TRUE, rgcpropvarWrite[0] == rgcpropvarRead[0] );
Check( TRUE, rgcpropvarWrite[1] == rgcpropvarRead[1] );
g_pfnFreePropVariantArray( 2, rgcpropvarRead );
Check( S_OK, pPropStg->Stat( &statpropsetstg ));
Check( 0, PROPSETFLAG_ANSI & statpropsetstg.grfFlags );
Check( 0, RELEASE_INTERFACE(pPropStg) );
} // for( int i = 0; i < 2; i++ )
// -----------------------
// Validate error checking
// -----------------------
// Create a new property set
Check( S_OK, pPropSetStg->Create( fmtid, NULL,
0 == i ? PROPSETFLAG_DEFAULT : PROPSETFLAG_ANSI,
STGM_CREATE|STGM_READWRITE|STGM_SHARE_EXCLUSIVE,
&pPropStg ));
// After writing a property, we shouldn't be able to set the codepage or LCID
rgcpropspec[0] = PID_FIRST_USABLE;
rgcpropvarWrite[0] = (long) 1234;
Check( S_OK, pPropStg->WriteMultiple( 1, rgcpropspec, rgcpropvarWrite, PID_FIRST_USABLE ));
rgcpropspec[0] = PID_CODEPAGE;
rgcpropvarWrite[0] = (short) 1234;
Check( STG_E_INVALIDPARAMETER, pPropStg->WriteMultiple( 1, rgcpropspec, rgcpropvarWrite, PID_FIRST_USABLE ));
rgcpropspec[0] = PID_LOCALE;
rgcpropvarWrite[0] = (ULONG) 5678;
Check( STG_E_INVALIDPARAMETER, pPropStg->WriteMultiple( 1, rgcpropspec, rgcpropvarWrite, PID_FIRST_USABLE ));
// But it's settable after deleting the property
rgcpropspec[0] = PID_FIRST_USABLE;
Check( S_OK, pPropStg->DeleteMultiple( 1, rgcpropspec ));
rgcpropspec[0] = PID_CODEPAGE;
rgcpropvarWrite[0] = (short) 1234;
Check( S_OK, pPropStg->WriteMultiple( 1, rgcpropspec, rgcpropvarWrite, PID_FIRST_USABLE ));
rgcpropspec[1] = PID_LOCALE;
rgcpropvarWrite[1] = (ULONG) 5678;
Check( S_OK, pPropStg->WriteMultiple( 1, &rgcpropspec[1], &rgcpropvarWrite[1], PID_FIRST_USABLE ));
Check( S_OK, pPropStg->WriteMultiple( 2, rgcpropspec, rgcpropvarWrite, PID_FIRST_USABLE ));
Check( S_OK, pPropStg->ReadMultiple(2, rgcpropspec, rgcpropvarRead ));
Check( TRUE, rgcpropvarWrite[0] == rgcpropvarRead[0] );
Check( TRUE, rgcpropvarWrite[1] == rgcpropvarRead[1] );
// But again it's not writable if there's a name in the dictionary
rgcpropspec[0] = PID_CODEPAGE;
rgcpropvarWrite[0] = (short) CP_WINUNICODE;
Check( S_OK, pPropStg->WriteMultiple( 1, rgcpropspec, rgcpropvarWrite, PID_FIRST_USABLE ));
PROPID rgpropid[1] = { PID_FIRST_USABLE };
LPOLESTR rglposz[1] = { OLESTR("Hello") };
Check( S_OK, pPropStg->WritePropertyNames( 1, rgpropid, rglposz ));
Check( STG_E_INVALIDPARAMETER, pPropStg->WriteMultiple( 1, rgcpropspec, rgcpropvarWrite, PID_FIRST_USABLE ));
Check( 0, RELEASE_INTERFACE(pPropStg) );
Check( cRefsOriginal, RELEASE_INTERFACE(pPropSetStg) );
}
void
test_ExtendedTypes( IStorage *pstg )
{
HRESULT hr = S_OK;
IPropertySetStorage *pPropSetStg = NULL;
IPropertyStorage *pPropStg = NULL;
FMTID fmtid;
Status( "Extended Types\n" );
UuidCreate( &fmtid );
Check( S_OK, pstg->QueryInterface( IID_IPropertySetStorage, reinterpret_cast<void**>(&pPropSetStg) ));
Check( S_OK, pPropSetStg->Create( fmtid, NULL, PROPSETFLAG_DEFAULT,
STGM_CREATE|STGM_READWRITE|STGM_SHARE_EXCLUSIVE,
&pPropStg ));
CPropVariant rgcpropvarWrite[5], rgcpropvarRead[5];
CPropSpec rgcpropspec[5];
rgcpropvarWrite[0] = (CHAR) 1;
rgcpropspec[0] = OLESTR("VT_I1");
DECIMAL decVal = { 10, 9, 8, 7, 6 };
rgcpropvarWrite[1] = decVal;
rgcpropspec[1] = OLESTR("VT_DECIMAL");
rgcpropvarWrite[2].SetINT( 2 );
rgcpropspec[2] = OLESTR("VT_INT");
rgcpropvarWrite[3].SetUINT( 3 );
rgcpropspec[3] = OLESTR("VT_UINT");
rgcpropvarWrite[4][1] = (CHAR) 2;
rgcpropvarWrite[4][0] = (CHAR) 1;
rgcpropspec[4] = OLESTR("VT_VECTOR|VT_I1");
Check( S_OK, pPropStg->WriteMultiple( sizeof(rgcpropvarWrite)/sizeof(rgcpropvarWrite[0]),
rgcpropspec, rgcpropvarWrite, PID_FIRST_USABLE ));
for( int i = 0; i < sizeof(rgcpropvarRead)/sizeof(rgcpropvarRead[0]); i++ )
PropVariantInit( &rgcpropvarRead[i] );
CheckFormatVersion(pPropStg, PROPSET_WFORMAT_EXPANDED_VTS);
Check( S_OK, pPropStg->ReadMultiple( sizeof(rgcpropvarRead)/sizeof(rgcpropvarRead[0]),
rgcpropspec,
reinterpret_cast<PROPVARIANT*>(rgcpropvarRead) ));
Check( rgcpropvarRead[0].vt, rgcpropvarWrite[0].vt );
Check( TRUE, rgcpropvarWrite[0].cVal == rgcpropvarRead[0].cVal );
Check( rgcpropvarRead[1].vt, rgcpropvarWrite[1].vt );
Check( 0, memcmp( &rgcpropvarRead[1].decVal.scale, &rgcpropvarWrite[1].decVal.scale,
sizeof(rgcpropvarRead[1].decVal) - sizeof(rgcpropvarRead[1].decVal.wReserved) ));
Check( rgcpropvarRead[2].vt, rgcpropvarWrite[2].vt );
Check( rgcpropvarRead[2].intVal, rgcpropvarWrite[2].intVal );
Check( rgcpropvarRead[3].vt, rgcpropvarWrite[3].vt );
Check( rgcpropvarRead[3].uintVal, rgcpropvarWrite[3].uintVal );
Check( TRUE, rgcpropvarRead[4] == rgcpropvarWrite[4] );
Check( 0, RELEASE_INTERFACE(pPropStg) );
RELEASE_INTERFACE(pPropSetStg);
}
void
test_StgOnHandle( OLECHAR *poszDir )
{
HRESULT hr = S_OK;
OLECHAR oszFile[ MAX_PATH ], oszDir[ MAX_PATH ];
CPropVariant cpropvarWrite, cpropvarRead;
HANDLE hFile = INVALID_HANDLE_VALUE;
HANDLE hDir = INVALID_HANDLE_VALUE;
IPropertyBagEx *pbag = NULL;
Status( "StgOpenStorageOnHandle\n" );
ocscpy( oszFile, poszDir );
ocscat( oszFile, OLESTR("test_StgOnHandle") );
ocscpy( oszDir, poszDir );
ocscat( oszDir, OLESTR("test_StgOnHandle Dir") );
// Create a storage and put a property in it.
Check( S_OK, g_pfnStgCreateStorageEx( oszFile, STGM_CREATE|STGM_SHARE_EXCLUSIVE|STGM_READWRITE,
DetermineStgFmt( g_enumImplementation ),
0, NULL, NULL,
IID_IPropertyBagEx, reinterpret_cast<void**>(&pbag) ));
OLECHAR *poszPropName = OLESTR("Prop Name");
cpropvarWrite = (long) 123; // VT_I4
Check( S_OK, pbag->WriteMultiple( 1, &poszPropName, &cpropvarWrite ));
Check( 0, RELEASE_INTERFACE(pbag) );
// Create a directory and put a property in it too.
Check( TRUE, CreateDirectory( oszDir, NULL ));
hDir = CreateFile( oszDir, GENERIC_READ|GENERIC_WRITE, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, INVALID_HANDLE_VALUE );
Check( TRUE, INVALID_HANDLE_VALUE != hDir );
Check( S_OK, g_pfnStgOpenStorageOnHandle( hDir, STGM_READWRITE|STGM_SHARE_EXCLUSIVE,
NULL, NULL,
IID_IPropertyBagEx, reinterpret_cast<void**>(&pbag) ));
CloseHandle( hDir );
Check( S_OK, pbag->WriteMultiple( 1, &poszPropName, &cpropvarWrite ));
Check( 0, RELEASE_INTERFACE(pbag) );
// Open the file and read the properties
hFile = CreateFile( oszFile, GENERIC_READ|GENERIC_WRITE, 0,
NULL, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL );
Check( TRUE, INVALID_HANDLE_VALUE != hFile );
Check( S_OK, g_pfnStgOpenStorageOnHandle( hFile, STGM_READWRITE|STGM_SHARE_EXCLUSIVE,
NULL, NULL,
IID_IPropertyBagEx, reinterpret_cast<void**>(&pbag) ));
CloseHandle( hFile );
PropVariantClear( &cpropvarRead );
Check( S_OK, pbag->ReadMultiple( 1, &poszPropName, &cpropvarRead, NULL ));
Check( TRUE, cpropvarRead == cpropvarWrite );
Check( 0, RELEASE_INTERFACE(pbag) );
// Open the directory and read the properties
hFile = CreateFile( oszDir, GENERIC_READ|GENERIC_WRITE, 0,
NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL );
Check( TRUE, INVALID_HANDLE_VALUE != hFile );
Check( S_OK, g_pfnStgOpenStorageOnHandle( hFile, STGM_READWRITE|STGM_SHARE_EXCLUSIVE,
NULL, NULL,
IID_IPropertyBagEx, reinterpret_cast<void**>(&pbag) ));
CloseHandle( hFile );
PropVariantClear( &cpropvarRead );
Check( S_OK, pbag->ReadMultiple( 1, &poszPropName, &cpropvarRead, NULL ));
Check( TRUE, cpropvarRead == cpropvarWrite );
Check( 0, RELEASE_INTERFACE(pbag) );
}
void
test_PropsetOnEmptyFile( OLECHAR *poszDir )
{
HRESULT hr = S_OK;
OLECHAR oszFile[ MAX_PATH ];
CPropVariant cpropvarWrite, cpropvarRead;
HANDLE hFile = INVALID_HANDLE_VALUE;
IPropertySetStorage *pset = NULL;
// We only run this test for NFF property sets; there's special code there
// for the case of a read-only open of an empty file.
if( PROPIMP_NTFS != g_enumImplementation ) return;
Status( "Empty file\n" );
ocscpy( oszFile, poszDir );
ocscat( oszFile, OLESTR("test_PropsetOnEmptyFile") );
// Create a file
hFile = CreateFile( oszFile, GENERIC_READ|GENERIC_WRITE, 0,
NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, INVALID_HANDLE_VALUE );
Check( FALSE, INVALID_HANDLE_VALUE == hFile );
CloseHandle( hFile );
// Get a read-only property interface on the file.
Check( S_OK, StgOpenStorageEx( oszFile, STGM_READ|STGM_SHARE_DENY_WRITE,
STGFMT_ANY, 0, NULL, NULL,
IID_IPropertySetStorage,
reinterpret_cast<void**>(&pset) ));
Check( 0, RELEASE_INTERFACE(pset) );
}
void
test_PropsetOnHGlobal()
{
HANDLE hglobal = NULL;
IPropertyStorage *pPropStg = NULL;
IStream *pStm = NULL;
Status( "StgCreate/OpenPropStg on CreateStreamOnHGlobal\n" );
// Build up an IPropertyStorage on a memory block
hglobal = GlobalAlloc( GHND, 0 );
Check( FALSE, NULL == hglobal );
Check( S_OK, CreateStreamOnHGlobal( hglobal, FALSE, &pStm ));
hglobal = NULL;
Check( S_OK, StgCreatePropStg( (IUnknown*) pStm, FMTID_NULL, &CLSID_NULL,
PROPSETFLAG_DEFAULT,
0L, // Reserved
&pPropStg ));
// Write a Unicode string property to the property set
CPropVariant rgcpropvarWrite[2] = { L"First Value", L"Second Value" };
CPropSpec rgcpropspec[2] = { L"First Name", L"Second Name" };
Check( S_OK, pPropStg->WriteMultiple( 1, &rgcpropspec[0], &rgcpropvarWrite[0], PID_FIRST_USABLE ));
// Close the IPropertyStorage and IStream.
Check( S_OK, pPropStg->Commit( STGC_DEFAULT )); // Flush to pStm
Check( 0, RELEASE_INTERFACE(pPropStg) );
Check( S_OK, GetHGlobalFromStream( pStm, &hglobal ));
Check( 0, RELEASE_INTERFACE(pStm) );
// Reopen everything
Check( S_OK, CreateStreamOnHGlobal( hglobal, FALSE, &pStm ));
hglobal = NULL;
Check( S_OK, StgOpenPropStg( (IUnknown*) pStm, FMTID_NULL,
PROPSETFLAG_DEFAULT,
0L, // Reserved
&pPropStg ));
// Write another property
Check( S_OK, pPropStg->WriteMultiple( 1, &rgcpropspec[1], &rgcpropvarWrite[1], PID_FIRST_USABLE ));
// Read and verify the properties
CPropVariant rgcpropvarRead[2];
Check( S_OK, pPropStg->ReadMultiple( 2, rgcpropspec, rgcpropvarRead ));
Check( TRUE, rgcpropvarRead[0] == rgcpropvarWrite[0] );
Check( TRUE, rgcpropvarRead[1] == rgcpropvarWrite[1] );
Check( 0, RELEASE_INTERFACE(pPropStg) );
Check( S_OK, GetHGlobalFromStream( pStm, &hglobal ));
Check( 0, RELEASE_INTERFACE(pStm) );
// Reopen everything using a read-only stream.
Check( S_OK, CreateStreamOnHGlobal( hglobal, TRUE, &pStm ));
hglobal = NULL;
CReadOnlyStream ReadOnlyStream( pStm );
Check( S_OK, StgOpenPropStg( (IUnknown*) &ReadOnlyStream, FMTID_NULL,
PROPSETFLAG_DEFAULT,
0L, // Reserved
&pPropStg ));
Check( STG_E_ACCESSDENIED, pPropStg->WriteMultiple( 1, &rgcpropspec[1],
&rgcpropvarWrite[1], PID_FIRST_USABLE ));
Check( 0, RELEASE_INTERFACE(pPropStg) );
Check( 0, RELEASE_INTERFACE(pStm) );
}
void
test_SafeArray( IStorage *pstg )
{
HRESULT hr = S_OK;
IPropertySetStorage *pPropSetStg = NULL;
IPropertyStorage *pPropStg = NULL;
FMTID fmtid;
ULONG crefpstg = 0;
Status( "SafeArrays\n" );
UuidCreate( &fmtid );
pstg->AddRef();
crefpstg = pstg->Release();
// Get an IPropertyStorage from the input IStorage
Check( S_OK, pstg->QueryInterface( IID_IPropertySetStorage, reinterpret_cast<void**>(&pPropSetStg) ));
Check( S_OK, pPropSetStg->Create( fmtid, NULL, PROPSETFLAG_DEFAULT,
STGM_CREATE|STGM_READWRITE|STGM_SHARE_EXCLUSIVE,
&pPropStg ));
SAFEARRAY *rgpsa[] = { NULL, NULL, NULL }; //, NULL, NULL };
CPropVariant *rgcpropvar = NULL;
SAFEARRAYBOUND rgsaBounds[] = { {2,0}, {3,10}, {4,20} }; // [0..1], [10..12], [20..23]
ULONG cDims = sizeof(rgsaBounds)/sizeof(rgsaBounds[0]);
ULONG cElems = 0;
// Create three SafeArrays to test a fixed sized type, a variable sized type
// (which is also ByRef), and a Variant.
rgpsa[0] = SafeArrayCreate( VT_I4, 3, rgsaBounds ); // Try both Create and CreateEx
Check( TRUE, NULL != rgpsa[0] );
rgpsa[1] = SafeArrayCreateEx( VT_BSTR, 3, rgsaBounds, NULL );
Check( TRUE, NULL != rgpsa[1] );
rgpsa[2] = SafeArrayCreateEx( VT_VARIANT, 3, rgsaBounds, NULL );
Check( TRUE, NULL != rgpsa[2] );
/*
rgpsa[3] = SafeArrayCreateEx( VT_I8, 3, rgsaBounds, NULL );
Check( TRUE, NULL != rgpsa[3] );
rgpsa[4] = SafeArrayCreateEx( VT_UI8, 3, rgsaBounds, NULL );
Check( TRUE, NULL != rgpsa[4] );
*/
// Determine how many elements are in the SafeArrays, and alloc that
// many PropVariants. We'll need this for the SafeArray of Variants.
cElems = CalcSafeArrayElementCount( rgpsa[0] );
rgcpropvar = new CPropVariant[ cElems ];
Check( FALSE, NULL == rgcpropvar );
// Fill in each of the SafeArrays.
for( ULONG i = 0; i < cElems; i++ )
{
LONG rgIndices[3];
// Map this this element from linear space to bounds space
CalcSafeArrayIndices( i, rgIndices, rgsaBounds, cDims );
// Add an I4
LONG lVal = static_cast<LONG>(i);
Check( S_OK, SafeArrayPutElement( rgpsa[0], rgIndices, &lVal ));
// Add a BSTR
BSTR bstrVal = SysAllocString( OLESTR("0 BSTR Val") );
*bstrVal = OLESTR('0') + static_cast<OLECHAR>(i);
Check( S_OK, SafeArrayPutElement( rgpsa[1], rgIndices, bstrVal ));
// Add a PropVariant that could be an I4 or a BSTR
if( i & 1 )
rgcpropvar[i] = (long) i;
else
rgcpropvar[i].SetBSTR( bstrVal ); // Copies string
Check( S_OK, SafeArrayPutElement( rgpsa[2], rgIndices, &rgcpropvar[i] ));
// The SafeArrays have copied the BSTR, so we can free our local copy
SysFreeString( bstrVal );
// Add I8/UI8
/*
LONGLONG llVal = i;
Check( S_OK, SafeArrayPutElement( rgpsa[3], rgIndices, &llVal ));
llVal += 1000;
Check( S_OK, SafeArrayPutElement( rgpsa[4], rgIndices, &llVal ));
*/
}
VARIANT rgvarWrite[3], rgvarRead[3];
PROPVARIANT rgpropvarCopy[3];
CPropSpec rgcpropspec[3];
// Load the SafeArrays into PropVariants
LOAD_VARIANT(rgvarWrite[0], VT_ARRAY|VT_I4, parray, rgpsa[0] );
rgcpropspec[0] = OLESTR("VT_ARRAY|VT_I4");
LOAD_VARIANT(rgvarWrite[1], VT_BYREF|VT_ARRAY|VT_BSTR, pparray, &rgpsa[1] );
rgcpropspec[1] = OLESTR("VT_BYREF|VT_ARRAY|VT_BSTR");
LOAD_VARIANT(rgvarWrite[2], VT_ARRAY|VT_VARIANT, parray, rgpsa[2] );
rgcpropspec[2] = OLESTR("VT_ARRAY|VT_VARIANT");
/*
LOAD_VARIANT(rgvarWrite[3], VT_ARRAY|VT_I8, parray, rgpsa[3] );
rgcpropspec[3] = OLESTR("VT_ARRAY|VT_I8");
LOAD_VARIANT(rgvarWrite[4], VT_ARRAY|VT_UI8, parray, rgpsa[4] );
rgcpropspec[4] = OLESTR("VT_ARRAY|VT_UI8");
*/
// Write the PropVariant SafeArrays and verify that the propset version in the
// header gets incremented.
Check( S_OK, pPropStg->WriteMultiple( sizeof(rgvarWrite)/sizeof(rgvarWrite[0]),
rgcpropspec,
reinterpret_cast<PROPVARIANT*>(rgvarWrite),
PID_FIRST_USABLE ));
CheckFormatVersion(pPropStg, PROPSET_WFORMAT_EXPANDED_VTS);
// Test PropVariantCopy by copying each of the PropVariants and comparing the result.
for( i = 0; i < sizeof(rgvarRead)/sizeof(rgvarRead[0]); i++ )
{
PropVariantInit( &rgpropvarCopy[i] );
Check( S_OK, g_pfnPropVariantCopy( &rgpropvarCopy[i], reinterpret_cast<PROPVARIANT*>(&rgvarWrite[i]) ));
Check( rgpropvarCopy[i].vt, rgvarWrite[i].vt );
if( VT_BYREF & rgpropvarCopy[i].vt )
CompareSafeArrays( *rgpropvarCopy[i].pparray, *rgvarWrite[i].pparray );
else
CompareSafeArrays( rgpropvarCopy[i].parray, rgvarWrite[i].parray );
// As long as we're looping, let's start init-ing the Read array too.
VariantInit( &rgvarRead[i] );
}
// Read back the values that we wrote.
Check( S_OK, pPropStg->ReadMultiple( sizeof(rgvarRead)/sizeof(rgvarRead[0]),
rgcpropspec,
reinterpret_cast<PROPVARIANT*>(rgvarRead) ));
// Validate the Read values. For the second one, the byref should no longer
// be set.
Check( rgvarWrite[0].vt, rgvarRead[0].vt );
CompareSafeArrays( rgvarWrite[0].parray, rgvarRead[0].parray );
Check( 0, rgvarRead[1].vt & VT_BYREF );
Check( rgvarWrite[1].vt, rgvarRead[1].vt|VT_BYREF );
CompareSafeArrays( *rgvarWrite[1].pparray, rgvarRead[1].parray );
Check( rgvarWrite[2].vt, rgvarRead[2].vt );
CompareSafeArrays( rgvarWrite[2].parray, rgvarRead[2].parray );
/*
Check( rgvarWrite[3].vt, rgvarRead[3].vt );
CompareSafeArrays( rgvarWrite[3].parray, rgvarRead[3].parray );
Check( rgvarWrite[4].vt, rgvarRead[4].vt );
CompareSafeArrays( rgvarWrite[4].parray, rgvarRead[4].parray );
*/
// Free the safearrays (they're in rgvarWrite, but we don't clear that).
Check( S_OK, SafeArrayDestroy( rgpsa[0] ));
Check( S_OK, SafeArrayDestroy( rgpsa[1] ));
Check( S_OK, SafeArrayDestroy( rgpsa[2] ));
/*
Check( S_OK, SafeArrayDestroy( rgpsa[3] ));
Check( S_OK, SafeArrayDestroy( rgpsa[4] ));
*/
Check( S_OK, g_pfnFreePropVariantArray( sizeof(rgpropvarCopy)/sizeof(rgpropvarCopy[0]),
reinterpret_cast<PROPVARIANT*>(rgpropvarCopy) ));
Check( S_OK, g_pfnFreePropVariantArray( sizeof(rgvarRead)/sizeof(rgvarRead[0]),
reinterpret_cast<PROPVARIANT*>(rgvarRead) ));
Check( S_OK, g_pfnFreePropVariantArray( cElems, rgcpropvar ));
// ------------------------------------------------------
// Verify that we can't write a safearray with a bad type
// ------------------------------------------------------
LONG rgIndices[] = { 0 };
VARIANT *pvar;
rgpsa[0] = SafeArrayCreateVector( VT_VARIANT, 0, 1 );
Check( TRUE, NULL != rgpsa[0] );
SafeArrayPtrOfIndex( rgpsa[0], rgIndices, reinterpret_cast<void**>(&pvar) );
pvar->vt = VT_STREAM;
rgcpropvar[0].vt = VT_ARRAY | VT_VARIANT;
rgcpropvar[0].parray = rgpsa[0];
rgpsa[0] = NULL;
// In NT5, this returned HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER), which was
// the error that StgConvertVariantToPropertyNoEH got from SafeArrayGetVartype.
// In Whistler, SafeArrayGetVartype is returning success, so the error doesn't
// get caught until the recursive call to StgConvertVariantToPropertyNoEH,
// which returns STATUS_INVALID_PARAMETER, which gets translated into
// STG_E_INVALIDPARAMETER.
Check( STG_E_INVALIDPARAMETER,
pPropStg->WriteMultiple( 1, rgcpropspec, rgcpropvar, PID_FIRST_USABLE ));
// Clear the propvar we just used (which also destroys the safearray)
Check( S_OK, g_pfnPropVariantClear( &rgcpropvar[0] ) );
Check( S_OK, pPropStg->WriteMultiple( 2, rgcpropspec, rgcpropvar, PID_FIRST_USABLE ));
Check( S_OK, g_pfnFreePropVariantArray( 2, rgcpropvar ));
Check( 0, RELEASE_INTERFACE(pPropStg) );
Check( crefpstg, RELEASE_INTERFACE(pPropSetStg) );
delete[] rgcpropvar;
}
void
test_ReadOnlyReservedProperties( IStorage *pStg )
{
IPropertySetStorage *pPropSetStg = NULL;
IPropertyStorage *pPropStg = NULL;
CPropVariant cpropvar = L"Property Value";
CPropSpec cpropspec;
FMTID fmtid;
ULONG cRefsOriginal = GetRefCount(pStg);
Status( "Read-only reserved PROPIDs\n" );
UuidCreate( &fmtid );
Check( S_OK, pStg->QueryInterface( IID_IPropertySetStorage, reinterpret_cast<void**>(&pPropSetStg) ));
Check( S_OK, pPropSetStg->Create( fmtid, NULL, PROPSETFLAG_DEFAULT,
STGM_CREATE|STGM_READWRITE|STGM_SHARE_EXCLUSIVE,
&pPropStg ));
cpropspec = PID_BEHAVIOR + 1;
Check( STG_E_INVALIDPARAMETER, pPropStg->WriteMultiple( 1, &cpropspec, &cpropvar, PID_FIRST_USABLE ));
cpropspec = PID_MAX_READONLY;
Check( STG_E_INVALIDPARAMETER, pPropStg->WriteMultiple( 1, &cpropspec, &cpropvar, PID_FIRST_USABLE ));
cpropspec = PID_MAX_READONLY + 1;
Check( S_OK, pPropStg->WriteMultiple( 1, &cpropspec, &cpropvar, PID_FIRST_USABLE ));
Check( 0, RELEASE_INTERFACE(pPropStg) );
Check( cRefsOriginal, RELEASE_INTERFACE(pPropSetStg) );
}
void
test_LowMemory( IStorage *pstg )
{
HRESULT hr = S_OK;
IPropertySetStorage *psetstg = NULL;
IPropertyStorage *ppropstg = NULL;
IStorageTest *ptest = NULL;
CPropSpec rgcpropspec[2];
CPropVariant rgcpropvarWrite[2], rgcpropvarRead[2];
int i;
Status( "Low-memory mapped stream code\n" );
Check( S_OK, pstg->QueryInterface( IID_IPropertySetStorage, reinterpret_cast<void**>(&psetstg) ));
for( i = 0; i < 2; i++ )
{
DWORD propsetflag = i == 0 ? PROPSETFLAG_DEFAULT : PROPSETFLAG_NONSIMPLE;
FMTID fmtid;
UuidCreate( &fmtid );
Check( S_OK, psetstg->Create( fmtid, NULL, propsetflag,
STGM_CREATE|STGM_READWRITE|STGM_SHARE_EXCLUSIVE,
&ppropstg ));
// Go into low-memory mode
hr = ppropstg->QueryInterface( IID_IStorageTest, reinterpret_cast<void**>(&ptest) );
if( SUCCEEDED(hr) )
hr = ptest->SimulateLowMemory( TRUE );
// IStorageTest isn't available in a free build. As of this writing
// it's not available in docfile.
if( E_NOINTERFACE == hr )
{
Status( " ... Partially skipping, IStorageTest not available\n" );
continue;
}
else
Check( S_OK, hr );
// Write and read properties
rgcpropspec[0] = OLESTR("First property");
rgcpropvarWrite[0] = "Hello, world";
rgcpropspec[1] = OLESTR("Second property");
rgcpropvarWrite[1] = "How are you?";
Check( S_OK, ppropstg->WriteMultiple( 2, rgcpropspec, rgcpropvarWrite, PID_FIRST_USABLE ));
Check( S_OK, ppropstg->ReadMultiple( 2, rgcpropspec, rgcpropvarRead ));
Check( TRUE, rgcpropvarWrite[0] == rgcpropvarRead[0] );
Check( TRUE, rgcpropvarWrite[1] == rgcpropvarRead[1] );
g_pfnFreePropVariantArray( 2, rgcpropvarRead );
// Write, commit, and read
g_pfnFreePropVariantArray( 2, rgcpropvarWrite );
rgcpropvarWrite[0] = CBlob( L"go blue" );
rgcpropvarWrite[1] = static_cast<CLSID>(fmtid);
Check( S_OK, ppropstg->WriteMultiple( 2, rgcpropspec, rgcpropvarWrite, PID_FIRST_USABLE ));
Check( S_OK, ppropstg->ReadMultiple( 2, rgcpropspec, rgcpropvarRead ));
Check( TRUE, rgcpropvarWrite[0] == rgcpropvarRead[0] );
Check( TRUE, rgcpropvarWrite[1] == rgcpropvarRead[1] );
g_pfnFreePropVariantArray( 2, rgcpropvarRead );
Check( S_OK, ppropstg->Commit( STGC_DEFAULT ));
Check( S_OK, ppropstg->ReadMultiple( 2, rgcpropspec, rgcpropvarRead ));
Check( TRUE, rgcpropvarWrite[0] == rgcpropvarRead[0] );
Check( TRUE, rgcpropvarWrite[1] == rgcpropvarRead[1] );
g_pfnFreePropVariantArray( 2, rgcpropvarRead );
// Write, close, reopen, and read
g_pfnFreePropVariantArray( 2, rgcpropvarWrite );
rgcpropvarWrite[0] = 0.1234;
rgcpropvarWrite[1] = CClipData("Hi");
Check( S_OK, ppropstg->WriteMultiple( 2, rgcpropspec, rgcpropvarWrite, PID_FIRST_USABLE ));
RELEASE_INTERFACE(ptest);
RELEASE_INTERFACE(ppropstg);
Check( S_OK, psetstg->Open( fmtid, STGM_READ|STGM_SHARE_EXCLUSIVE, &ppropstg ));
Check( S_OK, ppropstg->ReadMultiple( 2, rgcpropspec, rgcpropvarRead ));
Check( TRUE, rgcpropvarWrite[0] == rgcpropvarRead[0] );
Check( TRUE, rgcpropvarWrite[1] == rgcpropvarRead[1] );
g_pfnFreePropVariantArray( 2, rgcpropvarRead );
RELEASE_INTERFACE(ppropstg);
} // for( i = 0; i < 2; i++ )
//Exit:
RELEASE_INTERFACE(ptest);
RELEASE_INTERFACE(ppropstg);
RELEASE_INTERFACE(psetstg);
}
void
test_BagOpenMethod( IStorage *pstg )
{
HRESULT hr = S_OK;
IPropertyBagEx *pbag = NULL;
OLECHAR * rgoszDelete[2];
CPropVariant cpropvar;
PROPVARIANT propvar;
VERSIONEDSTREAM VersionedStream;
GUID guidVersion2;
OLECHAR *pwszName = { OLESTR("Versioned Stream") };
IUnknown *punk = NULL;
IStream *pstm = NULL;
CHAR rgbStreamDataWrite[50] = "Stream data";
CHAR rgbStreamDataRead[100];
ULONG cbRead;
STATSTG statstg;
Status( "IPropertyBagEx::Open\n" );
Check( S_OK, pstg->QueryInterface( IID_IPropertyBagEx, reinterpret_cast<void**>(&pbag) ));
// Create a VersionedStream
UuidCreate( &VersionedStream.guidVersion );
VersionedStream.pStream = NULL;
cpropvar = VersionedStream;
// Write the versioned stream (causing a stream to be created) and read it back.
Check( S_OK, pbag->WriteMultiple( 1, &pwszName, &cpropvar ));
cpropvar.Clear();
Check( S_OK, pbag->ReadMultiple( 1, &pwszName, &cpropvar, NULL ));
Check( TRUE, VT_VERSIONED_STREAM == cpropvar.VarType() && NULL != cpropvar.pVersionedStream->pStream );
// Put some data in the stream and release it.
Check( S_OK, cpropvar.pVersionedStream->pStream->Write( rgbStreamDataWrite, sizeof(rgbStreamDataWrite), NULL ));
cpropvar.Clear();
// Now read that VersionedStream, with the proper GUID
Check( S_OK, pbag->Open( NULL, pwszName, VersionedStream.guidVersion, 0, IID_IStream, &punk ));
Check( S_OK, punk->QueryInterface( IID_IStream, reinterpret_cast<void**>(&pstm) ));
// Verify the data.
Check( S_OK, pstm->Read( rgbStreamDataRead, sizeof(rgbStreamDataRead), &cbRead ));
Check( TRUE, cbRead == sizeof(rgbStreamDataWrite) );
Check( TRUE, 0 == strcmp( rgbStreamDataWrite, rgbStreamDataRead ));
RELEASE_INTERFACE(pstm);
RELEASE_INTERFACE(punk);
// Attempt to read the same VersionedStream with a bad GUID
UuidCreate( &guidVersion2 );
Check( STG_E_FILEALREADYEXISTS, pbag->Open( NULL, pwszName, guidVersion2, 0, IID_IStream, &punk ));
// Attempt with a bad guid again, but this time cause a new property to be created.
Check( S_OK, pbag->Open( NULL, pwszName, guidVersion2, OPENPROPERTY_OVERWRITE, IID_IStream, &punk ));
Check( S_OK, punk->QueryInterface( IID_IStream, reinterpret_cast<void**>(&pstm) ));
Check( S_OK, pstm->Stat( &statstg, STATFLAG_NONAME ));
Check( TRUE, CULargeInteger(0) == statstg.cbSize );
RELEASE_INTERFACE(pstm);
RELEASE_INTERFACE(punk);
// Show that we can overwrite an existing property of a different type, but only
// by setting the overwrite flag.
cpropvar = static_cast<long>(45);
Check( S_OK, pbag->WriteMultiple( 1, &pwszName, &cpropvar ));
Check( STG_E_FILEALREADYEXISTS, pbag->Open( NULL, pwszName, guidVersion2, 0, IID_IStream, &punk ));
Check( S_OK, pbag->Open( NULL, pwszName, guidVersion2, OPENPROPERTY_OVERWRITE, IID_IStream, &punk ));
RELEASE_INTERFACE(punk);
// Show that if a property doesn't exist, Open creates it.
Check( S_OK, pbag->DeleteMultiple( 1, &pwszName, 0 ));
PropVariantClear( &cpropvar );
Check( S_FALSE, pbag->ReadMultiple( 1, &pwszName, &cpropvar, NULL ));
Check( S_OK, pbag->Open( NULL, pwszName, guidVersion2, 0, IID_IStream, &punk ));
RELEASE_INTERFACE(punk);
RELEASE_INTERFACE(pbag);
} // test_BagOpenMethod
void
test_StandaloneAPIs( LPOLESTR ocsDir )
{
OLECHAR ocsFile[ MAX_PATH + 1 ];
FMTID fmtidStgPropStg, fmtidStgPropSetStg;
IStorage *pstg = NULL; //TSafeStorage< IStorage > pstg;
IStream *pstmInMemory = NULL;
IStorage *pstgInMemory = NULL;
IPropertySetStorage *ppropsetstg = NULL; //TSafeStorage< IPropertySetStorage > ppropsetstg;
CPropVariant rgcpropvar[ CPROPERTIES_ALL ];
IPropertySetStorage *pPropSetStg;
IPropertyStorage *pPropStg;
DWORD propsetflag;
ULONG cPropertiesAll;
ULONG ulIndex;
Status( "Standalone API test\n" );
// Generate FMTIDs.
UuidCreate( &fmtidStgPropStg );
UuidCreate( &fmtidStgPropSetStg );
// Generate a filename from the directory name.
ocscpy( ocsFile, ocsDir );
ocscat( ocsFile, OLESTR( "IPropAPIs.stg" ));
// Create a storage.
Check( S_OK, g_pfnStgCreateStorageEx( ocsFile,
STGM_CREATE | STGM_READWRITE | STGM_SHARE_EXCLUSIVE,
DetermineStgFmt( g_enumImplementation ),
0L,
NULL,
NULL,
DetermineStgIID( g_enumImplementation ),
(void**) &pstg ));
// Run the following part of the test twice; once for a simple
// property set and once for a non-simple.
for( int i = 0; i < 2; i++ )
{
ILockBytes *pLockBytes = NULL;
IStorage *pstgInMemory = NULL;
#ifdef _MAC
Handle hglobal;
hglobal = NewHandle( 0 );
#else
HANDLE hglobal;
hglobal = GlobalAlloc( GPTR, 0 );
#endif
Check( TRUE, NULL != hglobal );
if( 0 == i )
{
// Create simple IPropertyStorage
Check(S_OK, CreateStreamOnHGlobal( hglobal, TRUE, &pstmInMemory ));
Check( S_OK, g_pfnStgCreatePropStg( (IUnknown*) pstmInMemory,
fmtidStgPropStg,
&CLSID_NULL,
PROPSETFLAG_ANSI,
0L, // Reserved
&pPropStg ));
}
else
{
// If we're not allowed to do non-simple, skip out now.
if( (RESTRICT_SIMPLE_ONLY & g_Restrictions)
||
(RESTRICT_NON_HIERARCHICAL & g_Restrictions) )
{
break;
}
// Create a non-simple IPropertyStorage
Check( S_OK, CreateILockBytesOnHGlobal( hglobal, TRUE, &pLockBytes ));
Check( S_OK, StgCreateDocfileOnILockBytes( pLockBytes,
STGM_CREATE|STGM_READWRITE|STGM_SHARE_EXCLUSIVE,
0,
&pstgInMemory ));
Check( S_OK, g_pfnStgCreatePropStg( (IUnknown*) pstgInMemory,
fmtidStgPropStg,
&CLSID_NULL,
PROPSETFLAG_ANSI | PROPSETFLAG_NONSIMPLE,
0,
&pPropStg ));
}
// Write to the property set.
Check( S_OK, pPropStg->WriteMultiple( 0 == i ? CPROPERTIES_ALL_SIMPLE : CPROPERTIES_ALL,
g_rgcpropspecAll,
g_rgcpropvarAll,
PID_FIRST_USABLE ));
Check( S_OK, ResetRGPropVar( g_rgcpropvarAll ));
// Read from the property set
Check( S_OK, pPropStg->ReadMultiple( 0 == i ? CPROPERTIES_ALL_SIMPLE : CPROPERTIES_ALL,
g_rgcpropspecAll,
rgcpropvar ));
// Compare the properties
for( ulIndex = 0;
0 == i ? (ulIndex < CPROPERTIES_ALL_SIMPLE) : (ulIndex < CPROPERTIES_ALL);
ulIndex++ )
{
Check( TRUE, rgcpropvar[ulIndex] == g_rgcpropvarAll[ulIndex] );
rgcpropvar[ulIndex].Clear();
}
pPropStg->Release();
pPropStg = NULL;
// -------------------
// Test StgOpenPropStg
// -------------------
// Open the IPropertyStorage
Check( S_OK, g_pfnStgOpenPropStg( 0 == i
? (IUnknown*) pstmInMemory
: (IUnknown*) pstgInMemory,
fmtidStgPropStg,
PROPSETFLAG_DEFAULT
| (0 == i ? 0 : PROPSETFLAG_NONSIMPLE),
0L, // Reserved
&pPropStg ));
// Read from the property set
Check( S_OK, pPropStg->ReadMultiple( 0 == i ? CPROPERTIES_ALL_SIMPLE : CPROPERTIES_ALL,
g_rgcpropspecAll,
rgcpropvar ));
// Compare the properties
for( ulIndex = 0;
0 == i ? (ulIndex < CPROPERTIES_ALL_SIMPLE) : (ulIndex < CPROPERTIES_ALL);
ulIndex++ )
{
Check( TRUE, rgcpropvar[ulIndex] == g_rgcpropvarAll[ulIndex] );
rgcpropvar[ulIndex].Clear();
}
pPropStg->Release();
pPropStg = NULL;
RELEASE_INTERFACE( pstmInMemory );
RELEASE_INTERFACE( pstgInMemory );
RELEASE_INTERFACE( pLockBytes );
}
// --------------------------------
// Test StgCreatePropSetStg::Create
// --------------------------------
// This is equivalent to the previous tests, but
// uses StgCreatePropSetStg to create an IPropertySetStorage,
// and uses that to create a property set.
// Create the IPropertySetStorage
Check( S_OK, g_pfnStgCreatePropSetStg( pstg,
0L, // Reserved
&pPropSetStg ));
// Create an IPropertyStorage. Create it non-simple, unless the underlying
// IStorage (i.e. NTFS) doesn't support it.
if( (RESTRICT_SIMPLE_ONLY & g_Restrictions) || (RESTRICT_NON_HIERARCHICAL & g_Restrictions) )
{
propsetflag = PROPSETFLAG_DEFAULT;
cPropertiesAll = CPROPERTIES_ALL_SIMPLE;
}
else
{
propsetflag = PROPSETFLAG_NONSIMPLE;
cPropertiesAll = CPROPERTIES_ALL;
}
Check( S_OK, pPropSetStg->Create( fmtidStgPropSetStg,
&CLSID_NULL,
propsetflag,
STGM_CREATE | STGM_READWRITE | STGM_SHARE_EXCLUSIVE,
&pPropStg ));
// Write to the property set.
Check( S_OK, pPropStg->WriteMultiple( cPropertiesAll,
g_rgcpropspecAll,
g_rgcpropvarAll,
PID_FIRST_USABLE ));
Check( S_OK, ResetRGPropVar( g_rgcpropvarAll ));
//-----------------------------------------------------------------------
// Close it all up and then open it again.
// This will exercise the g_pfnStgOpenStorageEx API
//
pPropStg->Commit(STGC_DEFAULT);
pPropStg->Release();
pPropStg = NULL;
pPropSetStg->Release();
pPropSetStg = NULL;
pstg->Release();
pstg = NULL;
Check( S_OK, g_pfnStgOpenStorageEx( ocsFile,
STGM_READWRITE | STGM_SHARE_EXCLUSIVE,
STGFMT_ANY, //DetermineStgFmt( g_enumImplementation ), // BUGBUG: Use STGFMT_ANY when StgEx can handle it
0L,
NULL,
NULL,
IID_IPropertySetStorage,
(void**) &pPropSetStg ));
Check( S_OK, pPropSetStg->Open( fmtidStgPropSetStg,
STGM_READWRITE | STGM_SHARE_EXCLUSIVE,
&pPropStg));
//pPropSetStg->Release();
//
//-----------------------------------------------------------------------
//
// Read from the property set
//
Check( S_OK, pPropStg->ReadMultiple( cPropertiesAll,
g_rgcpropspecAll,
rgcpropvar ));
// Compare the properties
for( ulIndex = 0; ulIndex < cPropertiesAll; ulIndex++ )
{
Check( TRUE, rgcpropvar[ulIndex] == g_rgcpropvarAll[ulIndex] );
rgcpropvar[ulIndex].Clear();
}
// Clean up
RELEASE_INTERFACE( pPropStg );
RELEASE_INTERFACE( pPropSetStg );
}
//
// IPropertySetStorage tests
//
void
test_IPropertySetStorage_IUnknown(IStorage *pStorage)
{
// Only use this an IStorage-based property set, since this test
// assumes that IStorage & IPropertySetStorage are on the same
// object.
if( PROPIMP_DOCFILE_IPROP == g_enumImplementation )
{
return;
}
Status( "IPropertySetStorage::IUnknown\n" );
// Check ref counting through different interfaces on object
//
// QI to IPropertySetStorage
// QI to IUnknown on IStorage
// QI to IUnknown on IPropertySetStorage
// QI back to IPropertySetStorage from IUnknown
// QI back to IStorage from IPropertySetStorage
//
// Release all.
//
IStorage *pStorage2;
IPropertySetStorage *ppss1, *ppss2, *ppss3;
IUnknown *punk1,*punk2;
HRESULT hr=S_OK;
Check(S_OK, pStorage->QueryInterface(IID_IPropertySetStorage, (void**)&ppss1));
Check(S_OK, pStorage->QueryInterface(IID_IUnknown, (void **)&punk1));
Check(S_OK, ppss1->QueryInterface(IID_IUnknown, (void **)&punk2));
Check(S_OK, ppss1->QueryInterface(DetermineStgIID( g_enumImplementation ), (void **)&pStorage2));
Check(S_OK, ppss1->QueryInterface(IID_IPropertySetStorage, (void **)&ppss2));
Check(S_OK, punk1->QueryInterface(IID_IPropertySetStorage, (void **)&ppss3));
ppss1->AddRef();
ppss1->Release();
//pStorage.Release();
ppss1->Release();
punk1->Release();
punk2->Release();
pStorage2->Release();
ppss2->Release();
// void *pvVirtFuncTable = *(void**)ppss3;
ppss3->Release();
// Check(STG_E_INVALIDHANDLE, ((IPropertySetStorage*)&pvVirtFuncTable)->QueryInterface(IID_IUnknown, (void**)&punk3));
}
#define INVALID_POINTER ( (void *) 0xFFFFFFFF )
#define VTABLE_MEMBER_FN(pObj,entry) ( (*(ULONG ***)(pObj))[ (entry) ] )
//+---------------------------------------------------------
//
// Template: Alloc2PageVector
//
// Purpose: This function template allocates two pages
// of memory, and then sets a vector pointer
// so that its first element is wholy within
// the first page, and the second element is
// wholy within the second. Then, the protection
// of the second page is set according to the
// caller-provided parameter.
//
//
// Inputs: [TYPE**] ppBase
// Points to the beginning of the two pages.
// [TYPE**] ppVector
// Points to the beginning of the vector of TYPEs.
// [DWORD] dwProtect
// The desired protection on the second page
// (from the PAGE_* enumeration).
// [LPWSTR] lpwstr (optional)
// If not NULL, used to initialize the vector
// elements.
//
// Output: TRUE iff successful.
//
//+---------------------------------------------------------
template< class TYPE > BOOL Alloc2PageVector( TYPE** ppBase,
TYPE** ppVector,
DWORD dwProtect,
TYPE* pInit )
{
DWORD dwOldProtect;
SYSTEM_INFO si;
GetSystemInfo( &si );
*ppBase = (TYPE*) VirtualAlloc( NULL, 2 * si.dwPageSize, MEM_COMMIT, PAGE_EXECUTE_READWRITE );
if( NULL == *ppBase )
return( FALSE );
*ppVector = (TYPE*) ( (BYTE*) *ppBase + si.dwPageSize - sizeof(TYPE) );
if( NULL != pInit )
{
memcpy( &((LPWSTR*)*ppVector)[0], pInit, sizeof(TYPE) );
memcpy( &((LPWSTR*)*ppVector)[1], pInit, sizeof(TYPE) );
}
if( !VirtualProtect( (BYTE*) *ppBase + si.dwPageSize, si.dwPageSize, dwProtect, &dwOldProtect ) )
return( FALSE );
return( TRUE );
}
void
test_PropVariantValidation( IStorage *pStg )
{
Status( "PropVariant Validation\n" );
IPropertySetStorage *pPSStg = NULL; // TSafeStorage< IPropertySetStorage > pPSStg( pStg );
IPropertyStorage *pPStg = NULL; // TSafeStorage< IPropertyStorage > pPStg;
CPropVariant cpropvar;
CLIPDATA clipdata;
PROPSPEC propspec;
const LPWSTR wszText = L"Unicode Text String";
FMTID fmtid;
UuidCreate( &fmtid );
Check( S_OK, StgToPropSetStg( pStg, &pPSStg ));
Check(S_OK, pPSStg->Create( fmtid,
NULL,
PROPSETFLAG_DEFAULT,
STGM_READWRITE | STGM_SHARE_EXCLUSIVE,
&pPStg ));
propspec.ulKind = PRSPEC_PROPID;
propspec.propid = 2;
// -------------------------------
// Test invalid VT_CF Propvariants
// -------------------------------
// NULL clip format.
clipdata.cbSize = 4;
clipdata.ulClipFmt = (ULONG) -1;
clipdata.pClipData = NULL;
cpropvar = clipdata;
Check(S_OK, pPStg->WriteMultiple( 1, &propspec, &cpropvar, PID_FIRST_USABLE ));
// Too short cbSize.
((PROPVARIANT*)&cpropvar)->pclipdata->cbSize = 3;
Check(STG_E_INVALIDPARAMETER, pPStg->WriteMultiple( 1, &propspec, &cpropvar, PID_FIRST_USABLE ));
// Too short pClipData (it should be 1 byte, but the pClipData is NULL).
((PROPVARIANT*)&cpropvar)->pclipdata->cbSize = 5;
Check(STG_E_INVALIDPARAMETER, pPStg->WriteMultiple( 1, &propspec, &cpropvar, PID_FIRST_USABLE ));
Check( 0, RELEASE_INTERFACE(pPStg) );
RELEASE_INTERFACE(pPSStg);
}
void
test_ParameterValidation(IStorage *pStg)
{
// We only run this test on WIN32 builds, because we need
// the VirtualAlloc routine.
#ifdef WIN32
Status( "Parameter Validation\n" );
IPropertySetStorage *pPSStg = NULL;
IPropertyStorage *pPStg = NULL;
FMTID fmtid;
UuidCreate( &fmtid );
LPFMTID pfmtidNULL = NULL;
LPFMTID pfmtidInvalid = (LPFMTID) INVALID_POINTER;
PAPP_COMPAT_INFO pAppCompatInfo = NULL;
DWORD dwOldProtect;
Check( S_OK, StgToPropSetStg( pStg, &pPSStg ));
// By default, pointer validation is turned off in ole32 (as of Whistler).
// Enable it for our process so that we can test the checks.
PAPP_COMPAT_INFO pAppCompatInfoSave = (PAPP_COMPAT_INFO) NtCurrentPeb()->AppCompatInfo;
APP_COMPAT_INFO AppCompatInfoNew;
memset( &AppCompatInfoNew, 0, sizeof(AppCompatInfoNew) );
AppCompatInfoNew.CompatibilityFlags.QuadPart |= KACF_OLE32VALIDATEPTRS;
NtCurrentPeb()->AppCompatInfo = &AppCompatInfoNew;
NtCurrentPeb()->AppCompatFlags.QuadPart = AppCompatInfoNew.CompatibilityFlags.QuadPart;
// Define two invalid property names
OLECHAR oszTooLongName[ CCH_MAXPROPNAMESZ + 1 ];
LPOLESTR poszTooLongName = oszTooLongName;
OLECHAR oszTooShortName[] = { L"" };
LPOLESTR poszTooShortName = oszTooShortName;
PROPSPEC propspecTooLongName = { PRSPEC_LPWSTR };
PROPSPEC propspecTooShortName = { PRSPEC_LPWSTR };
propspecTooLongName.lpwstr = oszTooLongName;
propspecTooShortName.lpwstr = oszTooShortName;
for( int i = 0; i < sizeof(oszTooLongName)/sizeof(oszTooLongName[0]); i++ )
oszTooLongName[i] = OLESTR('a');
oszTooLongName[ sizeof(oszTooLongName)/sizeof(oszTooLongName[0]) ] = OLESTR('\0');
// Define several arrays which will be created with special
// protections. For all of this vectors, the first element
// will be in a page to which we have all access rights. The
// second element will be in a page for which we have no access,
// read access, or all access. The variables are named
// according to the access rights in the second element.
// The '...Base' variables are pointers to the base of
// the allocated memory (and must therefore be freed).
// The corresponding variables without the "Base" postfix
// are the vector pointers.
PROPSPEC *rgpropspecNoAccessBase, *rgpropspecNoAccess;
CPropVariant *rgcpropvarReadAccessBase, *rgcpropvarReadAccess;
CPropVariant *rgcpropvarNoAccessBase, *rgcpropvarNoAccess;
PROPID *rgpropidNoAccessBase, *rgpropidNoAccess;
PROPID *rgpropidReadAccessBase, *rgpropidReadAccess;
LPWSTR *rglpwstrNoAccessBase, *rglpwstrNoAccess;
LPWSTR *rglpwstrReadAccessBase, *rglpwstrReadAccess;
STATPROPSETSTG *rgStatPSStgReadAccessBase, *rgStatPSStgReadAccess;
STATPROPSTG *rgStatPStgReadAccessBase, *rgStatPStgReadAccess;
PROPSPEC rgpropspecAllAccess[1];
CPropVariant rgcpropvarAllAccess[1];
PROPID rgpropidAllAccess[1];
LPWSTR rglpwstrAllAccess[1];
LPWSTR rglpwstrInvalid[1];
STATPROPSETSTG rgStatPSStgAllAccess[1];
STATPROPSTG rgStatPStgAllAccess[1];
// Allocate memory for the vectors and set the vector
// pointers.
PROPID propidDefault = PID_FIRST_USABLE;
LPWSTR lpwstrNameDefault = L"Property Name";
Check(TRUE, Alloc2PageVector( &rgpropspecNoAccessBase,
&rgpropspecNoAccess,
(ULONG) PAGE_NOACCESS,
(PROPSPEC*) NULL ));
Check(TRUE, Alloc2PageVector( &rgcpropvarReadAccessBase,
&rgcpropvarReadAccess,
(ULONG) PAGE_READONLY,
(CPropVariant*) NULL ));
Check(TRUE, Alloc2PageVector( &rgcpropvarNoAccessBase,
&rgcpropvarNoAccess,
(ULONG) PAGE_NOACCESS,
(CPropVariant*) NULL ));
Check(TRUE, Alloc2PageVector( &rgpropidNoAccessBase,
&rgpropidNoAccess,
(ULONG) PAGE_NOACCESS,
&propidDefault ));
Check(TRUE, Alloc2PageVector( &rgpropidReadAccessBase,
&rgpropidReadAccess,
(ULONG) PAGE_READONLY,
&propidDefault ));
Check(TRUE, Alloc2PageVector( &rglpwstrNoAccessBase,
&rglpwstrNoAccess,
(ULONG) PAGE_NOACCESS,
&lpwstrNameDefault ));
Check(TRUE, Alloc2PageVector( &rglpwstrReadAccessBase,
&rglpwstrReadAccess,
(ULONG) PAGE_READONLY,
&lpwstrNameDefault ));
Check(TRUE, Alloc2PageVector( &rgStatPSStgReadAccessBase,
&rgStatPSStgReadAccess,
(ULONG) PAGE_READONLY,
(STATPROPSETSTG*) NULL ));
Check(TRUE, Alloc2PageVector( &rgStatPStgReadAccessBase,
&rgStatPStgReadAccess,
(ULONG) PAGE_READONLY,
(STATPROPSTG*) NULL ));
rglpwstrAllAccess[0] = rglpwstrNoAccess[0] = rglpwstrReadAccess[0] = L"Property Name";
// Create restricted buffers for misc tests
BYTE *pbReadOnly = (BYTE*) VirtualAlloc( NULL, 1, MEM_COMMIT, PAGE_READONLY );
Check( TRUE, pbReadOnly != NULL );
BYTE *pbNoAccess = (BYTE*) VirtualAlloc( NULL, 1, MEM_COMMIT, PAGE_NOACCESS );
// ----------------------------------------
// Test IPropertySetStorage::QueryInterface
// ----------------------------------------
IUnknown *pUnk = NULL;
#if 0
// This test cannot run because CPropertySetStorage::QueryInterface is a virtual
// function, and since CExposedDocFile is derived from CPropertySetStorage,
// it is inaccessibl.
// Invalid REFIID
Check(E_INVALIDARG, ((CExposedDocFile*)&pPSStg)->CPropertySetStorage::QueryInterface( (REFIID) *pfmtidNULL, (void**)&pUnk ));
Check(E_INVALIDARG, pPSStg->QueryInterface( (REFIID) *pfmtidInvalid, (void**)&pUnk ));
// Invalid IUnknown*
Check(E_INVALIDARG, pPSStg->QueryInterface( IID_IUnknown, NULL ));
Check(E_INVALIDARG, pPSStg->QueryInterface( IID_IUnknown, (void**) INVALID_POINTER ));
#endif
// --------------------------------
// Test IPropertySetStorage::Create
// --------------------------------
// Invalid REFFMTID
Check(E_INVALIDARG, pPSStg->Create( *pfmtidNULL,
NULL,
PROPSETFLAG_DEFAULT,
STGM_READWRITE | STGM_SHARE_EXCLUSIVE,
&pPStg ));
Check(E_INVALIDARG, pPSStg->Create( *pfmtidInvalid,
NULL,
PROPSETFLAG_DEFAULT,
STGM_READWRITE | STGM_SHARE_EXCLUSIVE,
&pPStg ));
// Invalid Class ID pointer
Check(E_INVALIDARG, pPSStg->Create( FMTID_NULL,
(GUID*) INVALID_POINTER,
PROPSETFLAG_DEFAULT,
STGM_READWRITE | STGM_SHARE_EXCLUSIVE,
&pPStg ));
// Invalid PropSetFlag
Check(STG_E_INVALIDFLAG, pPSStg->Create( FMTID_NULL,
&CLSID_NULL,
PROPSETFLAG_UNBUFFERED, // Only supported in APIs
STGM_READWRITE | STGM_SHARE_EXCLUSIVE,
&pPStg ));
Check(STG_E_INVALIDFLAG, pPSStg->Create( FMTID_NULL,
&CLSID_NULL,
0xffffffff,
STGM_READWRITE | STGM_SHARE_EXCLUSIVE,
&pPStg ));
// Invalid mode
Check(STG_E_INVALIDFLAG, pPSStg->Create( FMTID_NULL,
&CLSID_NULL,
PROPSETFLAG_DEFAULT,
STGM_DIRECT | STGM_SHARE_DENY_NONE,
&pPStg ));
// Invalid IPropertyStorage**
Check(E_INVALIDARG, pPSStg->Create( FMTID_NULL,
&CLSID_NULL,
PROPSETFLAG_DEFAULT,
STGM_READWRITE | STGM_SHARE_EXCLUSIVE,
NULL ));
Check(E_INVALIDARG, pPSStg->Create( FMTID_NULL,
&CLSID_NULL,
PROPSETFLAG_DEFAULT,
STGM_READWRITE | STGM_SHARE_EXCLUSIVE,
(IPropertyStorage **) INVALID_POINTER ));
// ------------------------------
// Test IPropertySetStorage::Open
// ------------------------------
// Invalid REFFMTID
Check(E_INVALIDARG, pPSStg->Open( *pfmtidNULL,
STGM_READWRITE | STGM_SHARE_EXCLUSIVE,
&pPStg ));
Check(E_INVALIDARG, pPSStg->Open( *pfmtidInvalid,
STGM_READWRITE | STGM_SHARE_EXCLUSIVE,
&pPStg ));
Check(STG_E_INVALIDFLAG, pPSStg->Open( FMTID_NULL, STGM_DIRECT | STGM_SHARE_DENY_NONE, &pPStg ));
// Invalid IPropertyStorage**
Check(E_INVALIDARG, pPSStg->Open( FMTID_NULL,
STGM_READWRITE | STGM_SHARE_EXCLUSIVE,
NULL ));
Check(E_INVALIDARG, pPSStg->Open( FMTID_NULL,
STGM_READWRITE | STGM_SHARE_EXCLUSIVE,
(IPropertyStorage**) INVALID_POINTER ));
// --------------------------------
// Test IPropertySetStorage::Delete
// --------------------------------
// Invalid REFFMTID.
Check(E_INVALIDARG, pPSStg->Delete( *pfmtidNULL ));
Check(E_INVALIDARG, pPSStg->Delete( (REFFMTID) *pfmtidInvalid ));
// ------------------------------
// Test IPropertySetStorage::Enum
// ------------------------------
// Invalid IEnumSTATPROPSETSTG
Check(E_INVALIDARG, pPSStg->Enum( (IEnumSTATPROPSETSTG **) NULL ));
Check(E_INVALIDARG, pPSStg->Enum( (IEnumSTATPROPSETSTG **) INVALID_POINTER ));
// -------------
// Test PROPSPEC
// -------------
// Create a PropertyStorage
Check(S_OK, pPSStg->Create( fmtid,
NULL,
PROPSETFLAG_DEFAULT,
STGM_READWRITE | STGM_SHARE_EXCLUSIVE,
&pPStg ));
// Invalid ulKind
rgpropspecAllAccess[0].ulKind = (ULONG) -1;
rgpropspecAllAccess[0].lpwstr = NULL;
Check(E_INVALIDARG, pPStg->ReadMultiple( 1,
rgpropspecAllAccess,
rgcpropvarAllAccess ));
Check(E_INVALIDARG, pPStg->WriteMultiple( 1,
rgpropspecAllAccess,
rgcpropvarAllAccess,
2 ));
Check(E_INVALIDARG, pPStg->DeleteMultiple( 1,
rgpropspecAllAccess ));
// Too short PROPSPEC
rgpropspecNoAccess[0].ulKind = PRSPEC_PROPID;
rgpropspecNoAccess[0].propid = 2;
Check(E_INVALIDARG, pPStg->ReadMultiple( 2,
rgpropspecNoAccess,
rgcpropvarAllAccess ));
Check(E_INVALIDARG, pPStg->WriteMultiple( 2,
rgpropspecNoAccess,
rgcpropvarAllAccess,
2 ));
Check(E_INVALIDARG, pPStg->DeleteMultiple( 2,
rgpropspecNoAccess ));
// -------------------------------------
// Test IPropertyStorage::QueryInterface
// -------------------------------------
// Invalid REFIID
Check(E_INVALIDARG, pPStg->QueryInterface( (REFIID) *pfmtidNULL, (void**)&pUnk ));
Check(E_INVALIDARG, pPStg->QueryInterface( (REFIID) *pfmtidInvalid, (void**)&pUnk ));
// Invalid IUnknown*
Check(E_INVALIDARG, pPStg->QueryInterface( IID_IUnknown, NULL ));
Check(E_INVALIDARG, pPStg->QueryInterface( IID_IUnknown, (void**) INVALID_POINTER ));
// -----------------------------------
// Test IPropertyStorage::ReadMultiple
// -----------------------------------
rgpropspecAllAccess[0].ulKind = PRSPEC_LPWSTR;
rgpropspecAllAccess[0].lpwstr = OLESTR("Test Property");
// Too short count
Check(S_FALSE, pPStg->ReadMultiple( 0,
rgpropspecAllAccess,
rgcpropvarAllAccess));
// Too long a count for the PropVariant
Check(E_INVALIDARG, pPStg->ReadMultiple( 2,
rgpropspecAllAccess,
(PROPVARIANT*) (void*) rgcpropvarReadAccess ));
// Invalid PropVariant[]
Check(E_INVALIDARG, pPStg->ReadMultiple( 1,
rgpropspecAllAccess,
NULL ));
Check(E_INVALIDARG, pPStg->ReadMultiple( 1,
rgpropspecAllAccess,
(LPPROPVARIANT) INVALID_POINTER ));
// Bad PROPSPECs
// If we ever add a version-0 property set compatibility mode, we should add this test back.
// Check(STG_E_INVALIDPARAMETER, pPStg->ReadMultiple( 1, &propspecTooLongName, rgcpropvarAllAccess ));
Check(STG_E_INVALIDPARAMETER, pPStg->ReadMultiple( 1, &propspecTooShortName, rgcpropvarAllAccess ));
// ------------------------------------
// Test IPropertyStorage::WriteMultiple
// ------------------------------------
rgpropspecAllAccess[0].ulKind = PRSPEC_LPWSTR;
rgpropspecAllAccess[0].lpwstr = L"Test Property";
rgcpropvarAllAccess[0] = (long) 1;
// Too short count
Check(S_OK, pPStg->WriteMultiple( 0,
rgpropspecAllAccess,
(PROPVARIANT*)(void*)rgcpropvarAllAccess,
2));
// Too short PropVariant
Check(E_INVALIDARG, pPStg->WriteMultiple( 2,
rgpropspecAllAccess,
(PROPVARIANT*)(void*)rgcpropvarNoAccess,
PID_FIRST_USABLE ));
// Invalid PropVariant[]
Check(E_INVALIDARG, pPStg->WriteMultiple( 1,
rgpropspecAllAccess,
NULL,
2));
Check(E_INVALIDARG, pPStg->WriteMultiple( 1,
rgpropspecAllAccess,
(LPPROPVARIANT) INVALID_POINTER,
PID_FIRST_USABLE));
// Bad PROPSPECs
// If we ever add a version-0 property set compatibility mode, we should add this test back.
// Check(STG_E_INVALIDPARAMETER, pPStg->WriteMultiple( 1, &propspecTooLongName, rgcpropvarAllAccess,
// PID_FIRST_USABLE ));
Check(STG_E_INVALIDPARAMETER, pPStg->WriteMultiple( 1, &propspecTooShortName, rgcpropvarAllAccess,
PID_FIRST_USABLE ));
// -------------------------------------
// Test IPropertyStorage::DeleteMultiple
// -------------------------------------
// Invalid count
Check(S_OK, pPStg->DeleteMultiple( 0,
rgpropspecAllAccess ));
// Bad PROPSPECs
// If we ever add a version-0 property set compatibility mode, we should add this test back.
// Check(STG_E_INVALIDPARAMETER, pPStg->DeleteMultiple( 1, &propspecTooLongName ));
Check(STG_E_INVALIDPARAMETER, pPStg->DeleteMultiple( 1, &propspecTooShortName ));
// ----------------------------------------
// Test IPropertyStorage::ReadPropertyNames
// ----------------------------------------
// Create a property with the name we're going to use.
rgpropspecAllAccess[0].ulKind = PRSPEC_LPWSTR;
rgpropspecAllAccess[0].lpwstr = rglpwstrAllAccess[0];
Check(S_OK, pPStg->WriteMultiple( 1,
rgpropspecAllAccess,
&rgcpropvarAllAccess[0],
PID_FIRST_USABLE ));
// Invalid count
Check(S_FALSE, pPStg->ReadPropertyNames( 0,
rgpropidAllAccess,
rglpwstrAllAccess ));
// Too short PROPID[] or LPWSTR[]
Check(E_INVALIDARG, pPStg->ReadPropertyNames( 2,
rgpropidNoAccess,
rglpwstrAllAccess ));
Check(E_INVALIDARG, pPStg->ReadPropertyNames( 2,
rgpropidAllAccess,
rglpwstrReadAccess ));
// Invalid rgpropid[]
Check(E_INVALIDARG, pPStg->ReadPropertyNames( 1,
NULL,
rglpwstrAllAccess ));
Check(E_INVALIDARG, pPStg->ReadPropertyNames( 1,
(PROPID*) INVALID_POINTER,
rglpwstrAllAccess ));
// Invalid rglpwstr[]
Check(E_INVALIDARG, pPStg->ReadPropertyNames( 1,
rgpropidAllAccess,
NULL ));
Check(E_INVALIDARG, pPStg->ReadPropertyNames( 1,
rgpropidAllAccess,
(LPWSTR*) INVALID_POINTER ));
// -----------------------------------------
// Test IPropertyStorage::WritePropertyNames
// -----------------------------------------
// Invalid count
Check(S_OK, pPStg->WritePropertyNames( 0,
NULL,
rglpwstrAllAccess ));
// Too short PROPID[] or LPWSTR[]
Check(E_INVALIDARG, pPStg->WritePropertyNames( 2,
rgpropidNoAccess,
rglpwstrAllAccess ));
Check(E_INVALIDARG, pPStg->WritePropertyNames( 2,
rgpropidAllAccess,
rglpwstrNoAccess ));
Check(S_OK, pPStg->WritePropertyNames( 2,
rgpropidAllAccess,
rglpwstrReadAccess ));
// Invalid rgpropid[]
Check(E_INVALIDARG, pPStg->WritePropertyNames( 1,
NULL,
rglpwstrAllAccess ));
Check(E_INVALIDARG, pPStg->WritePropertyNames( 1,
(PROPID*) INVALID_POINTER,
rglpwstrAllAccess ));
// Invalid rglpwstr[]
Check(E_INVALIDARG, pPStg->WritePropertyNames( 1,
rgpropidAllAccess,
NULL ));
Check(E_INVALIDARG, pPStg->WritePropertyNames( 1,
rgpropidAllAccess,
(LPWSTR*) INVALID_POINTER ));
// Invalid name.
rglpwstrInvalid[0] = NULL;
Check(E_INVALIDARG, pPStg->WritePropertyNames( 1,
rgpropidAllAccess,
rglpwstrInvalid ));
rglpwstrInvalid[0] = (LPWSTR) INVALID_POINTER;
Check(E_INVALIDARG, pPStg->WritePropertyNames( 1,
rgpropidAllAccess,
rglpwstrInvalid ));
// Invalid length names
// If we ever add a version-0 property set compatibility mode, we should add this test back.
// Check(STG_E_INVALIDPARAMETER, pPStg->WritePropertyNames( 1, rgpropidAllAccess, &poszTooLongName ));
Check(STG_E_INVALIDPARAMETER, pPStg->WritePropertyNames( 1, rgpropidAllAccess, &poszTooShortName ));
// ------------------------------------------
// Test IPropertyStorage::DeletePropertyNames
// ------------------------------------------
// Invalid count
Check(S_OK, pPStg->DeletePropertyNames( 0,
rgpropidAllAccess ));
// Too short PROPID[]
Check(E_INVALIDARG, pPStg->DeletePropertyNames( 2,
rgpropidNoAccess ));
Check(S_OK, pPStg->DeletePropertyNames( 2,
rgpropidReadAccess ));
// Invalid rgpropid[]
Check(E_INVALIDARG, pPStg->DeletePropertyNames( 1,
NULL ));
Check(E_INVALIDARG, pPStg->DeletePropertyNames( 1,
(PROPID*) INVALID_POINTER ));
// ---------------------------
// Test IPropertyStorage::Enum
// ---------------------------
// Invalid IEnumSTATPROPSTG
Check(E_INVALIDARG, pPStg->Enum( NULL ));
Check(E_INVALIDARG, pPStg->Enum( (IEnumSTATPROPSTG**) INVALID_POINTER ));
// --------------------------------------
// Test IPropertyStorage::SetElementTimes
// --------------------------------------
Check(E_INVALIDARG, pPStg->SetTimes( (FILETIME*) INVALID_POINTER,
NULL, NULL ));
Check(E_INVALIDARG, pPStg->SetTimes( NULL,
(FILETIME*) INVALID_POINTER,
NULL ));
Check(E_INVALIDARG, pPStg->SetTimes( NULL, NULL,
(FILETIME*) INVALID_POINTER ));
// -------------------------------
// Test IPropertyStorage::SetClass
// -------------------------------
Check(E_INVALIDARG, pPStg->SetClass( (REFCLSID) *pfmtidNULL ));
Check(E_INVALIDARG, pPStg->SetClass( (REFCLSID) *pfmtidInvalid ));
// ---------------------------
// Test IPropertyStorage::Stat
// ---------------------------
Check(E_INVALIDARG, pPStg->Stat( NULL ));
Check(E_INVALIDARG, pPStg->Stat( (STATPROPSETSTG*) INVALID_POINTER ));
// ------------------------------
// Test IEnumSTATPROPSETSTG::Next
// ------------------------------
ULONG cEltFound;
IEnumSTATPROPSETSTG *pESPSStg = NULL; // TSafeStorage< IEnumSTATPROPSETSTG > pESPSStg;
Check(S_OK, pPSStg->Enum( &pESPSStg ));
// Invalid STATPROPSETSTG*
Check(E_INVALIDARG, pESPSStg->Next( 1, NULL, &cEltFound ));
Check(E_INVALIDARG, pESPSStg->Next( 1, (STATPROPSETSTG*) INVALID_POINTER, &cEltFound ));
// Invalid pceltFound
Check(S_OK, pESPSStg->Next( 1, rgStatPSStgAllAccess, NULL ));
Check(STG_E_INVALIDPARAMETER, pESPSStg->Next( 2, rgStatPSStgAllAccess, NULL ));
Check(E_INVALIDARG, pESPSStg->Next( 2, rgStatPSStgAllAccess, (ULONG*) INVALID_POINTER ));
// Too short STATPROPSETSTG[]
Check(E_INVALIDARG, pESPSStg->Next( 2, rgStatPSStgReadAccess, &cEltFound ));
// -------------------------------
// Test IEnumSTATPROPSETSTG::Clone
// -------------------------------
// Invalid IEnumSTATPROPSETSTG**
Check(E_INVALIDARG, pESPSStg->Clone( NULL ));
Check(E_INVALIDARG, pESPSStg->Clone( (IEnumSTATPROPSETSTG**) INVALID_POINTER ));
// ---------------------------
// Test IEnumSTATPROPSTG::Next
// ---------------------------
IEnumSTATPROPSTG *pESPStg = NULL; // TSafeStorage< IEnumSTATPROPSTG > pESPStg;
Check(S_OK, pPStg->Enum( &pESPStg ));
// Invalid STATPROPSETSTG*
Check(E_INVALIDARG, pESPStg->Next( 1, NULL, &cEltFound ));
Check(E_INVALIDARG, pESPStg->Next( 1, (STATPROPSTG*) INVALID_POINTER, &cEltFound ));
// Invalid pceltFound
Check(S_OK, pESPStg->Next( 1, rgStatPStgAllAccess, NULL ));
Check(STG_E_INVALIDPARAMETER, pESPStg->Next( 2, rgStatPStgAllAccess, NULL ));
Check(E_INVALIDARG, pESPStg->Next( 2, rgStatPStgAllAccess, (ULONG*) INVALID_POINTER ));
// Too short STATPROPSTG[]
Check(E_INVALIDARG, pESPStg->Next( 2, rgStatPStgReadAccess, &cEltFound ));
// ----------------------------
// Test IEnumSTATPROPSTG::Clone
// ----------------------------
// Invalid IEnumSTATPROPSETSTG**
Check(E_INVALIDARG, pESPStg->Clone( NULL ));
Check(E_INVALIDARG, pESPStg->Clone( (IEnumSTATPROPSTG**) INVALID_POINTER ));
// --------------------------------------------
// Test PropStgNameToFmtId & FmtIdToPropStgName
// --------------------------------------------
// We're done with the IPropertyStorage and IPropertySetStorage
// now, but we need the pointers for some calls below, so let's
// free them now.
RELEASE_INTERFACE(pPStg);
RELEASE_INTERFACE(pPSStg);
RELEASE_INTERFACE(pESPStg);
// In some cases we can't test these APIs, so only test them
// if we have the function pointers.
if( g_pfnPropStgNameToFmtId && g_pfnFmtIdToPropStgName )
{
OLECHAR oszPropStgName[ CCH_MAX_PROPSTG_NAME+1 ];
FMTID fmtidPropStgName = FMTID_NULL;
// Validate the FMTID parm
Check( E_INVALIDARG, g_pfnPropStgNameToFmtId( oszPropStgName, pfmtidNULL ));
Check( E_INVALIDARG, g_pfnPropStgNameToFmtId( oszPropStgName, pfmtidInvalid ));
Check( E_INVALIDARG, g_pfnPropStgNameToFmtId( oszPropStgName, (FMTID*) pbReadOnly ));
Check( E_INVALIDARG, g_pfnFmtIdToPropStgName( pfmtidNULL, oszPropStgName ));
Check( E_INVALIDARG, g_pfnFmtIdToPropStgName( pfmtidInvalid, oszPropStgName ));
Check( S_OK, g_pfnFmtIdToPropStgName( (FMTID*) pbReadOnly, oszPropStgName ));
// Validate the name parameter
/*
Check( STG_E_INVALIDNAME, g_pfnPropStgNameToFmtId( NULL, &fmtidPropStgName ));
Check( STG_E_INVALIDNAME, g_pfnPropStgNameToFmtId( (LPOLESTR) INVALID_POINTER, &fmtidPropStgName ));
Check( STG_E_INVALIDNAME, g_pfnPropStgNameToFmtId( (LPOLESTR) pbNoAccess, &fmtidPropStgName));
Check( S_OK, g_pfnPropStgNameToFmtId( (LPOLESTR) pbReadOnly, &fmtidPropStgName ));
Check( E_INVALIDARG, g_pfnFmtIdToPropStgName( &fmtidPropStgName, NULL ));
Check( E_INVALIDARG, g_pfnFmtIdToPropStgName( &fmtidPropStgName, (LPOLESTR) INVALID_POINTER ));
Check( E_INVALIDARG, g_pfnFmtIdToPropStgName( &fmtidPropStgName, (LPOLESTR) pbReadOnly ));
*/
} // if( g_pfnPropStgNameToFmtId && g_pfnFmtIdToPropStgName )
// ------------------------------------------
// Test StgCreatePropStg, StgOpenPropStg APIs
// ------------------------------------------
// In some cases we can't test these APIs, so only test them
// if we have the function pointers.
if( g_pfnStgCreatePropSetStg && g_pfnStgCreatePropStg && g_pfnStgOpenPropStg
&&
!(RESTRICT_SIMPLE_ONLY & g_Restrictions) )
{
FMTID fmtidPropStgName = FMTID_NULL;
IStream *pStm = NULL; // TSafeStorage< IStream > pStm;
// We need a Stream for one of the tests.
Check( S_OK, pStg->CreateStream( OLESTR( "Parameter Validation" ),
STGM_CREATE | STGM_READWRITE | STGM_SHARE_EXCLUSIVE,
0L, 0L,
&pStm ));
// Test the IUnknown
Check( E_INVALIDARG, g_pfnStgCreatePropStg( NULL, fmtidPropStgName, NULL, PROPSETFLAG_DEFAULT, 0, &pPStg ));
Check( E_INVALIDARG, g_pfnStgOpenPropStg( NULL, fmtidPropStgName, PROPSETFLAG_DEFAULT, 0L, &pPStg ));
// Test the FMTID
Check( E_INVALIDARG, g_pfnStgCreatePropStg( (IUnknown*) pStm, *pfmtidNULL, NULL, PROPSETFLAG_DEFAULT, 0, &pPStg ));
Check( E_INVALIDARG, g_pfnStgOpenPropStg( (IUnknown*) pStm, *pfmtidNULL, PROPSETFLAG_DEFAULT, 0, &pPStg ));
Check( E_INVALIDARG, g_pfnStgCreatePropStg( (IUnknown*) pStm, *pfmtidInvalid, NULL, PROPSETFLAG_DEFAULT, 0, &pPStg ));
Check( E_INVALIDARG, g_pfnStgOpenPropStg( (IUnknown*) pStm, *pfmtidInvalid, PROPSETFLAG_DEFAULT, 0, &pPStg ));
// Test the CLSID
Check( E_INVALIDARG, g_pfnStgCreatePropStg( (IUnknown*) pStm, fmtidPropStgName, (CLSID*) pfmtidInvalid, PROPSETFLAG_DEFAULT, 0, &pPStg ));
// Test grfFlags
Check( STG_E_INVALIDFLAG, g_pfnStgCreatePropStg( (IUnknown*) pStm, fmtidPropStgName, NULL, 0x8000, 0L, &pPStg ));
Check( STG_E_INVALIDFLAG, g_pfnStgOpenPropStg( (IUnknown*) pStm, fmtidPropStgName, 0x8000, 0L, &pPStg ));
Check( E_NOINTERFACE, g_pfnStgCreatePropStg( (IUnknown*) pStm, fmtidPropStgName, NULL, PROPSETFLAG_NONSIMPLE, 0L, &pPStg ));
Check( E_NOINTERFACE, g_pfnStgCreatePropStg( (IUnknown*) pStg, fmtidPropStgName, NULL, PROPSETFLAG_DEFAULT, 0L, &pPStg ));
Check( E_NOINTERFACE, g_pfnStgOpenPropStg( (IUnknown*) pStm, fmtidPropStgName, PROPSETFLAG_NONSIMPLE, 0L, &pPStg ));
Check( E_NOINTERFACE, g_pfnStgOpenPropStg( (IUnknown*) pStg, fmtidPropStgName, PROPSETFLAG_DEFAULT , 0L, &pPStg ));
// Test IPropertyStorage**
Check( E_INVALIDARG, g_pfnStgCreatePropStg( (IUnknown*) pStm, fmtidPropStgName, NULL, PROPSETFLAG_DEFAULT, 0L, NULL ));
Check( E_INVALIDARG, g_pfnStgOpenPropStg( (IUnknown*) pStm, fmtidPropStgName, PROPSETFLAG_DEFAULT, 0L, NULL ));
Check( E_INVALIDARG, g_pfnStgCreatePropStg( (IUnknown*) pStm, fmtidPropStgName, NULL, PROPSETFLAG_DEFAULT, 0L, (IPropertyStorage**) INVALID_POINTER ));
Check( E_INVALIDARG, g_pfnStgOpenPropStg( (IUnknown*) pStm, fmtidPropStgName, PROPSETFLAG_DEFAULT, 0L, (IPropertyStorage**) INVALID_POINTER ));
Check( E_INVALIDARG, g_pfnStgCreatePropStg( (IUnknown*) pStm, fmtidPropStgName, NULL, PROPSETFLAG_DEFAULT, 0L, (IPropertyStorage**) pbReadOnly ));
Check( E_INVALIDARG, g_pfnStgOpenPropStg( (IUnknown*) pStm, fmtidPropStgName, PROPSETFLAG_DEFAULT, 0L, (IPropertyStorage**) pbReadOnly ));
RELEASE_INTERFACE(pStm);
} // if( g_pfnStgCreatePropSetStg && g_pfnStgCreatePropStg && g_pfnStgOpenPropStg )
// If we're not using IStorage::QueryInterface to get an IPropertySetStorage,
// we must be using the new APIs, so let's test them.
// ----------------------------
// Test StgCreatePropSetStg API
// ----------------------------
// In some cases we can't test these APIs, so only test them
// if we have the function pointers.
if( g_pfnStgCreatePropSetStg && g_pfnStgCreatePropStg && g_pfnStgOpenPropStg )
{
// Test the IStorage*
Check( E_INVALIDARG, g_pfnStgCreatePropSetStg( NULL, 0L, &pPSStg ));
Check( E_INVALIDARG, g_pfnStgCreatePropSetStg( (IStorage*) INVALID_POINTER, 0L, &pPSStg ));
// Test the IPropertySetStorage**
Check( E_INVALIDARG, g_pfnStgCreatePropSetStg( pStg, 0L, NULL ));
Check( E_INVALIDARG, g_pfnStgCreatePropSetStg( pStg, 0L, (IPropertySetStorage**) INVALID_POINTER ));
// -------------------------------------------------------------
// Test g_pfnPropVariantCopy, PropVariantClear & FreePropVariantArray
// -------------------------------------------------------------
// PropVariantCopy
Check( E_INVALIDARG, g_pfnPropVariantCopy( rgcpropvarAllAccess, NULL ));
Check( E_INVALIDARG, g_pfnPropVariantCopy( rgcpropvarAllAccess, (PROPVARIANT*) INVALID_POINTER ));
Check( E_INVALIDARG, g_pfnPropVariantCopy( NULL, rgcpropvarAllAccess ));
Check( E_INVALIDARG, g_pfnPropVariantCopy( (PROPVARIANT*) INVALID_POINTER, rgcpropvarAllAccess ));
Check( E_INVALIDARG, g_pfnPropVariantCopy( (PROPVARIANT*) pbReadOnly, rgcpropvarAllAccess ));
// PropVariantClear
Check( S_OK, g_pfnPropVariantClear( NULL ));
Check( E_INVALIDARG, g_pfnPropVariantClear( (PROPVARIANT*) INVALID_POINTER ));
Check( E_INVALIDARG, g_pfnPropVariantClear( (PROPVARIANT*) pbReadOnly ));
// FreePropVariantArray
Check( E_INVALIDARG, g_pfnFreePropVariantArray( 1, NULL ));
Check( E_INVALIDARG, g_pfnFreePropVariantArray( 1, (PROPVARIANT*) INVALID_POINTER ));
Check( S_OK, g_pfnFreePropVariantArray( 1, (PROPVARIANT*) (void*)rgcpropvarReadAccess ));
Check( E_INVALIDARG, g_pfnFreePropVariantArray( 2, (PROPVARIANT*) (void*)rgcpropvarReadAccess ));
} // if( g_pfnStgCreatePropSetStg && g_pfnStgCreatePropStg && g_pfnStgOpenPropStg )
// ----
// Exit
// ----
VirtualFree( rgpropspecNoAccessBase, 0, MEM_RELEASE );
VirtualFree( rgcpropvarReadAccessBase, 0, MEM_RELEASE );
VirtualFree( rgcpropvarNoAccessBase, 0, MEM_RELEASE );
VirtualFree( rgpropidNoAccessBase, 0, MEM_RELEASE );
VirtualFree( rgpropidReadAccessBase, 0, MEM_RELEASE );
VirtualFree( rglpwstrNoAccessBase, 0, MEM_RELEASE );
VirtualFree( rglpwstrReadAccessBase, 0, MEM_RELEASE );
VirtualFree( rgStatPSStgReadAccessBase, 0, MEM_RELEASE );
VirtualFree( rgStatPStgReadAccessBase, 0, MEM_RELEASE );
RELEASE_INTERFACE(pPSStg);
RELEASE_INTERFACE(pPStg);
RELEASE_INTERFACE(pESPSStg);
NtCurrentPeb()->AppCompatInfo = pAppCompatInfoSave;
#endif // #ifdef WIN32
} // test_ParameterValidation(IStorage *pStg)
// Check creation/open/deletion of property sets (check fmtid and predefined names)
// Create a property set
// Try recreate of same
// Try delete
// Close the property set
// Try recreate of same
// Reopen the property set
// Try recreate of same
// Try delete
// Close the property set
// Delete the property set
// Repeat the test once more
void
test_IPropertySetStorage_CreateOpenDelete(IStorage *pStorage)
{
Status( "IPropertySetStorage::Create/Open/Delete\n" );
FMTID fmtid;
PROPSPEC propspec;
UuidCreate(&fmtid);
for (int i=0; i<4; i++)
{
DWORD propsetflag;
if( !(g_Restrictions & RESTRICT_SIMPLE_ONLY) )
propsetflag = (i & 2) == 0 ? PROPSETFLAG_DEFAULT : PROPSETFLAG_NONSIMPLE;
else
propsetflag = PROPSETFLAG_DEFAULT;
{
IPropertySetStorage *pPropSetStg = NULL; // TSafeStorage< IPropertySetStorage > pPropSetStg(pStorage);
IPropertyStorage *PropStg, *PropStg2;
Check( S_OK, StgToPropSetStg( pStorage, &pPropSetStg ));
Check( S_OK, pPropSetStg->Create(fmtid,
NULL,
propsetflag,
STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_DIRECT | STGM_READWRITE,
&PropStg));
Check( S_OK, pPropSetStg->Create(fmtid,
NULL,
propsetflag,
STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_DIRECT | STGM_READWRITE,
&PropStg2 ));
Check( STG_E_REVERTED, PropStg->Commit(0) );
RELEASE_INTERFACE( PropStg );
RELEASE_INTERFACE( PropStg2 );
RELEASE_INTERFACE( pPropSetStg );
}
{
IPropertySetStorage *pPropSetStg = NULL; // TSafeStorage< IPropertySetStorage > pPropSetStg(pStorage);
IPropertyStorage *PropStg, *PropStg2;
Check( S_OK, StgToPropSetStg( pStorage, &pPropSetStg ));
// use STGM_FAILIFTHERE
Check(STG_E_FILEALREADYEXISTS, pPropSetStg->Create(fmtid,
NULL,
propsetflag,
STGM_SHARE_EXCLUSIVE | STGM_DIRECT | STGM_READWRITE,
&PropStg));
Check(S_OK, pPropSetStg->Open(fmtid,
STGM_SHARE_EXCLUSIVE | STGM_DIRECT | STGM_READWRITE,
&PropStg));
Check( STG_E_ACCESSDENIED,
pPropSetStg->Open(fmtid,
STGM_SHARE_EXCLUSIVE | STGM_DIRECT | STGM_READWRITE,
&PropStg2));
Check( STG_E_ACCESSDENIED,
pPropSetStg->Create( fmtid,
NULL,
propsetflag,
STGM_SHARE_EXCLUSIVE | STGM_DIRECT | STGM_READWRITE,
&PropStg2));
// Docfile allows an open element to be deleted (putting open objects
// in the reverted state). NTFS doesn't allow the delete though.
Check( (g_Restrictions & RESTRICT_NON_HIERARCHICAL)
? STG_E_SHAREVIOLATION
: S_OK,
pPropSetStg->Delete(fmtid) );
propspec.ulKind = PRSPEC_PROPID;
propspec.propid = 1000;
PROPVARIANT propvar;
propvar.vt = VT_I4;
propvar.lVal = 12345;
Check((g_Restrictions & RESTRICT_NON_HIERARCHICAL) ? S_OK : STG_E_REVERTED,
PropStg->WriteMultiple(1, &propspec, &propvar, 2)); // force dirty
RELEASE_INTERFACE(PropStg);
RELEASE_INTERFACE(pPropSetStg);
//Check(S_OK, pPropSetStg->Delete(fmtid));
}
}
}
void
test_IPropertySetStorage_SummaryInformation(IStorage *pStorage)
{
if( g_Restrictions & RESTRICT_NON_HIERARCHICAL ) return;
Status( "SummaryInformation\n" );
IPropertySetStorage *pPropSetStg = NULL; // TSafeStorage< IPropertySetStorage > pPropSetStg(pStorage);
IPropertyStorage *PropStg;
IStream *pstm;
Check( S_OK, StgToPropSetStg( pStorage, &pPropSetStg ));
Check(S_OK, pPropSetStg->Create(FMTID_SummaryInformation,
NULL,
PROPSETFLAG_DEFAULT,
STGM_SHARE_EXCLUSIVE | STGM_DIRECT | STGM_READWRITE,
&PropStg));
RELEASE_INTERFACE(PropStg);
Check(S_OK, pStorage->OpenStream(OLESTR("\005SummaryInformation"),
NULL,
STGM_READWRITE | STGM_SHARE_EXCLUSIVE,
0,
&pstm));
RELEASE_INTERFACE(pstm);
RELEASE_INTERFACE(pPropSetStg);
}
//
// Check STGM_FAILIFTHERE and ~STGM_FAILIFTHERE in following cases
// Check overwriting simple with extant non-simple
// Check overwriting simple with simple
// Check overwriting non-simple with simple
// Check overwriting non-simple with non-simple
void
test_IPropertySetStorage_FailIfThere(IStorage *pStorage)
{
// (Use "fale" instead of "fail" in this printf so the output won't
// alarm anyone with the word "fail" uncessarily).
Status( "IPropertySetStorage, FaleIfThere\n" );
IPropertySetStorage *pPropSetStg = NULL; // TSafeStorage< IPropertySetStorage > pPropSetStg(pStorage);
ULONG cStorageRefs = GetRefCount( pStorage );
Check( S_OK, StgToPropSetStg( pStorage, &pPropSetStg ));
// Iter 0 1 2 3 4 5 6 7
// Create simple nonsimple simple nonsimple simple nonsimple simple nonsimple
// ReCreate simple simple nonsimple nonsimple simple simple nonsimple nonsimple
// failif failif failif failif overw overw overw overw
//
// expected exists exists exists exists ok ok ok ok
for (int i=0; i<8; i++)
{
FMTID fmtid;
IPropertyStorage *PropStg;
DWORD propsetflagNonSimple = (g_Restrictions & RESTRICT_SIMPLE_ONLY) ? PROPSETFLAG_DEFAULT : PROPSETFLAG_NONSIMPLE;
UuidCreate(&fmtid);
Check(S_OK, pPropSetStg->Create(fmtid,
NULL,
(i & 1) == 1 ? propsetflagNonSimple : 0,
STGM_SHARE_EXCLUSIVE | STGM_DIRECT | STGM_READWRITE,
&PropStg));
PropStg->Release();
Check((i&4) == 4 ? S_OK : STG_E_FILEALREADYEXISTS,
pPropSetStg->Create(fmtid,
NULL,
(i & 2) == 2 ? propsetflagNonSimple : 0,
( (i & 4) == 4 ? STGM_CREATE : STGM_FAILIFTHERE )
|
STGM_SHARE_EXCLUSIVE | STGM_DIRECT | STGM_READWRITE,
&PropStg));
if (PropStg)
{
PropStg->Release();
}
}
RELEASE_INTERFACE( pPropSetStg );
Check( cStorageRefs, GetRefCount( pStorage ));
}
//
//
//
// Bad this pointer.
// Call all methods with a bad this pointer, check we get STG_E_INVALIDHANDLE
//
void
test_IPropertySetStorage_BadThis(IStorage *pIgnored)
{
Status( "Bad IPropertySetStorage 'this' pointer\n" );
IPropertySetStorage *pBad;
IID iid;
FMTID fmtid;
void *pv;
IPropertyStorage *pps;
IEnumSTATPROPSETSTG *penm;
pBad = reinterpret_cast<IPropertySetStorage*>(&iid);
Check(STG_E_INVALIDHANDLE,pBad->QueryInterface(iid, &pv));
Check(0, pBad->AddRef());
Check(0, pBad->Release());
Check(STG_E_INVALIDHANDLE,pBad->Create( fmtid, NULL, 0, 0, &pps));
Check(STG_E_INVALIDHANDLE,pBad->Open(fmtid, 0, &pps));
Check(STG_E_INVALIDHANDLE,pBad->Delete( fmtid ));
Check(STG_E_INVALIDHANDLE,pBad->Enum( &penm ));
}
// Transacted mode
// Create a non-simple property set with one VT_STREAM child, close it
// Open it in transacted mode
// Write another VT_STORAGE child
// Close and revert
// Check that the second child does not exist.
// Repeat and close and commit and check the child exists.
void
test_IPropertySetStorage_TransactedMode(IStorage *pStorage)
{
FMTID fmtid;
UuidCreate(&fmtid);
if( g_Restrictions & ( RESTRICT_DIRECT_ONLY | RESTRICT_SIMPLE_ONLY )) return;
Status( "Transacted Mode\n" );
{
//
// create a substorage "teststg" with a propset
// create a stream "src" which is then written via VT_STREAM as propid 7fffffff
CTempStorage pSubStorage(coCreate, pStorage, OLESTR("teststg"));
IPropertySetStorage *pPropSetStg = NULL; // TSafeStorage< IPropertySetStorage > pPropSetStg(pSubStorage);
Check( S_OK, StgToPropSetStg( pSubStorage, &pPropSetStg ));
IPropertyStorage *pPropSet;
IStream *pstm;
Check(S_OK, pPropSetStg->Create(fmtid, NULL, PROPSETFLAG_NONSIMPLE,
STGM_READWRITE | STGM_DIRECT | STGM_SHARE_EXCLUSIVE,
&pPropSet));
PROPSPEC ps;
ps.ulKind = PRSPEC_PROPID;
ps.propid = 0x7ffffffd;
Check(S_OK, pStorage->CreateStream(OLESTR("src"), STGM_DIRECT|STGM_SHARE_EXCLUSIVE|STGM_READWRITE,
0,0, &pstm));
Check(S_OK, pstm->Write(L"billmo", 14, NULL));
Check(S_OK, pstm->Seek(g_li0, STREAM_SEEK_SET, NULL));
PROPVARIANT pv;
pv.vt = VT_STREAM;
pv.pStream = pstm;
Check(S_OK, pPropSet->WriteMultiple(1, &ps, &pv, 2)); // copies the stream in
Check( 0, RELEASE_INTERFACE(pPropSet) );
Check( 0, RELEASE_INTERFACE(pstm) );
RELEASE_INTERFACE(pPropSetStg);
}
{
IPropertyStorage *pPropSet;
// Reopen the propset in transacted and add one with id 0x7ffffffe
CTempStorage pSubStorage(coOpen, pStorage, OLESTR("teststg"), STGM_TRANSACTED);
IPropertySetStorage *pPropSetStg = NULL; // TSafeStorage< IPropertySetStorage > pPropSetStg(pSubStorage);
Check( S_OK, StgToPropSetStg( pSubStorage, &pPropSetStg ));
// Create a storage object to copy
CTempStorage pstgSrc;
CTempStorage pTestChild(coCreate, pstgSrc, OLESTR("testchild"));
Check(S_OK, pPropSetStg->Open(fmtid,
STGM_READWRITE | STGM_DIRECT | STGM_SHARE_EXCLUSIVE,
&pPropSet));
// copy in the storage object
PROPSPEC ps[2];
ps[0].ulKind = PRSPEC_PROPID;
ps[0].propid = 0x7ffffffe;
ps[1].ulKind = PRSPEC_PROPID;
ps[1].propid = 0x7ffffff0;
PROPVARIANT pv[2];
pv[0].vt = VT_STORAGE;
pv[0].pStorage = pTestChild;
pv[1].vt = VT_I4;
pv[1].lVal = 123;
Check(S_OK, pPropSet->WriteMultiple(2, ps, pv, 2)); // copies the storage in
pSubStorage->Revert(); // throws away the storage
// check that property set operations return stg_e_reverted
Check(STG_E_REVERTED, pPropSet->WriteMultiple(2, ps, pv, 2));
Check(STG_E_REVERTED, pPropSet->ReadMultiple(1, ps+1, pv+1));
Check(STG_E_REVERTED, pPropSet->DeleteMultiple(1, ps+1));
LPOLESTR pstr = L"pstr";
Check(STG_E_REVERTED, pPropSet->ReadPropertyNames(1, &ps[1].propid, &pstr));
Check(STG_E_REVERTED, pPropSet->WritePropertyNames(1, &ps[1].propid, &pstr));
Check(STG_E_REVERTED, pPropSet->DeletePropertyNames(1, &ps[1].propid));
Check(STG_E_REVERTED, pPropSet->Commit(STGC_DEFAULT));
Check(STG_E_REVERTED, pPropSet->Revert());
IEnumSTATPROPSTG *penum;
Check(STG_E_REVERTED, pPropSet->Enum(&penum));
FILETIME ft;
Check(STG_E_REVERTED, pPropSet->SetTimes(&ft, &ft, &ft));
CLSID clsid;
Check(STG_E_REVERTED, pPropSet->SetClass(clsid));
STATPROPSETSTG statpropsetstg;
Check(STG_E_REVERTED, pPropSet->Stat(&statpropsetstg));
Check( 0, RELEASE_INTERFACE(pPropSet) );
RELEASE_INTERFACE(pPropSetStg);
}
{
IPropertyStorage *pPropSet;
// Reopen the propset in direct mode and check that the
// second child is not there.
CTempStorage pSubStorage(coOpen, pStorage, OLESTR("teststg"));
IPropertySetStorage *pPropSetStg = NULL; // TSafeStorage< IPropertySetStorage > pPropSetStg(pSubStorage);
Check( S_OK, StgToPropSetStg( pSubStorage, &pPropSetStg ));
Check(S_OK, pPropSetStg->Open(fmtid,
STGM_READWRITE | STGM_DIRECT | STGM_SHARE_EXCLUSIVE,
&pPropSet));
// read out the storage object
PROPSPEC aps[2];
aps[0].ulKind = PRSPEC_PROPID;
aps[0].propid = 0x7ffffffe; // storage not expected
aps[1].ulKind = PRSPEC_PROPID;
aps[1].propid = 0x7ffffffd; // stream is expected
PROPVARIANT apv[2];
Check(S_FALSE, pPropSet->ReadMultiple(1, aps, apv));
Check(S_OK, pPropSet->ReadMultiple(2, aps, apv)); // opens the stream
Check(TRUE, apv[0].vt == VT_EMPTY);
Check(TRUE, apv[1].vt == VT_STREAM);
Check(TRUE, apv[1].pStream != NULL);
WCHAR wcsBillMo[7];
Check(S_OK, apv[1].pStream->Read(wcsBillMo, 14, NULL));
Check(TRUE, wcscmp(L"billmo", wcsBillMo) == 0);
Check( 0, RELEASE_INTERFACE(apv[1].pStream) );
Check( 0, RELEASE_INTERFACE(pPropSet) );
RELEASE_INTERFACE(pPropSetStg);
}
}
//
// test that the buffer is correctly reverted
//
void
test_IPropertySetStorage_TransactedMode2(IStorage *pStorage)
{
if( g_Restrictions & (RESTRICT_DIRECT_ONLY | RESTRICT_SIMPLE_ONLY )) return;
Status( "Transacted Mode 2\n" );
//
// write and commit a property A
// write and revert a property B
// write and commit a property C
// check that property B does not exist
FMTID fmtid;
PROPSPEC ps;
PROPVARIANT pv;
IPropertyStorage *pPropStg;
IPropertySetStorage *pPropSetStg = NULL; // TSafeStorage< IPropertySetStorage > pPropSetStg(pStorage);
Check( S_OK, StgToPropSetStg( pStorage, &pPropSetStg ));
UuidCreate(&fmtid);
// We'll run this test twice, once with a Create and the other
// with an Open (this way, we test both of the CPropertyStorage
// constructors).
for( int i = 0; i < 2; i++ )
{
if( i == 0 )
{
Check(S_OK, pPropSetStg->Create(fmtid, NULL, PROPSETFLAG_NONSIMPLE,
STGM_TRANSACTED | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, &pPropStg));
}
else
{
Check(S_OK, pPropSetStg->Open(fmtid,
STGM_TRANSACTED | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, &pPropStg));
}
ps.ulKind = PRSPEC_PROPID;
ps.propid = 6;
pv.vt = VT_I4;
pv.lVal = 1;
Check(S_OK, pPropStg->WriteMultiple(1, &ps, &pv, 0x2000));
Check(S_OK, pPropStg->Commit(STGC_DEFAULT));
ps.propid = 7;
pv.lVal = 2;
Check(S_OK, pPropStg->WriteMultiple(1, &ps, &pv, 0x2000));
Check(S_OK, pPropStg->Revert());
ps.propid = 8;
pv.lVal = 3;
Check(S_OK, pPropStg->WriteMultiple(1, &ps, &pv, 0x2000));
Check(S_OK, pPropStg->Commit(STGC_DEFAULT));
ps.propid = 6;
Check(S_OK, pPropStg->ReadMultiple(1, &ps, &pv));
Check(TRUE, pv.lVal == 1);
Check(TRUE, pv.vt == VT_I4);
ps.propid = 7;
Check(S_FALSE, pPropStg->ReadMultiple(1, &ps, &pv));
ps.propid = 8;
Check(S_OK, pPropStg->ReadMultiple(1, &ps, &pv));
Check(TRUE, pv.lVal == 3);
Check(TRUE, pv.vt == VT_I4);
RELEASE_INTERFACE(pPropStg);
} // for( int i = 0; i < 2; i++ )
RELEASE_INTERFACE(pPropSetStg);
}
void
test_IPropertySetStorage_SubPropertySet(IStorage *pStorage)
{
FMTID fmtid;
PROPSPEC ps;
PROPVARIANT pv;
IPropertyStorage *pPropStg;
IPropertySetStorage *pSubSetStg;
IPropertyStorage *pPropStg2;
if( g_Restrictions & RESTRICT_SIMPLE_ONLY ) return;
Status( "Sub Property Set\n" );
for (int i=0; i<2; i++)
{
IPropertySetStorage *pPropSetStg = NULL; // TSafeStorage< IPropertySetStorage > pPropSetStg(pStorage);
ULONG cStorageRefs = GetRefCount( pStorage );
Check( S_OK, StgToPropSetStg( pStorage, &pPropSetStg ));
UuidCreate(&fmtid);
Check(S_OK, pPropSetStg->Create(fmtid, NULL, PROPSETFLAG_NONSIMPLE,
STGM_SHARE_EXCLUSIVE | STGM_READWRITE, &pPropStg));
ps.ulKind = PRSPEC_PROPID;
ps.propid = 6;
pv.vt = VT_STORAGE;
pv.pStorage = NULL;
Check(S_OK, pPropStg->WriteMultiple(1, &ps, &pv, 0x2000));
Check(S_OK, pPropStg->ReadMultiple(1, &ps, &pv));
Check(S_OK, StgToPropSetStg( pv.pStorage, &pSubSetStg ));
Check(S_OK, pSubSetStg->Create(fmtid, NULL, i==0 ? PROPSETFLAG_NONSIMPLE : PROPSETFLAG_DEFAULT,
STGM_SHARE_EXCLUSIVE | STGM_READWRITE, &pPropStg2));
IStorage *pstgTmp = pv.pStorage;
pv.pStorage = NULL;
if (i==1)
{
pv.vt = VT_I4;
}
Check(S_OK, pPropStg2->WriteMultiple(1, &ps, &pv, 0x2000));
pPropStg->Release();
pstgTmp->Release();
pSubSetStg->Release();
pPropStg2->Release();
RELEASE_INTERFACE(pPropSetStg);
Check( cStorageRefs, GetRefCount(pStorage) );
}
}
/*
The following sequence of operations:
- open transacted docfile
- open property set inside docfile
- write properties
- commit docfile
- release property set
results in a STG_E_REVERTED error being detected
*/
void
test_IPropertySetStorage_CommitAtRoot(IStorage *pStorage)
{
if( g_Restrictions & RESTRICT_DIRECT_ONLY ) return;
Status( "Commit at root\n" );
for (int i=0; i<6; i++)
{
FMTID fmtid;
IStorage *pstgT = NULL;
Check(S_OK, g_pfnStgCreateStorageEx(NULL,
STGM_CREATE | STGM_DELETEONRELEASE | STGM_TRANSACTED | STGM_READWRITE | STGM_SHARE_EXCLUSIVE,
STGFMT_STORAGE,
0, NULL, NULL,
IID_IStorage,
reinterpret_cast<void**>(&pstgT) ));
IPropertySetStorage *pPropSetStg = NULL; // TSafeStorage< IPropertySetStorage > pPropSetStg(pStorage);
Check( S_OK, StgToPropSetStg( pstgT, &pPropSetStg ));
UuidCreate(&fmtid);
IPropertyStorage *pPropStg = NULL;
Check(S_OK, pPropSetStg->Create(fmtid, NULL, PROPSETFLAG_DEFAULT,
STGM_SHARE_EXCLUSIVE | STGM_READWRITE, &pPropStg));
PROPSPEC propspec;
propspec.ulKind = PRSPEC_PROPID;
propspec.propid = 1000;
PROPVARIANT propvar;
propvar.vt = VT_I4;
propvar.lVal = 12345;
Check(S_OK, pPropStg->WriteMultiple(1, &propspec, &propvar, 2)); // force dirty
switch (i)
{
case 0:
Check(S_OK, pstgT->Commit(STGC_DEFAULT));
pstgT->Release();
pPropStg->Release();
break;
case 1:
Check(S_OK, pstgT->Commit(STGC_DEFAULT));
pPropStg->Release();
pstgT->Release();
break;
case 2:
pstgT->Release();
pPropStg->Release();
break;
case 3:
pPropStg->Commit(STGC_DEFAULT);
pPropStg->Release();
pstgT->Release();
break;
case 4:
pPropStg->Commit(STGC_DEFAULT);
pstgT->Release();
pPropStg->Release();
break;
case 5:
pPropStg->Release();
pstgT->Release();
break;
}
Check( 0, RELEASE_INTERFACE(pstgT) );
}
}
void
test_IPropertySetStorage(IStorage *pStorage)
{
// Check ref counting through different interfaces on object
test_IPropertySetStorage_IUnknown(pStorage);
test_IPropertySetStorage_CreateOpenDelete(pStorage);
test_IPropertySetStorage_SummaryInformation(pStorage);
test_IPropertySetStorage_FailIfThere(pStorage);
test_IPropertySetStorage_TransactedMode(pStorage);
test_IPropertySetStorage_TransactedMode2(pStorage);
test_IPropertySetStorage_SubPropertySet(pStorage);
test_IPropertySetStorage_CommitAtRoot(pStorage);
}
// IEnumSTATPROPSETSTG
//
// Check enumeration of property sets
//
// Check refcounting and IUnknown
//
// Create some property sets, predefined and not, simple and not, one through IStorage
// Enumerate them and check
// (check fmtid, grfFlags)
// (check when asking for more than there is: S_FALSE, S_OK)
// Delete one
// Reset the enumerator
// Enumerate them and check
// Delete one
//
// Reset the enumeratorA
// Read one from enumeratorA
// Clone enumerator -> enumeratorB
// Loop comparing rest of enumerator contents
//
// Reset the enumerator
// Skip all
// Check none left
//
// Reset the enumerator
// Skip all but one
// Check one left
//
void test_IEnumSTATPROPSETSTG(IStorage *pStorage)
{
Status( "IEnumSTATPROPSETSTG\n" );
FMTID afmtid[8];
CLSID aclsid[8];
IPropertyStorage *pPropSet;
memset( afmtid, 0, sizeof(afmtid) );
memset( aclsid, 0, sizeof(aclsid) );
IPropertySetStorage *pPropSetStg = NULL; // TSafeStorage< IPropertySetStorage > pPropSetStg(pStorage);
FILETIME ftStart;
Check( S_OK, StgToPropSetStg( pStorage, &pPropSetStg ));
CoFileTimeNow(&ftStart);
IEnumSTATPROPSETSTG *penum, *penum2;
STATPROPSETSTG StatBuffer[6];
Check(S_OK, pPropSetStg->Enum(&penum));
while( S_OK == penum->Next( 1, &StatBuffer[0], NULL ))
pPropSetStg->Delete( StatBuffer[0].fmtid );
RELEASE_INTERFACE( penum );
Check(S_OK, pPropSetStg->Enum(&penum));
Check( S_FALSE, penum->Next( 1, &StatBuffer[0], NULL ));
RELEASE_INTERFACE( penum );
for (int i=0; i<5; i++)
{
ULONG cFetched;
if (i & 4)
afmtid[i] = FMTID_SummaryInformation;
else
UuidCreate(&afmtid[i]);
UuidCreate(&aclsid[i]);
Check(S_OK, pPropSetStg->Create(
afmtid[i],
aclsid+i,
( (i & 1) && !(g_Restrictions & RESTRICT_SIMPLE_ONLY) ? PROPSETFLAG_NONSIMPLE : 0)
|
( (i & 2) && !(g_Restrictions & RESTRICT_UNICODE_ONLY) ? PROPSETFLAG_ANSI : 0),
STGM_READWRITE | STGM_DIRECT | STGM_SHARE_EXCLUSIVE,
&pPropSet));
pPropSet->Release();
Check(S_OK, pPropSetStg->Enum(&penum));
Check( S_FALSE, penum->Next( i+2, &StatBuffer[0], &cFetched ));
Check( S_OK, penum->Reset() );
Check( S_OK, penum->Next( i+1, &StatBuffer[0], &cFetched ));
RELEASE_INTERFACE( penum );
}
ULONG celt;
Check(S_OK, pPropSetStg->Enum(&penum));
IUnknown *punk, *punk2;
IEnumSTATPROPSETSTG *penum3;
Check(S_OK, penum->QueryInterface(IID_IUnknown, (void**)&punk));
Check(S_OK, punk->QueryInterface(IID_IEnumSTATPROPSETSTG, (void**)&penum3));
Check(S_OK, penum->QueryInterface(IID_IEnumSTATPROPSETSTG, (void**)&punk2));
Check(TRUE, punk == punk2);
punk->Release();
penum3->Release();
punk2->Release();
// test S_FALSE
Check(S_FALSE, penum->Next(6, StatBuffer, &celt));
Check(TRUE, celt == 5);
penum->Reset();
// test reading half out, then cloning, then comparing
// rest of enumeration with other clone.
Check(S_OK, penum->Next(3, StatBuffer, &celt));
Check(TRUE, celt == 3);
celt = 0;
Check(S_OK, penum->Clone(&penum2));
Check(S_OK, penum->Next(2, StatBuffer, &celt));
Check(TRUE, celt == 2);
// check the clone
for (int c=0; c<2; c++)
{
STATPROPSETSTG CloneStat;
Check(S_OK, penum2->Next(1, &CloneStat, NULL));
Check(TRUE, 0 == memcmp(&CloneStat, StatBuffer+c, sizeof(CloneStat)));
Check(TRUE, CloneStat.dwOSVersion == PROPSETHDR_OSVERSION_UNKNOWN);
}
// check both empty
celt = 0;
Check(S_FALSE, penum->Next(1, StatBuffer, &celt));
Check(TRUE, celt == 0);
Check(S_FALSE, penum2->Next(1, StatBuffer, &celt));
Check(TRUE, celt == 0);
penum->Reset();
//
// loop deleting one propset at a time
// enumerate the propsets checking that correct ones appear.
//
for (ULONG d = 0; d<5; d++)
{
// d is for delete
BOOL afFound[5];
Check(S_FALSE, penum->Next(5+1-d, StatBuffer, &celt));
Check(TRUE, celt == 5-d );
penum->Reset();
memset(afFound, 0, sizeof(afFound));
for (ULONG iPropSet=0; iPropSet<5; iPropSet++)
{
for (ULONG iSearch=0; iSearch<5-d; iSearch++)
{
if (0 == memcmp(&StatBuffer[iSearch].fmtid, &afmtid[iPropSet], sizeof(StatBuffer[0].fmtid)))
{
Check(FALSE, afFound[iPropSet]);
afFound[iPropSet] = TRUE;
break;
}
}
if (iPropSet < d)
Check(FALSE, afFound[iPropSet]);
if (iSearch == 5-d)
{
Check(TRUE, iPropSet < d);
continue;
}
Check(TRUE, ( (StatBuffer[iSearch].grfFlags & PROPSETFLAG_NONSIMPLE) ? 1u : 0u )
==
( (!(g_Restrictions & RESTRICT_SIMPLE_ONLY) && (iPropSet & 1)) ? 1u : 0u)
);
Check(TRUE, (StatBuffer[iSearch].grfFlags & PROPSETFLAG_ANSI) == 0);
// We should have a clsid if this is a non-simple property set and we're not disallowing
// hierarchical storages (i.e. it's not NTFS).
if( (PROPSETFLAG_NONSIMPLE & StatBuffer[iSearch].grfFlags) && !(RESTRICT_NON_HIERARCHICAL & g_Restrictions) )
Check(TRUE, StatBuffer[iSearch].clsid == aclsid[iPropSet]);
else
Check(TRUE, StatBuffer[iSearch].clsid == CLSID_NULL);
CheckTime(ftStart, StatBuffer[iSearch].mtime);
CheckTime(ftStart, StatBuffer[iSearch].atime);
CheckTime(ftStart, StatBuffer[iSearch].ctime);
}
Check(S_OK, pPropSetStg->Delete(afmtid[d]));
penum->Release();
Check(S_OK, pPropSetStg->Enum(&penum));
// Check(S_OK, penum->Reset());
}
penum->Release();
penum2->Release();
pPropSetStg->Release();
}
// Creation tests
//
// Access flags/Valid parameters/Permissions
// Check readonly cannot be written -
// WriteProperties, WritePropertyNames
void
test_IPropertyStorage_Access(IStorage *pStorage)
{
Status( "IPropertyStorage creation (access) tests\n" );
IPropertySetStorage *pPropSetStg = NULL; // TSafeStorage< IPropertySetStorage > pPropSetStg(pStorage);
FMTID fmtid;
ULONG cStorageRefs = GetRefCount(pStorage);
Check( S_OK, StgToPropSetStg( pStorage, &pPropSetStg ));
UuidCreate(&fmtid);
// check by name
IPropertyStorage *pPropStg;
Check(S_OK, pPropSetStg->Create(fmtid, NULL, 0,
STGM_SHARE_EXCLUSIVE | STGM_READWRITE, &pPropStg));
// QueryInterface tests
// QI to IPropertyStorage
// QI to IUnknown on IPropertyStorage
// QI back to IPropertyStorage from IUnknown
//
// Release all.
IPropertyStorage *pPropStg2,*pPropStg3;
IUnknown *punk;
Check(S_OK, pPropStg->QueryInterface(IID_IPropertyStorage,
(void**)&pPropStg2));
Check(S_OK, pPropStg->QueryInterface(IID_IUnknown,
(void**)&punk));
Check(S_OK, punk->QueryInterface(IID_IPropertyStorage,
(void**)&pPropStg3));
pPropStg3->Release();
pPropStg2->Release();
punk->Release();
PROPSPEC ps;
ps.ulKind = PRSPEC_LPWSTR;
ps.lpwstr = OLESTR("testprop");
PROPVARIANT pv;
pv.vt = VT_LPSTR;
pv.pszVal = (LPSTR) "testval";
Check(S_OK, pPropStg->WriteMultiple(1, &ps, &pv, 2));
pPropStg->Release();
Check(S_OK, pPropSetStg->Open(fmtid, STGM_SHARE_EXCLUSIVE | STGM_READ, &pPropStg));
Check(STG_E_ACCESSDENIED, pPropStg->WriteMultiple(1, &ps, &pv, 2));
Check(STG_E_ACCESSDENIED, pPropStg->DeleteMultiple(1, &ps));
PROPID propid=3;
Check(STG_E_ACCESSDENIED, pPropStg->WritePropertyNames(1, &propid, (LPOLESTR*) &pv.pszVal));
Check(STG_E_ACCESSDENIED, pPropStg->DeletePropertyNames(1, &propid));
FILETIME ft;
Check(STG_E_ACCESSDENIED, pPropStg->SetTimes(&ft, &ft, &ft));
CLSID clsid;
Check(STG_E_ACCESSDENIED, pPropStg->SetClass(clsid));
RELEASE_INTERFACE(pPropStg);
RELEASE_INTERFACE(pPropSetStg);
}
// Creation tests
// Check VT_STREAM etc not usable with simple.
//
void
test_IPropertyStorage_Create(IStorage *pStorage)
{
Status( "IPropertyStorage creation (simple/non-simple) tests\n" );
IPropertySetStorage *pPropSetStg = NULL;
FMTID fmtid;
ULONG cStorageRefs = GetRefCount( pStorage );
Check( S_OK, StgToPropSetStg( pStorage, &pPropSetStg ));
UuidCreate(&fmtid);
// check by name
IPropertyStorage *pPropStg;
Check(S_OK, pPropSetStg->Create(fmtid, NULL, PROPSETFLAG_DEFAULT,
STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE,
&pPropStg));
PROPSPEC ps;
ps.ulKind = PRSPEC_PROPID;
ps.propid = 2;
PROPVARIANT pv;
pv.vt = VT_STREAM;
pv.pStream = NULL;
Check(STG_E_PROPSETMISMATCHED, pPropStg->WriteMultiple(1, &ps, &pv, 2000));
pPropStg->Release();
Check( cStorageRefs, RELEASE_INTERFACE(pStorage) );
}
//
//
// Stat (Create four combinations)
// Check non-simple/simple flag
// Check ansi/wide fflag
// Also test clsid on propset
void test_IPropertyStorage_Stat(IStorage *pStorage)
{
Status( "IPropertyStorage::Stat\n" );
DWORD dwOSVersion = 0;
IPropertySetStorage *pPropSetStg = NULL; // TSafeStorage< IPropertySetStorage > pPropSetStg(pStorage);
FMTID fmtid;
UuidCreate(&fmtid);
IPropertyStorage *pPropSet;
STATPROPSETSTG StatPropSetStg;
ULONG cStorageRefs = GetRefCount( pStorage );
Check( S_OK, StgToPropSetStg( pStorage, &pPropSetStg ));
// Calculate the OS Version
#ifdef _MAC
{
// Get the Mac System Version (e.g., 7.53).
OSErr oserr;
SysEnvRec theWorld;
oserr = SysEnvirons( curSysEnvVers, &theWorld );
Check( TRUE, noErr == oserr );
dwOSVersion = MAKEPSVER( OSKIND_MACINTOSH,
HIBYTE(theWorld.systemVersion),
LOBYTE(theWorld.systemVersion) );
}
#else
dwOSVersion = MAKELONG( LOWORD(GetVersion()), OSKIND_WIN32 );
#endif
for (ULONG i=0; i<4; i++)
{
FILETIME ftStart;
CoFileTimeNow(&ftStart);
memset(&StatPropSetStg, 0, sizeof(StatPropSetStg));
CLSID clsid;
UuidCreate(&clsid);
Check(S_OK, pPropSetStg->Create(fmtid, &clsid,
((i & 1) && 0 == (g_Restrictions & RESTRICT_SIMPLE_ONLY) ? PROPSETFLAG_NONSIMPLE : 0)
|
((i & 2) && 0 == (g_Restrictions & RESTRICT_UNICODE_ONLY) ? PROPSETFLAG_ANSI : 0),
STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE,
&pPropSet));
CheckStat(pPropSet, fmtid,
clsid,
(
((i & 1) && !(g_Restrictions & RESTRICT_SIMPLE_ONLY) ? PROPSETFLAG_NONSIMPLE : 0)
|
((i & 2) && !(g_Restrictions & RESTRICT_UNICODE_ONLY) ? PROPSETFLAG_ANSI : 0)
),
ftStart, dwOSVersion );
pPropSet->Release();
Check(S_OK, pPropSetStg->Open(fmtid,
STGM_SHARE_EXCLUSIVE | STGM_READWRITE,
&pPropSet));
CheckStat(pPropSet, fmtid, clsid,
((i & 1) && !(g_Restrictions & RESTRICT_SIMPLE_ONLY) ? PROPSETFLAG_NONSIMPLE : 0) |
((i & 2) && !(g_Restrictions & RESTRICT_UNICODE_ONLY)? PROPSETFLAG_ANSI : 0), ftStart, dwOSVersion );
UuidCreate(&clsid);
Check(S_OK, pPropSet->SetClass(clsid));
pPropSet->Release();
Check(S_OK, pPropSetStg->Open(fmtid,
STGM_SHARE_EXCLUSIVE | STGM_READWRITE,
&pPropSet));
CheckStat(pPropSet, fmtid, clsid,
((i & 1) && !(g_Restrictions & RESTRICT_SIMPLE_ONLY) ? PROPSETFLAG_NONSIMPLE : 0)
|
((i & 2) && !(g_Restrictions & RESTRICT_UNICODE_ONLY) ? PROPSETFLAG_ANSI : 0), ftStart, dwOSVersion );
pPropSet->Release();
}
RELEASE_INTERFACE(pPropSetStg);
}
// ReadMultiple
// Check none found S_FALSE
//
// Success case non-simple readmultiple
// Create a non-simple property set
// Create two sub non-simples
// Close all
// Open the non-simple
// Query for the two sub-nonsimples
// Try writing to them
// Close all
// Open the non-simple
// Query for the two sub-nonsimples
// Check read back
// Close all
void
test_IPropertyStorage_ReadMultiple_Normal(IStorage *pStorage)
{
if( g_Restrictions & RESTRICT_SIMPLE_ONLY ) return;
Status( "IPropertyStorage::ReadMultiple (normal)\n" );
IPropertySetStorage *pPropSetStg = NULL;
FMTID fmtid;
UuidCreate(&fmtid);
IPropertyStorage *pPropSet;
ULONG cStorageRefs = GetRefCount( pStorage );
Check( S_OK, StgToPropSetStg( pStorage, &pPropSetStg ));
Check(S_OK, pPropSetStg->Create(fmtid, NULL,
PROPSETFLAG_NONSIMPLE,
STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE,
&pPropSet));
// none found
PROPSPEC ps[2];
ps[0].ulKind = PRSPEC_LPWSTR;
ps[0].lpwstr = L"testname";
ps[1].ulKind = PRSPEC_PROPID;
ps[1].propid = 1000;
PROPVARIANT pv[2];
PROPVARIANT pvSave[2];
PROPVARIANT pvExtra[2];
Check(S_FALSE, pPropSet->ReadMultiple(2, ps, pv));
PropVariantInit( &pv[0] );
pv[0].vt = VT_STREAM;
pv[0].pStream = NULL;
PropVariantInit( &pv[1] );
pv[1].vt = VT_STORAGE;
pv[1].pStorage = NULL;
memcpy(pvSave, pv, sizeof(pvSave));
memcpy(pvExtra, pv, sizeof(pvExtra));
// write the two sub non-simples
Check(S_OK, pPropSet->WriteMultiple(2, ps, pv, 1000));
// re-open them
Check(S_OK, pPropSet->ReadMultiple(2, ps, pv));
Check(TRUE, pv[0].pStream != NULL);
Check(TRUE, pv[1].pStorage != NULL);
// check status of write when already open
Check(S_OK, pPropSet->WriteMultiple(2, ps, pvSave, 1000));
Check(STG_E_REVERTED, pv[0].pStream->Commit(0));
Check(STG_E_REVERTED, pv[1].pStorage->Commit(0));
Check(S_OK, pPropSet->ReadMultiple(2, ps, pvExtra));
Check(TRUE, pvExtra[0].pStream != NULL);
Check(TRUE, pvExtra[1].pStorage != NULL);
Check(S_OK, pvExtra[0].pStream->Commit(0));
Check(S_OK, pvExtra[1].pStorage->Commit(0));
pvExtra[0].pStream->Release();
pvExtra[1].pStorage->Release();
pv[0].pStream->Release();
pv[1].pStorage->Release();
Check(S_OK, pPropSet->ReadMultiple(2, ps, pv));
Check(TRUE, pv[0].pStream != NULL);
Check(TRUE, pv[1].pStorage != NULL);
Check(S_OK, pv[0].pStream->Write("billmotest", sizeof("billmotest"), NULL));
IStream *pStm;
Check(S_OK, pv[1].pStorage->CreateStream(OLESTR("teststream"),
STGM_READWRITE | STGM_SHARE_EXCLUSIVE,
0, 0, &pStm));
pStm->Release();
pv[0].pStream->Release();
pv[1].pStorage->Release();
pPropSet->Release();
// re-re-open them
Check(S_OK, pPropSetStg->Open(fmtid,
STGM_SHARE_EXCLUSIVE | STGM_READWRITE,
&pPropSet));
Check(S_OK, pPropSet->ReadMultiple(2, ps, pv));
Check(TRUE, pv[0].pStream != NULL);
Check(TRUE, pv[0].pStorage != NULL);
// read the stream and storage and check the contents.
char szBillMo[32];
Check(S_OK, pv[0].pStream->Read(szBillMo, 11, NULL));
Check(TRUE, 0 == strcmp(szBillMo, "billmotest"));
Check(S_OK, pv[1].pStorage->OpenStream(OLESTR("teststream"), NULL,
STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &pStm));
pStm->Release();
pv[1].pStorage->Release();
pv[0].pStream->Release();
pPropSet->Release();
RELEASE_INTERFACE(pPropSetStg);
}
//
// CleanupOpenedObjects for ReadMultiple (two iterations one for "VT_STORAGE then VT_STREAM", one for
// "VT_STREAM then VT_STORAGE")
// Create property set
// Create a "VT_STREAM then VT_STORAGE"
// Open the second one exclusive
// Formulate a query so that both are read - > will fail but ...
// Check that the first one is still openable
//
void
test_IPropertyStorage_ReadMultiple_Cleanup(IStorage *pStorage)
{
if( g_Restrictions & RESTRICT_SIMPLE_ONLY ) return;
Status( "IPropertyStorage::ReadMultiple (cleanup)\n" );
IPropertySetStorage *pPropSetStg = NULL; // TSafeStorage< IPropertySetStorage > pPropSetStg(pStorage);
FMTID fmtid;
ULONG cStorageRefs = GetRefCount( pStorage );
Check( S_OK, StgToPropSetStg( pStorage, &pPropSetStg ));
UuidCreate(&fmtid);
for (LONG i=0;i<2;i++)
{
IPropertyStorage * pPropSet;
Check(S_OK, pPropSetStg->Create(fmtid, NULL,
PROPSETFLAG_NONSIMPLE,
STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE,
&pPropSet));
// none found
PROPSPEC ps[2];
ps[0].ulKind = PRSPEC_PROPID;
ps[0].propid = 1000;
ps[1].ulKind = PRSPEC_PROPID;
ps[1].propid = 2000;
PROPVARIANT pv[2];
pv[0].vt = (i == 0) ? VT_STREAM : VT_STORAGE;
pv[0].pStream = NULL;
pv[1].vt = (i == 1) ? VT_STORAGE : VT_STREAM;
pv[1].pStorage = NULL;
// write the two sub non-simples
// OFS gives driver internal error when overwriting a stream with a storage.
Check(S_OK, pPropSet->WriteMultiple(2, ps, pv, 1000));
// open both
Check(S_OK, pPropSet->ReadMultiple(2, ps, pv)); // **
// close the first ONLY and reopen both
PROPVARIANT pv2[2];
if (i==0)
pv[0].pStream->Release();
else
pv[0].pStorage->Release();
// reading both should fail because second is still open
Check(STG_E_ACCESSDENIED, pPropSet->ReadMultiple(2, ps, pv2));
// failure should not prevent this from succeeding
Check(S_OK, pPropSet->ReadMultiple(1, ps, pv2)); // ***
// cleanup from ** and ***
if (i==0)
{
pv2[0].pStream->Release(); // ***
pv[1].pStorage->Release(); // **
}
else
{
pv2[0].pStorage->Release(); // ***
pv[1].pStream->Release(); // **
}
pPropSet->Release();
}
RELEASE_INTERFACE(pPropSetStg);
}
// Reading an inconsistent non-simple
// Create a non-simple
// Create a sub-stream/storage
// Close all
// Delete the actual stream
// Read the indirect property -> should not exist.
//
void
test_IPropertyStorage_ReadMultiple_Inconsistent(IStorage *pStorage)
{
if( g_Restrictions & RESTRICT_SIMPLE_ONLY ) return;
if( PROPIMP_NTFS == g_enumImplementation ) return;
Status( "IPropertyStorage::ReadMultiple (inconsistent test)\n" );
IPropertySetStorage *pPropSetStg = NULL;
FMTID fmtid;
ULONG cStorageRefs = GetRefCount( pStorage );
Check( S_OK, StgToPropSetStg( pStorage, &pPropSetStg ));
UuidCreate(&fmtid);
IPropertyStorage * pPropSet;
Check(S_OK, pPropSetStg->Create(fmtid, NULL,
PROPSETFLAG_NONSIMPLE,
STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE,
&pPropSet));
// none found
PROPSPEC ps[3];
ps[0].ulKind = PRSPEC_PROPID;
ps[0].propid = 1000;
ps[1].ulKind = PRSPEC_PROPID;
ps[1].propid = 2000;
ps[2].ulKind = PRSPEC_PROPID;
ps[2].propid = 3000;
PROPVARIANT pv[3];
pv[0].vt = VT_STREAM;
pv[0].pStream = NULL;
pv[1].vt = VT_STORAGE;
pv[1].pStorage = NULL;
pv[2].vt = VT_UI4;
pv[2].ulVal = 12345678;
// write the two sub non-simples
Check(S_OK, pPropSet->WriteMultiple(3, ps, pv, 1000));
pPropSet->Release();
Check(S_OK, pStorage->Commit(STGC_DEFAULT));
// delete the propsets
OLECHAR ocsPropsetName[48];
// get name of the propset storage
RtlGuidToPropertySetName(&fmtid, ocsPropsetName);
// open it
CTempStorage pStgPropSet(coOpen, pStorage, ocsPropsetName);
// enumerate the non-simple properties.
IEnumSTATSTG *penum;
STATSTG stat[4];
ULONG celt;
Check(S_OK, pStgPropSet->EnumElements(0, NULL, 0, &penum));
Check(S_OK, penum->Next(3, stat, &celt));
penum->Release();
for (ULONG i=0;i<celt;i++)
{
if (ocscmp(OLESTR("CONTENTS"), stat[i].pwcsName) != 0)
pStgPropSet->DestroyElement(stat[i].pwcsName);
delete [] stat[i].pwcsName;
}
pStgPropSet.Release();
Check(S_OK, pPropSetStg->Open(fmtid,
STGM_SHARE_EXCLUSIVE | STGM_READWRITE,
&pPropSet));
Check(S_OK, pPropSet->ReadMultiple(3, ps, pv));
Check(TRUE, pv[0].vt == VT_EMPTY);
Check(TRUE, pv[1].vt == VT_EMPTY);
Check(TRUE, pv[2].vt == VT_UI4);
Check(TRUE, pv[2].ulVal == 12345678);
pPropSet->Release();
RELEASE_INTERFACE(pPropSetStg);
}
void
test_IPropertyStorage_ReadMultiple(IStorage *pStorage)
{
test_IPropertyStorage_ReadMultiple_Normal(pStorage);
test_IPropertyStorage_ReadMultiple_Cleanup(pStorage);
test_IPropertyStorage_ReadMultiple_Inconsistent(pStorage);
}
// Overwrite a non-simple property with a simple in a simple propset
void
test_IPropertyStorage_WriteMultiple_Overwrite1(IStorage *pStgBase)
{
if( g_Restrictions & RESTRICT_SIMPLE_ONLY ) return;
if( PROPIMP_NTFS == g_enumImplementation ) return;
Status( "IPropertyStorage::WriteMultiple (overwrite 1)\n" );
CTempStorage pStgSimple(coCreate, pStgBase, OLESTR("ov1_simp"));
CTempStorage pStorage(coCreate, pStgBase, OLESTR("ov1_stg"));
IPropertySetStorage *pPropSetStg = NULL;
IPropertySetStorage *pPropSetSimpleStg = NULL;
FMTID fmtid, fmtidSimple;
UuidCreate(&fmtid);
UuidCreate(&fmtidSimple);
ULONG cStorageRefs = GetRefCount( pStorage );
Check( S_OK, StgToPropSetStg( pStorage, &pPropSetStg ));
Check( S_OK, StgToPropSetStg( pStgSimple, &pPropSetSimpleStg ));
// create a simple set with a non-simple child by copying the contents
// stream a non-simple to a property set stream (simple)
// create a nonsimple propset (will contain the contents stream)
IPropertyStorage * pPropSet;
Check(S_OK, pPropSetStg->Create(fmtid, NULL,
PROPSETFLAG_NONSIMPLE,
STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE,
&pPropSet));
// none found
PROPSPEC ps[2];
ps[0].ulKind = PRSPEC_PROPID;
ps[0].propid = 1000;
ps[1].ulKind = PRSPEC_LPWSTR;
ps[1].lpwstr = OLESTR("foobar");
PROPVARIANT pv[2];
pv[0].vt = VT_STREAM;
pv[0].pStream = NULL;
pv[1].vt = VT_UI1;
pv[1].bVal = 66;
Check(S_OK, pPropSet->WriteMultiple(2, ps, pv, 100));
// invalid parameter
PROPVARIANT pvInvalid[2];
PROPSPEC psInvalid[2];
psInvalid[0].ulKind = PRSPEC_PROPID;
psInvalid[0].propid = 1000;
psInvalid[1].ulKind = PRSPEC_PROPID;
psInvalid[1].propid = 1001;
pvInvalid[0].vt = (VARTYPE)-99;
pvInvalid[1].vt = (VARTYPE)-100;
Check(HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED), pPropSet->WriteMultiple(1, psInvalid, pvInvalid, 100));
Check(HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED), pPropSet->WriteMultiple(2, psInvalid, pvInvalid, 100));
pPropSet->Release();
// create a simple propset (will be overwritten)
IPropertyStorage * pPropSetSimple;
Check(S_OK, pPropSetSimpleStg->Create(fmtidSimple, NULL,
0,
STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE,
&pPropSetSimple));
pPropSetSimple->Release();
OLECHAR ocsNonSimple[48];
OLECHAR ocsSimple[48];
// get the name of the simple propset
RtlGuidToPropertySetName(&fmtidSimple, ocsSimple);
// get the name of the non-simple propset
RtlGuidToPropertySetName(&fmtid, ocsNonSimple);
// open non-simple as a storage (will copy the simple to this)
IStorage *pstgPropSet;
Check(S_OK, pStorage->OpenStorage(ocsNonSimple, NULL,
STGM_SHARE_EXCLUSIVE | STGM_READWRITE, NULL, 0, &pstgPropSet));
// copy the contents of the non-simple to the propset of the simple
IStream *pstmNonSimple;
Check(S_OK, pstgPropSet->OpenStream(OLESTR("CONTENTS"), NULL,
STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &pstmNonSimple));
IStream *pstmSimple;
Check(S_OK, pStgSimple->OpenStream(ocsSimple,
NULL, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &pstmSimple));
ULARGE_INTEGER uli;
memset(&uli, 0xff, sizeof(uli));
Check(S_OK, pstmNonSimple->CopyTo(pstmSimple, uli, NULL, NULL));
pstmSimple->Release();
pstmNonSimple->Release();
pstgPropSet->Release();
// But now the FMTID *in* the simple property set doesn't
// match the string-ized FMTID which is the Stream's name. So,
// rename the Stream to match the property set's FMTID.
Check(S_OK, pStgSimple->RenameElement( ocsSimple, ocsNonSimple ));
// now we have a simple propset with a non-simple VT type
Check(S_OK, pPropSetSimpleStg->Open(fmtid, // Use the non-simple FMTID now
STGM_SHARE_EXCLUSIVE | STGM_READWRITE,
&pPropSetSimple));
Check(S_FALSE, pPropSetSimple->ReadMultiple(1, ps, pv));
Check(S_OK, pPropSetSimple->ReadMultiple(2, ps, pv));
Check(TRUE, pv[0].vt == VT_EMPTY);
Check(TRUE, pv[1].vt == VT_UI1);
Check(TRUE, pv[1].bVal == 66);
RELEASE_INTERFACE( pPropSetSimpleStg );
pPropSetSimple->Release();
RELEASE_INTERFACE(pPropSetStg);
}
// Overwrite a non-simple with a simple in a non-simple
// check that the non-simple is actually deleted
// Delete a non-simple
// check that the non-simple is actually deleted
void
test_IPropertyStorage_WriteMultiple_Overwrite2(IStorage *pStorage)
{
if( g_Restrictions & RESTRICT_SIMPLE_ONLY ) return;
if( PROPIMP_NTFS == g_enumImplementation ) return;
Status( "IPropertyStorage::WriteMultiple (overwrite 2)\n" );
IPropertySetStorage *pPropSetStg = NULL; // TSafeStorage< IPropertySetStorage > pPropSetStg(pStorage);
FMTID fmtid;
ULONG cStorageRefs = GetRefCount( pStorage );
Check( S_OK, StgToPropSetStg( pStorage, &pPropSetStg ));
UuidCreate(&fmtid);
IPropertyStorage *pPropSet;
Check(S_OK, pPropSetStg->Create(fmtid, NULL, PROPSETFLAG_NONSIMPLE,
STGM_SHARE_EXCLUSIVE | STGM_READWRITE, &pPropSet));
// create the non-simple
PROPSPEC ps[5];
ps[0].ulKind = PRSPEC_PROPID;
ps[0].propid = 1000;
ps[1].ulKind = PRSPEC_PROPID;
ps[1].propid = 1001;
ps[2].ulKind = PRSPEC_PROPID;
ps[2].propid = 1002;
ps[3].ulKind = PRSPEC_PROPID;
ps[3].propid = 1003;
ps[4].ulKind = PRSPEC_PROPID;
ps[4].propid = 1004;
PROPVARIANT pv[5];
pv[0].vt = VT_STORAGE;
pv[0].pStorage = NULL;
pv[1].vt = VT_STREAM;
pv[1].pStream = NULL;
pv[2].vt = VT_STORAGE;
pv[2].pStorage = NULL;
pv[3].vt = VT_STREAM;
pv[3].pStream = NULL;
pv[4].vt = VT_STREAM;
pv[4].pStream = NULL;
Check(S_OK, pPropSet->WriteMultiple(5, ps, pv, 2000));
pPropSet->Release();
// get the name of the propset
OLECHAR ocsPropsetName[48];
RtlGuidToPropertySetName(&fmtid, ocsPropsetName);
IStorage *pstgPropSet;
Check(S_OK, pStorage->OpenStorage(ocsPropsetName, NULL,
STGM_SHARE_EXCLUSIVE|STGM_READWRITE,
NULL, 0, &pstgPropSet));
// get the names of the non-simple property
IEnumSTATSTG *penum;
STATSTG statProp[6];
ULONG celt;
Check(S_OK, pstgPropSet->EnumElements(0, NULL, 0, &penum));
Check(S_OK, penum->Next(5, statProp, &celt));
Check(TRUE, celt == 5);
delete [] statProp[0].pwcsName;
delete [] statProp[1].pwcsName;
delete [] statProp[2].pwcsName;
delete [] statProp[3].pwcsName;
delete [] statProp[4].pwcsName;
penum->Release();
// reopen the property set and delete the non-simple
pstgPropSet->Release();
Check(S_OK, pPropSetStg->Open(fmtid, STGM_SHARE_EXCLUSIVE | STGM_READWRITE,
&pPropSet));
pv[0].vt = VT_LPWSTR;
pv[0].pwszVal = L"Overwrite1";
pv[1].vt = VT_LPWSTR;
pv[1].pwszVal = L"Overwrite2";
pv[2].vt = VT_LPWSTR;
pv[2].pwszVal = L"Overwrite3";
pv[3].vt = VT_LPWSTR;
pv[3].pwszVal = L"Overwrite4";
pv[4].vt = VT_LPWSTR;
pv[4].pwszVal = L"Overwrite5";
Check(S_OK, pPropSet->WriteMultiple(2, ps, pv, 2000));
Check(S_OK, pPropSet->DeleteMultiple(1, ps+2));
Check(S_OK, pPropSet->DeleteMultiple(2, ps+3));
pPropSet->Release();
// open the propset as storage again and check that the VT_STORAGE is gone.
Check(S_OK, pStorage->OpenStorage(ocsPropsetName, NULL,
STGM_SHARE_EXCLUSIVE|STGM_READWRITE,
NULL, 0, &pstgPropSet));
// check they were removed
STATSTG statProp2[5];
Check(S_OK, pstgPropSet->EnumElements(0, NULL, 0, &penum));
Check(S_FALSE, penum->Next(5, statProp2, &celt));
Check(TRUE, celt == 1); // contents
delete [] statProp2[0].pwcsName;
penum->Release();
pstgPropSet->Release();
RELEASE_INTERFACE(pPropSetStg);
}
// Write a VT_STORAGE over a VT_STREAM
// check for cases: when not already open, when already open(access denied)
// Write a VT_STREAM over a VT_STORAGE
// check for cases: when not already open, when already open(access denied)
void
test_IPropertyStorage_WriteMultiple_Overwrite3(IStorage *pStorage)
{
if( g_Restrictions & RESTRICT_SIMPLE_ONLY ) return;
Status( "IPropertyStorage::WriteMultiple (overwrite 3)\n" );
IPropertySetStorage *pPropSetStg = NULL; // TSafeStorage< IPropertySetStorage > pPropSetStg(pStorage);
FMTID fmtid;
ULONG cStorageRefs = GetRefCount( pStorage );
Check( S_OK, StgToPropSetStg( pStorage, &pPropSetStg ));
UuidCreate(&fmtid);
IPropertyStorage *pPropSet;
Check(S_OK, pPropSetStg->Create(fmtid, NULL, PROPSETFLAG_NONSIMPLE,
STGM_SHARE_EXCLUSIVE | STGM_READWRITE,
&pPropSet));
PROPSPEC ps[2];
ps[0].ulKind = PRSPEC_LPWSTR;
ps[0].lpwstr = OLESTR("stream_storage");
ps[1].ulKind = PRSPEC_LPWSTR;
ps[1].lpwstr = OLESTR("storage_stream");
PROPVARIANT pv[2];
pv[0].vt = VT_STREAMED_OBJECT;
pv[0].pStream = NULL;
pv[1].vt = VT_STORED_OBJECT;
pv[1].pStorage = NULL;
PROPVARIANT pvSave[2];
pvSave[0] = pv[0];
pvSave[1] = pv[1];
Check(S_OK, pPropSet->WriteMultiple(2, ps, pv, 1000));
// swap them around
PROPVARIANT pvTemp;
pvTemp = pv[0];
pv[0] = pv[1];
pv[1] = pvTemp;
Check(S_OK, pPropSet->WriteMultiple(2, ps, pv, 1000));
memset(pv, 0, sizeof(pv));
Check(S_OK, pPropSet->ReadMultiple(2, ps, pv));
Check(TRUE, pv[0].vt == VT_STORED_OBJECT);
Check(TRUE, pv[1].vt == VT_STREAMED_OBJECT);
Check(TRUE, pv[0].pStorage != NULL);
Check(TRUE, pv[1].pStream != NULL);
STATSTG stat; stat.type = 0;
Check(S_OK, pv[0].pStorage->Stat(&stat, STATFLAG_NONAME));
Check(TRUE, stat.type == STGTY_STORAGE);
Check(S_OK, pv[1].pStream->Stat(&stat, STATFLAG_NONAME));
Check(TRUE, stat.type == STGTY_STREAM);
STATSTG stat2; stat2.type = 0;
// swap them around again, but this time with access denied
Check(S_OK, pPropSet->WriteMultiple(2, ps, pvSave, 1000));
Check(STG_E_REVERTED, pv[0].pStorage->Stat(&stat, STATFLAG_NONAME));
pv[0].pStorage->Release();
Check(S_OK, pPropSet->WriteMultiple(2, ps, pvSave, 1000));
Check(STG_E_REVERTED, pv[1].pStream->Stat(&stat, STATFLAG_NONAME));
pv[1].pStream->Release();
pPropSet->Release();
RELEASE_INTERFACE(pPropSetStg);
}
//
// test using IStorage::Commit to commit the changes in a nested
// property set
//
void
test_IPropertyStorage_Commit(IStorage *pStorage)
{
if( g_Restrictions & ( RESTRICT_SIMPLE_ONLY | RESTRICT_DIRECT_ONLY) ) return;
Status( "IPropertyStorage::Commit\n" );
// 8 scenarios: (simple+non-simple) * (direct+transacted) * (release only + commit storage + commit propset)
for (int i=0; i<32; i++)
{
CTempStorage pDeeper(coCreate, pStorage, GetNextTest(), (i & 1) ? STGM_TRANSACTED : STGM_DIRECT);
IPropertySetStorage *pPropSetStg = NULL; // TSafeStorage< IPropertySetStorage > pPropSetStg(pDeeper);
FMTID fmtid;
ULONG cDeeperRefs = GetRefCount( pDeeper );
Check( S_OK, StgToPropSetStg( pDeeper, &pPropSetStg ));
UuidCreate(&fmtid);
IPropertyStorage *pPropSet;
Check(S_OK, pPropSetStg->Create(fmtid, NULL, (i&8) ? PROPSETFLAG_NONSIMPLE : PROPSETFLAG_DEFAULT,
STGM_SHARE_EXCLUSIVE | STGM_READWRITE | ((i&16) && (i&8) ? STGM_TRANSACTED : STGM_DIRECT),
&pPropSet));
PROPSPEC ps;
ps.ulKind = PRSPEC_PROPID;
ps.propid = 100;
PROPVARIANT pv;
pv.vt = VT_I4;
pv.lVal = 1234;
Check(S_OK, pPropSet->WriteMultiple(1, &ps, &pv, 1000));
memset(&pv, 0, sizeof(pv));
Check(S_OK, pPropSet->ReadMultiple(1, &ps, &pv));
Check(TRUE, pv.lVal == 1234);
pv.lVal = 2345; // no size changes
Check(S_OK, pPropSet->WriteMultiple(1, &ps, &pv, 1000));
if (i & 4)
Check(S_OK, pPropSet->Commit(0));
if (i & 2)
Check(S_OK, pStorage->Commit(0));
Check(0, pPropSet->Release()); // implicit commit if i&2 is false
if (S_OK == pPropSetStg->Open(fmtid, STGM_SHARE_EXCLUSIVE | STGM_READWRITE,
&pPropSet))
{
memset(&pv, 0, sizeof(pv));
Check( !((i&16) && (i&8)) || (i&0x1c)==0x1c ? S_OK : S_FALSE, pPropSet->ReadMultiple(1, &ps, &pv));
if (!((i&16) && (i&8)) || (i&0x1c)==0x1c)
Check(TRUE, pv.lVal == 2345);
pPropSet->Release();
}
RELEASE_INTERFACE(pPropSetStg);
Check( cDeeperRefs, GetRefCount( pDeeper ));
}
}
void
test_IPropertyStorage_WriteMultiple(IStorage *pStorage)
{
test_IPropertyStorage_WriteMultiple_Overwrite1(pStorage);
test_IPropertyStorage_WriteMultiple_Overwrite2(pStorage);
test_IPropertyStorage_WriteMultiple_Overwrite3(pStorage);
test_IPropertyStorage_Commit(pStorage);
}
// this serves as a test for WritePropertyNames, ReadPropertyNames, DeletePropertyNames
// DeleteMultiple, PropVariantCopy, FreePropVariantArray.
void
test_IPropertyStorage_DeleteMultiple(IStorage *pStorage)
{
Status( "IPropertyStorage::DeleteMultiple\n" );
IPropertySetStorage *pPropSetStg = NULL; // TSafeStorage< IPropertySetStorage > pPropSetStg(pStorage);
FMTID fmtid;
ULONG cStorageRefs = GetRefCount( pStorage );
Check( S_OK, StgToPropSetStg( pStorage, &pPropSetStg ));
UuidCreate(&fmtid);
IPropertyStorage *pPropSet;
int PropId = 3;
for (int type=0; type<2; type++)
{
BOOL fSimple = ( type == 0 || (g_Restrictions & RESTRICT_SIMPLE_ONLY) );
UuidCreate(&fmtid);
Check(S_OK, pPropSetStg->Create(fmtid,
NULL,
fSimple ? PROPSETFLAG_DEFAULT : PROPSETFLAG_NONSIMPLE,
STGM_SHARE_EXCLUSIVE | STGM_READWRITE,
&pPropSet));
// create and delete each type.
PROPVARIANT *pVar;
for (int AtOnce=1; AtOnce <3; AtOnce++)
{
CGenProps gp;
int Actual;
while (pVar = gp.GetNext(AtOnce, &Actual, FALSE, fSimple ))
{
PROPSPEC ps[3];
PROPID rgpropid[3];
LPOLESTR rglpostrName[3];
OLECHAR aosz[3][16];
for (int s=0; s<3; s++)
{
PROPGENPROPERTYNAME( &aosz[s][0], PropId );
rgpropid[s] = PropId++;
rglpostrName[s] = &aosz[s][0];
ps[s].ulKind = PRSPEC_LPWSTR;
ps[s].lpwstr = &aosz[s][0];
}
for (int l=1; l<Actual; l++)
{
PROPVARIANT VarRead[3];
Check(S_FALSE, pPropSet->ReadMultiple(l, ps, VarRead));
Check(S_OK, pPropSet->WritePropertyNames(l, rgpropid, rglpostrName));
Check(S_FALSE, pPropSet->ReadMultiple(l, ps, VarRead));
Check(S_OK, pPropSet->WriteMultiple(l, ps, pVar, 1000));
Check(S_OK, pPropSet->ReadMultiple(l, ps, VarRead));
Check(S_OK, g_pfnFreePropVariantArray(l, VarRead));
Check(S_OK, pPropSet->DeleteMultiple(l, ps));
Check(S_FALSE, pPropSet->ReadMultiple(l, ps, VarRead));
Check(S_OK, g_pfnFreePropVariantArray(l, VarRead));
LPOLESTR rglpostrNameCheck[3];
Check(S_OK, pPropSet->ReadPropertyNames(l, rgpropid, rglpostrNameCheck));
for (int c=0; c<l; c++)
{
Check( 0, ocscmp(rglpostrNameCheck[c], rglpostrName[c]) );
delete [] rglpostrNameCheck[c];
}
Check(S_OK, pPropSet->DeletePropertyNames(l, rgpropid));
Check(S_FALSE, pPropSet->ReadPropertyNames(l, rgpropid, rglpostrNameCheck));
}
g_pfnFreePropVariantArray(Actual, pVar);
delete pVar;
}
}
pPropSet->Release();
}
RELEASE_INTERFACE(pPropSetStg);
}
void
test_IPropertyStorage(IStorage *pStorage)
{
test_IPropertyStorage_Access(pStorage);
test_IPropertyStorage_Create(pStorage);
test_IPropertyStorage_Stat(pStorage);
test_IPropertyStorage_ReadMultiple(pStorage);
test_IPropertyStorage_WriteMultiple(pStorage);
test_IPropertyStorage_DeleteMultiple(pStorage);
}
//
// Word6.0 summary information
// Open
// Read fields
// Stat
//
void test_Word6(IStorage *pStorage, CHAR *pszTemporaryDirectory)
{
Status( "Word 6.0 compatibility test\n" );
extern unsigned char g_achTestDoc[];
extern unsigned g_cbTestDoc;
OLECHAR oszTempFile[ MAX_PATH + 1 ];
CHAR szTempFile[ MAX_PATH + 1 ];
strcpy( szTempFile, pszTemporaryDirectory );
strcat( szTempFile, "word6.doc" );
PropTest_mbstoocs( oszTempFile, sizeof(oszTempFile), szTempFile );
PROPTEST_FILE_HANDLE hFile = PropTest_CreateFile( szTempFile );
#ifdef _MAC
Check(TRUE, (PROPTEST_FILE_HANDLE) -1 != hFile);
#else
Check(TRUE, INVALID_HANDLE_VALUE != hFile);
#endif
DWORD cbWritten;
PropTest_WriteFile(hFile, g_achTestDoc, g_cbTestDoc, &cbWritten);
Check(TRUE, cbWritten == g_cbTestDoc);
PropTest_CloseHandle(hFile);
IStorage *pStg;
Check(S_OK, g_pfnStgOpenStorageEx(oszTempFile,
STGM_READWRITE | STGM_SHARE_EXCLUSIVE,
STGFMT_ANY,
0, NULL, NULL,
IID_IStorage,
reinterpret_cast<void**>(&pStg) ));
IPropertySetStorage *pPropSetStg = NULL; // TSafeStorage< IPropertySetStorage > pPropSetStg(pStg);
IPropertyStorage *pPropStg;
ULONG cStorageRefs = GetRefCount( pStg );
Check( S_OK, StgToPropSetStg( pStg, &pPropSetStg ));
Check(S_OK, pPropSetStg->Open(FMTID_SummaryInformation,
STGM_SHARE_EXCLUSIVE | STGM_DIRECT | STGM_READ,
&pPropStg));
#define WORDPROPS 18
static struct tagWordTest {
VARENUM vt;
void *pv;
} avt[WORDPROPS] = {
VT_LPSTR, "Title of the document.", // PID_TITLE
VT_LPSTR, "Subject of the document.", // PID_SUBJECT
VT_LPSTR, "Author of the document.", // PID_AUTHOR
VT_LPSTR, "Keywords of the document.", // PID_KEYWORDS
VT_LPSTR, "Comments of the document.", // PID_COMMENTS
VT_LPSTR, "Normal.dot", // PID_TEMPLATE -- Normal.dot
VT_LPSTR, "Bill Morel", // PID_LASTAUTHOR --
VT_LPSTR, "3", // PID_REVNUMBER -- '3'
VT_EMPTY, 0, // PID_EDITTIME -- 3 Minutes FILETIME
VT_EMPTY, 0, // PID_LASTPRINTED -- 04/07/95 12:04 FILETIME
VT_EMPTY, 0, // PID_CREATE_DTM
VT_EMPTY, 0, // PID_LASTSAVE_DTM
VT_I4, (void*) 1, // PID_PAGECOUNT
VT_I4, (void*) 7, // PID_WORDCOUNT
VT_I4, (void*) 65, // PID_CHARCOUNT
VT_EMPTY, 0, // PID_THUMBNAIL
VT_LPSTR, "Microsoft Word 6.0", // PID_APPNAME
VT_I4, 0 }; // PID_SECURITY
PROPSPEC propspec[WORDPROPS+2];
for (int i=2; i<WORDPROPS+2; i++)
{
propspec[i].ulKind = PRSPEC_PROPID;
propspec[i].propid = (PROPID)i;
}
PROPVARIANT propvar[WORDPROPS+2];
Check(S_OK, pPropStg->ReadMultiple(WORDPROPS, propspec+2, propvar+2));
for (i=2; i<WORDPROPS+2; i++)
{
if ( propvar[i].vt != avt[i-2].vt )
{
PRINTF( " PROPTEST: 0x%x retrieved type 0x%x, expected type 0x%x\n",
i, propvar[i].vt, avt[i-2].vt );
Check(TRUE, propvar[i].vt == avt[i-2].vt);
}
switch (propvar[i].vt)
{
case VT_LPSTR:
Check(TRUE, strcmp(propvar[i].pszVal, (char*)avt[i-2].pv)==0);
break;
case VT_I4:
Check(TRUE, (ULONG_PTR) propvar[i].lVal == (ULONG_PTR)avt[i-2].pv);
break;
}
}
g_pfnFreePropVariantArray( WORDPROPS, propvar+2 );
RELEASE_INTERFACE( pPropStg );
RELEASE_INTERFACE( pPropSetStg );
Check( 0, RELEASE_INTERFACE(pStg) );
}
void
test_IEnumSTATPROPSTG(IStorage *pstgTemp)
{
Status( "IEnumSTATPROPSTG\n" );
PROPID apropid[8];
LPOLESTR alpostrName[8];
OLECHAR aosz[8][32];
PROPID PropId=2;
PROPSPEC ps[8];
FMTID fmtid;
IPropertyStorage *pPropStg;
IPropertySetStorage *pPropSetStg = NULL; // TSafeStorage< IPropertySetStorage > pPropSetStg(pstgTemp);
ULONG cStorageRefs = GetRefCount( pstgTemp );
Check( S_OK, StgToPropSetStg( pstgTemp, &pPropSetStg ));
UuidCreate(&fmtid);
for (int setup=0; setup<8; setup++)
{
alpostrName[setup] = &aosz[setup][0];
}
CGenProps gp;
// simple/non-simple, ansi/wide, named/not named
for (int outer=0; outer<8; outer++)
{
UuidCreate(&fmtid);
Check(S_OK, pPropSetStg->Create(fmtid, NULL,
((outer&4) && !(g_Restrictions & RESTRICT_SIMPLE_ONLY) ? PROPSETFLAG_NONSIMPLE : 0)
|
((outer&2) && !(g_Restrictions & RESTRICT_UNICODE_ONLY) ? PROPSETFLAG_ANSI : 0),
STGM_CREATE | STGM_READWRITE | STGM_DIRECT | STGM_SHARE_EXCLUSIVE,
&pPropStg));
for (int i=0; i<CPROPERTIES; i++)
{
apropid[i] = PropId++;
if (outer & 1)
{
ps[i].ulKind = PRSPEC_LPWSTR;
PROPGENPROPERTYNAME( aosz[i], apropid[i] );
ps[i].lpwstr = aosz[i];
}
else
{
ps[i].ulKind = PRSPEC_PROPID;
ps[i].propid = apropid[i];
}
}
if (outer & 1)
{
Check(S_OK, pPropStg->WritePropertyNames(CPROPERTIES, apropid, alpostrName));
}
PROPVARIANT *pVar = gp.GetNext(CPROPERTIES, NULL, TRUE, (outer&4)==0); // no non-simple
Check(TRUE, pVar != NULL);
Check(S_OK, pPropStg->WriteMultiple(CPROPERTIES, ps, pVar, 1000));
g_pfnFreePropVariantArray(CPROPERTIES, pVar);
delete pVar;
// Allocate enough STATPROPSTGs for one more than the actual properties
// in the set.
STATPROPSTG StatBuffer[CPROPERTIES+1];
ULONG celt;
IEnumSTATPROPSTG *penum, *penum2;
Check(S_OK, pPropStg->Enum(&penum));
IUnknown *punk, *punk2;
IEnumSTATPROPSTG *penum3;
Check(S_OK, penum->QueryInterface(IID_IUnknown, (void**)&punk));
Check(S_OK, punk->QueryInterface(IID_IEnumSTATPROPSTG, (void**)&penum3));
Check(S_OK, penum->QueryInterface(IID_IEnumSTATPROPSTG, (void**)&punk2));
Check(TRUE, punk == punk2);
punk->Release();
penum3->Release();
punk2->Release();
// test S_FALSE
Check(S_FALSE, penum->Next( CPROPERTIES+1, StatBuffer, &celt));
Check(TRUE, celt == CPROPERTIES);
CleanStat(celt, StatBuffer);
penum->Reset();
// test reading half out, then cloning, then comparing
// rest of enumeration with other clone.
Check(S_OK, penum->Next(CPROPERTIES/2, StatBuffer, &celt));
Check(TRUE, celt == CPROPERTIES/2);
CleanStat(celt, StatBuffer);
celt = 0;
Check(S_OK, penum->Clone(&penum2));
Check(S_OK, penum->Next(CPROPERTIES - CPROPERTIES/2, StatBuffer, &celt));
Check(TRUE, celt == CPROPERTIES - CPROPERTIES/2);
// check the clone
for (int c=0; c<CPROPERTIES - CPROPERTIES/2; c++)
{
STATPROPSTG CloneStat;
Check(S_OK, penum2->Next(1, &CloneStat, NULL));
Check(TRUE, IsEqualSTATPROPSTG(&CloneStat, StatBuffer+c));
CleanStat(1, &CloneStat);
}
CleanStat(celt, StatBuffer);
// check both empty
celt = 0;
Check(S_FALSE, penum->Next(1, StatBuffer, &celt));
Check(TRUE, celt == 0);
Check(S_FALSE, penum2->Next(1, StatBuffer, &celt));
Check(TRUE, celt == 0);
penum->Reset();
//
// loop deleting one property at a time
// enumerate the propertys checking that correct ones appear.
//
for (ULONG d = 0; d<CPROPERTIES; d++)
{
// d is for delete
BOOL afFound[CPROPERTIES];
ULONG cTotal = 0;
Check(S_OK, penum->Next(CPROPERTIES-d, StatBuffer, &celt));
Check(TRUE, celt == CPROPERTIES-d);
penum->Reset();
memset(afFound, 0, sizeof(afFound));
for (ULONG iProperty=0; iProperty<CPROPERTIES; iProperty++)
{
// Search the StatBuffer for this property.
for (ULONG iSearch=0; iSearch<CPROPERTIES-d; iSearch++)
{
// Compare this entry in the StatBuffer to the property for which we're searching.
// Use the lpstrName or propid, whichever is appropriate for this pass (indicated
// by 'outer').
if ( ( (outer & 1) == 1 && 0 == ocscmp(StatBuffer[iSearch].lpwstrName, ps[iProperty].lpwstr) )
||
( (outer & 1) == 0 && StatBuffer[iSearch].propid == apropid[iProperty] )
)
{
ASSERT (!afFound[iSearch]);
afFound[iSearch] = TRUE;
cTotal++;
break;
}
}
}
CleanStat(celt, StatBuffer);
Check(TRUE, cTotal == CPROPERTIES-d);
Check(S_OK, pPropStg->DeleteMultiple(1, ps+d));
Check(S_OK, penum->Reset());
}
penum->Release();
penum2->Release();
pPropStg->Release();
}
RELEASE_INTERFACE( pPropSetStg );
Check( cStorageRefs, GetRefCount(pstgTemp) );
}
void
test_MaxPropertyName(IStorage *pstgTemp)
{
if( PROPIMP_NTFS == g_enumImplementation ) return;
Status( "Max Property Name length\n" );
// ----------
// Initialize
// ----------
CPropVariant cpropvar;
// Create a new storage, because we're going to create
// well-known property sets, and this way we can be sure
// that they don't already exist.
IStorage *pstg = NULL; // TSafeStorage< IStorage > pstg;
Check(S_OK, pstgTemp->CreateStorage( OLESTR("MaxPropNameTest"),
STGM_CREATE | STGM_READWRITE | STGM_SHARE_EXCLUSIVE,
0L, 0L,
&pstg ));
// Generate a new Format ID.
FMTID fmtid;
UuidCreate(&fmtid);
// Get a IPropertySetStorage from the IStorage.
IPropertySetStorage *pPropSetStg = NULL; // TSafeStorage< IPropertySetStorage > pPropSetStg(pstg);
IPropertyStorage *pPropStg = NULL; // TSafeStorage< IPropertyStorage > pPropStg;
Check( S_OK, StgToPropSetStg( pstg, &pPropSetStg ));
// ----------------------------------
// Test the non-SumInfo property set.
// ----------------------------------
// Create a new PropertyStorage.
Check(S_OK, pPropSetStg->Create(fmtid,
NULL,
PROPSETFLAG_DEFAULT,
STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_DIRECT | STGM_READWRITE,
&pPropStg));
// Generate a property name which greater than the old max length
// (NT5 removes the name length limitation, was 255 not including the terminator).
OLECHAR *poszPropertyName;
poszPropertyName = new OLECHAR[ (CCH_MAXPROPNAMESZ+1) * sizeof(OLECHAR) ];
Check(TRUE, poszPropertyName != NULL );
for( ULONG ulIndex = 0; ulIndex < CCH_MAXPROPNAMESZ; ulIndex++ )
poszPropertyName[ ulIndex ] = OLESTR('a') + (OLECHAR) ( ulIndex % 26 );
poszPropertyName[ CCH_MAXPROPNAMESZ ] = OLESTR('\0');
// Write out a property with this oldmax+1 name.
PROPSPEC propspec;
propspec.ulKind = PRSPEC_LPWSTR;
propspec.lpwstr = poszPropertyName;
cpropvar = (long) 0x1234;
Check(S_OK, pPropStg->WriteMultiple( 1, &propspec, &cpropvar, PID_FIRST_USABLE ));
// Write out a property with a minimum-character name.
propspec.lpwstr = OLESTR("X");
Check(S_OK, pPropStg->WriteMultiple( 1, &propspec, &cpropvar, PID_FIRST_USABLE ));
// Write out a property with a below-minimum-character name.
propspec.lpwstr = OLESTR("");
Check(STG_E_INVALIDPARAMETER, pPropStg->WriteMultiple( 1, &propspec, &cpropvar, PID_FIRST_USABLE ));
delete [] poszPropertyName;
Check( 0, RELEASE_INTERFACE(pPropStg ));
RELEASE_INTERFACE(pPropSetStg);
Check( 0, RELEASE_INTERFACE(pstg) );
}
void
test_CodePages( LPOLESTR poszDirectory )
{
if( g_Restrictions & RESTRICT_UNICODE_ONLY ) return;
Status( "Code Page compatibility\n" );
// --------------
// Initialization
// --------------
OLECHAR oszBadFile[ MAX_PATH ];
OLECHAR oszGoodFile[ MAX_PATH ];
OLECHAR oszUnicodeFile[ MAX_PATH ];
OLECHAR oszMacFile[ MAX_PATH ];
HRESULT hr = S_OK;
IStorage *pStgBad = NULL, *pStgGood = NULL, *pStgUnicode = NULL, *pStgMac = NULL; // TSafeStorage< IStorage > pStgBad, pStgGood, pStgUnicode, pStgMac;
CPropVariant cpropvarWrite, cpropvarRead;
Check( TRUE, GetACP() == CODEPAGE_DEFAULT );
// ------------------------------
// Create test ANSI property sets
// ------------------------------
// Create a property set with a bad codepage.
ocscpy( oszBadFile, poszDirectory );
ocscat( oszBadFile, OLESTR( "\\BadCP.stg" ));
CreateCodePageTestFile( oszBadFile, &pStgBad );
ModifyPropSetCodePage( pStgBad, FMTID_NULL, CODEPAGE_BAD );
// Create a property set with a good codepage.
ocscpy( oszGoodFile, poszDirectory );
ocscat( oszGoodFile, OLESTR("\\GoodCP.stg") );
CreateCodePageTestFile( oszGoodFile, &pStgGood );
ModifyPropSetCodePage( pStgGood, FMTID_NULL, CODEPAGE_GOOD );
// Create a property set that has the OS Kind (in the
// header) set to "Mac".
ocscpy( oszMacFile, poszDirectory );
ocscat( oszMacFile, OLESTR("\\MacKind.stg") );
CreateCodePageTestFile( oszMacFile, &pStgMac );
ModifyOSVersion( pStgMac, 0x00010904 );
// ---------------------------
// Open the Ansi property sets
// ---------------------------
IPropertySetStorage *pPropSetStgBad = NULL; // TSafeStorage< IPropertySetStorage > pPropSetStgBad(pStgBad);
Check( S_OK, StgToPropSetStg( pStgBad, &pPropSetStgBad ));
IPropertySetStorage *pPropSetStgGood = NULL; // TSafeStorage< IPropertySetStorage > pPropSetStgGood(pStgGood);
Check( S_OK, StgToPropSetStg( pStgGood, &pPropSetStgGood ));
IPropertySetStorage *pPropSetStgMac = NULL; // TSafeStorage< IPropertySetStorage > pPropSetStgMac(pStgMac);
Check( S_OK, StgToPropSetStg( pStgMac, &pPropSetStgMac ));
IPropertyStorage *pPropStgBad = NULL, *pPropStgGood = NULL, *pPropStgMac = NULL;
Check(S_OK, pPropSetStgBad->Open(FMTID_NULL,
STGM_SHARE_EXCLUSIVE | STGM_DIRECT | STGM_READWRITE,
&pPropStgBad));
Check(S_OK, pPropSetStgGood->Open(FMTID_NULL,
STGM_SHARE_EXCLUSIVE | STGM_DIRECT | STGM_READWRITE,
&pPropStgGood));
Check(S_OK, pPropSetStgMac->Open(FMTID_NULL,
STGM_SHARE_EXCLUSIVE | STGM_DIRECT | STGM_READWRITE,
&pPropStgMac));
// ------------------------------------------
// Test BSTRs in the three ANSI property sets
// ------------------------------------------
PROPSPEC propspec;
PROPVARIANT propvar;
PropVariantInit( &propvar );
// Attempt to read by name.
propspec.ulKind = PRSPEC_LPWSTR;
propspec.lpwstr = CODEPAGE_TEST_NAMED_PROPERTY;
Check(S_OK,
pPropStgMac->ReadMultiple( 1, &propspec, &propvar ));
g_pfnPropVariantClear( &propvar );
#ifndef OLE2ANSI // No error is generated if BSTRs are Ansi
Check(
HRESULT_FROM_WIN32(ERROR_NO_UNICODE_TRANSLATION),
pPropStgBad->ReadMultiple( 1, &propspec, &propvar ));
#endif
Check(S_OK,
pPropStgGood->ReadMultiple( 1, &propspec, &propvar ));
// Attempt to write by name. If this test fails, it may be because
// the machine doesn't support CODEPAGE_GOOD (this is the case by default
// on Win95). To remedy this situation, go to control panel, add/remove
// programs, windows setup (tab), check MultiLanguage support, then
// click OK. You'll have to restart the computer after this.
Check(S_OK,
pPropStgMac->WriteMultiple( 1, &propspec, &propvar, PID_FIRST_USABLE ));
#ifndef OLE2ANSI // No error is generated if BSTRs are Ansi
Check(HRESULT_FROM_WIN32(ERROR_NO_UNICODE_TRANSLATION),
pPropStgBad->WriteMultiple( 1, &propspec, &propvar, PID_FIRST_USABLE ));
#endif
Check(S_OK,
pPropStgGood->WriteMultiple( 1, &propspec, &propvar, PID_FIRST_USABLE ));
g_pfnPropVariantClear( &propvar );
// Attempt to read the BSTR property
propspec.ulKind = PRSPEC_PROPID;
propspec.propid = CODEPAGE_TEST_UNNAMED_BSTR_PROPID;
Check(S_OK,
pPropStgMac->ReadMultiple( 1, &propspec, &propvar ));
g_pfnPropVariantClear( &propvar );
#ifndef OLE2ANSI // No error is generated if BSTRs are Ansi
Check(HRESULT_FROM_WIN32(ERROR_NO_UNICODE_TRANSLATION),
pPropStgBad->ReadMultiple( 1, &propspec, &propvar ));
#endif
Check(S_OK,
pPropStgGood->ReadMultiple( 1, &propspec, &propvar ));
// Attempt to write the BSTR property
Check(S_OK,
pPropStgMac->WriteMultiple( 1, &propspec, &propvar, PID_FIRST_USABLE ));
#ifndef OLE2ANSI // No error is generated if BSTRs are Ansi
Check(HRESULT_FROM_WIN32(ERROR_NO_UNICODE_TRANSLATION),
pPropStgBad->WriteMultiple( 1, &propspec, &propvar, PID_FIRST_USABLE ));
#endif
Check(S_OK,
pPropStgGood->WriteMultiple( 1, &propspec, &propvar, PID_FIRST_USABLE ));
g_pfnPropVariantClear( &propvar );
// Attempt to read the BSTR Vector property
propspec.ulKind = PRSPEC_PROPID;
propspec.propid = CODEPAGE_TEST_VBSTR_PROPID;
Check(S_OK,
pPropStgMac->ReadMultiple( 1, &propspec, &propvar ));
g_pfnPropVariantClear( &propvar );
#ifndef OLE2ANSI // No error is generated if BSTRs are Ansi
Check(HRESULT_FROM_WIN32(ERROR_NO_UNICODE_TRANSLATION),
pPropStgBad->ReadMultiple( 1, &propspec, &propvar ));
#endif
Check(S_OK,
pPropStgGood->ReadMultiple( 1, &propspec, &propvar ));
// Attempt to write the BSTR Vector property
Check(S_OK,
pPropStgMac->WriteMultiple( 1, &propspec, &propvar, PID_FIRST_USABLE ));
#ifndef OLE2ANSI // No error is generated if BSTRs are Ansi
Check(HRESULT_FROM_WIN32(ERROR_NO_UNICODE_TRANSLATION),
pPropStgBad->WriteMultiple( 1, &propspec, &propvar, PID_FIRST_USABLE ));
#endif
Check(S_OK,
pPropStgGood->WriteMultiple( 1, &propspec, &propvar, PID_FIRST_USABLE ));
g_pfnPropVariantClear( &propvar );
// Attempt to read the Variant Vector which has a BSTR
propspec.ulKind = PRSPEC_PROPID;
propspec.propid = CODEPAGE_TEST_VPROPVAR_BSTR_PROPID;
Check(S_OK,
pPropStgMac->ReadMultiple( 1, &propspec, &propvar ));
g_pfnPropVariantClear( &propvar );
#ifndef OLE2ANSI // No error is generated if BSTRs are Ansi
Check(HRESULT_FROM_WIN32(ERROR_NO_UNICODE_TRANSLATION),
pPropStgBad->ReadMultiple( 1, &propspec, &propvar ));
#endif
Check(S_OK,
pPropStgGood->ReadMultiple( 1, &propspec, &propvar ));
// Attempt to write the Variant Vector which has a BSTR
Check(S_OK,
pPropStgMac->WriteMultiple( 1, &propspec, &propvar, PID_FIRST_USABLE ));
#ifndef OLE2ANSI // No error is generated if BSTRs are Ansi
Check(HRESULT_FROM_WIN32(ERROR_NO_UNICODE_TRANSLATION),
pPropStgBad->WriteMultiple( 1, &propspec, &propvar, PID_FIRST_USABLE ));
#endif
Check(S_OK,
pPropStgGood->WriteMultiple( 1, &propspec, &propvar, PID_FIRST_USABLE ));
g_pfnPropVariantClear( &propvar );
// Attempt to read the I4 property. Reading the bad property set
// takes special handling, because it will return a different result
// depending on whether NTDLL is checked or free (the free will work,
// the checked generates an error in its validation checking).
propspec.ulKind = PRSPEC_PROPID;
propspec.propid = 4;
Check(S_OK,
pPropStgMac->ReadMultiple( 1, &propspec, &propvar ));
g_pfnPropVariantClear( &propvar );
hr = pPropStgBad->ReadMultiple( 1, &propspec, &propvar );
Check(TRUE, S_OK == hr || HRESULT_FROM_WIN32(ERROR_NO_UNICODE_TRANSLATION) == hr );
g_pfnPropVariantClear( &propvar );
Check(S_OK,
pPropStgGood->ReadMultiple( 1, &propspec, &propvar ));
// Attempt to write the I4 property
Check(S_OK,
pPropStgMac->WriteMultiple( 1, &propspec, &propvar, PID_FIRST_USABLE ));
hr = pPropStgBad->WriteMultiple( 1, &propspec, &propvar, PID_FIRST_USABLE );
Check(TRUE, S_OK == hr || HRESULT_FROM_WIN32(ERROR_NO_UNICODE_TRANSLATION) == hr );
Check(S_OK,
pPropStgGood->WriteMultiple( 1, &propspec, &propvar, PID_FIRST_USABLE ));
g_pfnPropVariantClear( &propvar );
// ---------------------------------------
// Test LPSTRs in the Unicode property set
// ---------------------------------------
// This test doesn't verify that the LPSTRs are actually
// written in Unicode. A manual test is required for that.
// Create a Unicode property set. We'll make it
// non-simple so that we can test a VT_STREAM (which
// is stored like an LPSTR).
ocscpy( oszUnicodeFile, poszDirectory );
ocscat( oszUnicodeFile, OLESTR("\\UnicodCP.stg") );
Check(S_OK, g_pfnStgCreateStorageEx(oszUnicodeFile,
STGM_CREATE | STGM_READWRITE | STGM_SHARE_EXCLUSIVE,
DetermineStgFmt( g_enumImplementation ),
0, NULL, NULL,
DetermineStgIID( g_enumImplementation ),
reinterpret_cast<void**>(&pStgUnicode) ));
IPropertySetStorage *pPropSetStgUnicode = NULL; // TSafeStorage< IPropertySetStorage > pPropSetStgUnicode(pStgUnicode);
Check( S_OK, StgToPropSetStg( pStgUnicode, &pPropSetStgUnicode ));
IPropertyStorage *pPropStgUnicode = NULL; // TSafeStorage< IPropertyStorage > pPropStgUnicode;
Check(S_OK, pPropSetStgUnicode->Create(FMTID_NULL,
&CLSID_NULL,
PROPSETFLAG_NONSIMPLE,
STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE,
&pPropStgUnicode));
// Write/verify an LPSTR property.
propspec.ulKind = PRSPEC_LPWSTR;
propspec.lpwstr = OLESTR("LPSTR Property");
cpropvarWrite = "An LPSTR Property";
Check(S_OK, pPropStgUnicode->WriteMultiple( 1, &propspec, &cpropvarWrite, PID_FIRST_USABLE ));
Check(S_OK, pPropStgUnicode->ReadMultiple( 1, &propspec, &cpropvarRead ));
Check(0, strcmp( (LPSTR) cpropvarWrite, (LPSTR) cpropvarRead ));
cpropvarRead.Clear();
// Write/verify a vector of LPSTR properties
propspec.lpwstr = OLESTR("Vector of LPSTR properties");
cpropvarWrite[1] = "LPSTR Property #1";
cpropvarWrite[0] = "LPSTR Property #0";
Check(S_OK, pPropStgUnicode->WriteMultiple( 1, &propspec, &cpropvarWrite, PID_FIRST_USABLE ));
Check(S_OK, pPropStgUnicode->ReadMultiple( 1, &propspec, &cpropvarRead ));
Check(0, strcmp( (LPSTR) cpropvarWrite[1], (LPSTR) cpropvarRead[1] ));
Check(0, strcmp( (LPSTR) cpropvarWrite[0], (LPSTR) cpropvarRead[0] ));
cpropvarRead.Clear();
// Write/verify a vector of variants which has an LPSTR
propspec.lpwstr = OLESTR("Variant Vector with an LPSTR");
cpropvarWrite[1] = (PROPVARIANT) CPropVariant("LPSTR in a Variant Vector");
cpropvarWrite[0] = (PROPVARIANT) CPropVariant((long) 22); // an I4
Check(TRUE, (VT_VECTOR | VT_VARIANT) == cpropvarWrite.VarType() );
Check(S_OK, pPropStgUnicode->WriteMultiple( 1, &propspec, &cpropvarWrite, PID_FIRST_USABLE ));
Check(S_OK, pPropStgUnicode->ReadMultiple( 1, &propspec, &cpropvarRead ));
Check(0, strcmp( (LPSTR) cpropvarWrite[1], (LPSTR) cpropvarRead[1] ));
cpropvarRead.Clear();
// Write/verify a Stream.
cpropvarWrite = (IStream*) NULL;
propspec.lpwstr = OLESTR("An IStream");
Check(S_OK, pPropStgUnicode->WriteMultiple( 1, &propspec, &cpropvarWrite, PID_FIRST_USABLE ));
Check(S_OK, pPropStgUnicode->ReadMultiple( 1, &propspec, &cpropvarRead ));
cpropvarRead.Clear();
// There's nothing more we can check for the VT_STREAM property, a manual
// check is required to verify that it was written correctly.
RELEASE_INTERFACE(pStgBad);
RELEASE_INTERFACE(pStgGood);
RELEASE_INTERFACE(pStgUnicode);
RELEASE_INTERFACE(pStgMac);
RELEASE_INTERFACE(pPropSetStgBad);
RELEASE_INTERFACE(pPropStgBad);
RELEASE_INTERFACE(pPropStgGood);
RELEASE_INTERFACE(pPropStgMac);
RELEASE_INTERFACE(pPropSetStgGood);
RELEASE_INTERFACE(pPropSetStgMac);
RELEASE_INTERFACE(pPropSetStgUnicode);
RELEASE_INTERFACE(pPropStgUnicode);
}
void
test_PropertyInterfaces(IStorage *pstgTemp)
{
Status( "Property Interface\n" );
g_nIndent++;
// this test depends on being first for enumerator
test_IEnumSTATPROPSETSTG(pstgTemp);
test_MaxPropertyName(pstgTemp);
test_IPropertyStorage(pstgTemp);
test_IPropertySetStorage(pstgTemp);
test_IEnumSTATPROPSTG(pstgTemp);
--g_nIndent;
}
//===================================================================
//
// Function: test_CopyTo
//
// Synopsis: Verify that IStorage::CopyTo copies an
// un-flushed property set.
//
// This test creates and writes to a simple property set,
// a non-simple property set, and a new Storage & Stream,
// all within the source (caller-provided) Storage.
//
// It then copies the entire source Storage to the
// destination Storage, and verifies that all commited
// data in the Source is also in the destination.
//
// All new Storages and property sets are created
// under a new base storage. The caller can specify
// if this base Storage is direct or transacted, and
// can specify if the property sets are direct or
// transacted.
//
//===================================================================
void test_CopyTo(IStorage *pstgSource, // Source of the CopyTo
IStorage *pstgDestination, // Destination of the CopyTo
ULONG ulBaseStgTransaction, // Transaction bit for the base storage.
ULONG ulPropSetTransaction, // Transaction bit for the property sets.
LPOLESTR oszBaseStorageName )
{
if( g_Restrictions & RESTRICT_NON_HIERARCHICAL ) return;
char szMessage[ 128 ];
sprintf( szMessage, "IStorage::CopyTo (Base Storage is %s, PropSets are %s)\n",
ulBaseStgTransaction & STGM_TRANSACTED ? "transacted" : "direct",
ulPropSetTransaction & STGM_TRANSACTED ? "transacted" : "direct" );
Status( szMessage );
// ---------------
// Local Variables
// ---------------
OLECHAR const *poszTestSubStorage = OLESTR( "TestStorage" );
OLECHAR const *poszTestSubStream = OLESTR( "TestStream" );
OLECHAR const *poszTestDataPreCommit = OLESTR( "Test Data (pre-commit)" );
OLECHAR const *poszTestDataPostCommit = OLESTR( "Test Data (post-commit)" );
long lSimplePreCommit = 0x0123;
long lSimplePostCommit = 0x4567;
long lNonSimplePreCommit = 0x89AB;
long lNonSimplePostCommit = 0xCDEF;
BYTE acReadBuffer[ 80 ];
ULONG cbRead;
FMTID fmtidSimple, fmtidNonSimple;
// Base Storages for the Source & Destination. All
// new Streams/Storages/PropSets will be created below here.
IStorage *pstgBaseSource = NULL;
IStorage *pstgBaseDestination = NULL;
IStorage *pstgSub = NULL; // A sub-storage of the base.
IStream *pstmSub = NULL; // A Stream in the sub-storage (pstgSub)
PROPSPEC propspec;
PROPVARIANT propvarSourceSimple,
propvarSourceNonSimple,
propvarDestination;
// -----
// Begin
// -----
// Create new format IDs
UuidCreate(&fmtidSimple);
UuidCreate(&fmtidNonSimple);
// -----------------------
// Create the base Storage
// -----------------------
// Create a base Storage for the Source. All of this test will be under
// that Storage.
// In the source Storage.
Check( S_OK, pstgSource->CreateStorage(
oszBaseStorageName,
STGM_CREATE | ulBaseStgTransaction | STGM_SHARE_EXCLUSIVE | STGM_READWRITE,
0L, 0L,
&pstgBaseSource ));
// And in the destination Storage.
Check( S_OK, pstgDestination->CreateStorage(
oszBaseStorageName,
STGM_CREATE | STGM_DIRECT | STGM_SHARE_EXCLUSIVE | STGM_READWRITE,
0L, 0L,
&pstgBaseDestination ));
// -------------------------------------------
// Write data to a new Stream in a new Storage
// -------------------------------------------
// We'll partially verify the CopyTo by checking that this data
// makes it into the destination Storage.
// Create a Storage, and then a Stream within it.
Check( S_OK, pstgBaseSource->CreateStorage(
poszTestSubStorage,
STGM_CREATE | ulPropSetTransaction | STGM_SHARE_EXCLUSIVE | STGM_READWRITE,
0L, 0L,
&pstgSub ));
Check( S_OK, pstgSub->CreateStream(
poszTestSubStream,
STGM_CREATE | STGM_READWRITE | STGM_SHARE_EXCLUSIVE,
0L, 0L,
&pstmSub ));
// Write data to the Stream.
Check( S_OK, pstmSub->Write(
poszTestDataPreCommit,
( sizeof(OLECHAR)
*
(ocslen( poszTestDataPreCommit ) + sizeof(OLECHAR))
),
NULL ));
// ---------------------------------------------------------
// Write to a new simple property set in the Source storage.
// ---------------------------------------------------------
IPropertySetStorage *pPropSetStgSource = NULL; // TSafeStorage< IPropertySetStorage > pPropSetStgSource(pstgBaseSource);
Check( S_OK, StgToPropSetStg( pstgBaseSource, &pPropSetStgSource ));
IPropertyStorage *pPropStgSource1 = NULL, *pPropStgSource2 = NULL, *pPropStgDestination = NULL;
// Create a property set mode.
Check(S_OK, pPropSetStgSource->Create(fmtidSimple,
NULL,
PROPSETFLAG_DEFAULT,
STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE,
&pPropStgSource1));
// Write the property set name (just to test this functionality).
PROPID pidDictionary = 0;
OLECHAR *poszPropSetName = OLESTR("Property Set for CopyTo Test");
Check(TRUE, CWC_MAXPROPNAMESZ >= ocslen(poszPropSetName) + sizeof(OLECHAR) );
Check(S_OK, pPropStgSource1->WritePropertyNames( 1, &pidDictionary, &poszPropSetName ));
// Create a PROPSPEC. We'll use this throughout the rest of the routine.
propspec.ulKind = PRSPEC_PROPID;
propspec.propid = 1000;
// Create a PROPVARIANT for this test of the Simple case.
propvarSourceSimple.vt = VT_I4;
propvarSourceSimple.lVal = lSimplePreCommit;
// Write the PROPVARIANT to the property set.
Check(S_OK, pPropStgSource1->WriteMultiple(1, &propspec, &propvarSourceSimple, 2));
// ---------------------------------------------------------------
// Write to a new *non-simple* property set in the Source storage.
// ---------------------------------------------------------------
// Create a property set.
Check(S_OK, pPropSetStgSource->Create(fmtidNonSimple,
NULL,
PROPSETFLAG_NONSIMPLE,
STGM_CREATE | STGM_SHARE_EXCLUSIVE | ulPropSetTransaction | STGM_READWRITE,
&pPropStgSource2));
// Set data in the PROPVARIANT for the non-simple test.
propvarSourceNonSimple.vt = VT_I4;
propvarSourceNonSimple.lVal = lNonSimplePreCommit;
// Write the PROPVARIANT to the property set.
Check(S_OK, pPropStgSource2->WriteMultiple(1, &propspec, &propvarSourceNonSimple, 2));
// -------------------------
// Commit everything so far.
// -------------------------
// Commit the sub-Storage.
Check(S_OK, pstgSub->Commit( STGC_DEFAULT ));
// Commit the simple property set.
Check(S_OK, pPropStgSource1->Commit( STGC_DEFAULT ));
// Commit the non-simple property set.
Check(S_OK, pPropStgSource2->Commit( STGC_DEFAULT ));
// Commit the base Storage which holds all of the above.
Check(S_OK, pstgBaseSource->Commit( STGC_DEFAULT ));
// -------------------------------------------------
// Write new data to everything but don't commit it.
// -------------------------------------------------
// Write to the sub-storage.
Check(S_OK, pstmSub->Seek(g_li0, STREAM_SEEK_SET, NULL));
Check( S_OK, pstmSub->Write(
poszTestDataPostCommit,
( sizeof(OLECHAR)
*
(ocslen( poszTestDataPostCommit ) + sizeof(OLECHAR))
),
NULL ));
// Write to the simple property set.
propvarSourceSimple.lVal = lSimplePostCommit;
Check(S_OK, pPropStgSource1->WriteMultiple(1, &propspec, &propvarSourceSimple, 2));
// Write to the non-simple property set.
propvarSourceNonSimple.lVal = lNonSimplePostCommit;
Check(S_OK, pPropStgSource2->WriteMultiple(1, &propspec, &propvarSourceNonSimple, PID_FIRST_USABLE ));
// -------------------------------------------
// Copy the source Storage to the destination.
// -------------------------------------------
// Release the sub-Storage (which is below the base Storage, and has
// a Stream with data in it), just to test that the CopyTo can
// handle it.
pstgSub->Release();
pstgSub = NULL;
Check(S_OK, pstgBaseSource->CopyTo( 0, NULL, NULL, pstgBaseDestination ));
// ----------------------------------------------------------
// Verify the simple property set in the destination Storage.
// ----------------------------------------------------------
IPropertySetStorage *pPropSetStgDestination = NULL; // TSafeStorage< IPropertySetStorage > pPropSetStgDestination(pstgBaseDestination);
Check( S_OK, StgToPropSetStg( pstgBaseDestination, &pPropSetStgDestination ));
// Open the simple property set.
Check(S_OK, pPropSetStgDestination->Open(fmtidSimple,
STGM_SHARE_EXCLUSIVE | STGM_READWRITE,
&pPropStgDestination));
// Verify the property set name.
OLECHAR *poszPropSetNameDestination;
BOOL bReadPropertyNamePassed = FALSE;
Check(S_OK, pPropStgDestination->ReadPropertyNames( 1, &pidDictionary,
&poszPropSetNameDestination ));
if( poszPropSetNameDestination // Did we get a name back?
&& // If so, was it the correct name?
!ocscmp( poszPropSetName, poszPropSetNameDestination )
)
{
bReadPropertyNamePassed = TRUE;
}
delete [] poszPropSetNameDestination;
poszPropSetNameDestination = NULL;
Check( TRUE, bReadPropertyNamePassed );
// Read the PROPVARIANT that we wrote earlier.
Check(S_OK, pPropStgDestination->ReadMultiple(1, &propspec, &propvarDestination));
// Verify that it's correct.
Check(TRUE, propvarDestination.vt == propvarSourceSimple.vt );
Check(TRUE, propvarDestination.lVal == lSimplePostCommit);
Check(S_OK, pPropStgDestination->Commit( STGC_DEFAULT ));
Check(S_OK, pPropStgDestination->Release());
pPropStgDestination = NULL;
// ----------------------------------------------------------------
// Verify the *non-simple* property set in the destination Storage.
// ----------------------------------------------------------------
// Open the non-simple property set.
Check(S_OK,
pPropSetStgDestination->Open(fmtidNonSimple,
STGM_SHARE_EXCLUSIVE | STGM_DIRECT | STGM_READWRITE,
&pPropStgDestination));
// Read the PROPVARIANT that we wrote earlier.
Check(S_OK, pPropStgDestination->ReadMultiple(1, &propspec, &propvarDestination));
// Verify that they're the same.
Check(TRUE, propvarDestination.vt == propvarSourceNonSimple.vt );
Check(TRUE, propvarDestination.lVal
==
( STGM_TRANSACTED & ulPropSetTransaction
?
lNonSimplePreCommit
:
lNonSimplePostCommit
));
Check(S_OK, pPropStgDestination->Commit( STGC_DEFAULT ));
Check(S_OK, pPropStgDestination->Release());
pPropStgDestination = NULL;
// ------------------------------------------------
// Verify the test data in the destination Storage.
// ------------------------------------------------
// Now we can release and re-use the Stream pointer that
// currently points to the sub-Stream in the source docfile.
Check(STG_E_REVERTED, pstmSub->Commit( STGC_DEFAULT ));
Check(S_OK, pstmSub->Release());
pstmSub = NULL;
// Get the Storage then the Stream.
Check( S_OK, pstgBaseDestination->OpenStorage(
poszTestSubStorage,
NULL,
STGM_READWRITE | STGM_DIRECT | STGM_SHARE_EXCLUSIVE,
NULL,
0L,
&pstgSub ));
Check( S_OK, pstgSub->OpenStream(
poszTestSubStream,
NULL,
STGM_READWRITE | STGM_SHARE_EXCLUSIVE,
0L,
&pstmSub ));
// Read the data and compare it against what we wrote.
Check( S_OK, pstmSub->Read(
acReadBuffer,
sizeof( acReadBuffer ),
&cbRead ));
OLECHAR const *poszTestData = ( STGM_TRANSACTED & ulPropSetTransaction )
?
poszTestDataPreCommit
:
poszTestDataPostCommit;
Check( TRUE, cbRead == sizeof(OLECHAR)
*
(ocslen( poszTestData ) + sizeof(OLECHAR))
);
Check( FALSE, ocscmp( poszTestData, (OLECHAR *) acReadBuffer ));
// ----
// Exit
// ----
RELEASE_INTERFACE( pPropSetStgSource );
RELEASE_INTERFACE(pPropStgSource1);
RELEASE_INTERFACE(pPropStgSource2);
RELEASE_INTERFACE(pPropStgDestination);
RELEASE_INTERFACE(pPropSetStgDestination);
RELEASE_INTERFACE(pstgBaseSource);
RELEASE_INTERFACE(pstgBaseDestination);
RELEASE_INTERFACE(pstgSub);
RELEASE_INTERFACE(pstmSub);
// We're done. Don't bother to release anything;
// they'll release themselves in their destructors.
return;
} // test_CopyTo()
//--------------------------------------------------------
//
// Function: test_OLESpecTickerExample
//
// Synopsis: This function generates the ticker property set
// example that's used in the OLE Programmer's Reference
// (when describing property ID 0 - the dictionary).
//
//--------------------------------------------------------
#define PID_SYMBOL 0x7
#define PID_OPEN 0x3
#define PID_CLOSE 0x4
#define PID_HIGH 0x5
#define PID_LOW 0x6
#define PID_LAST 0x8
#define PID_VOLUME 0x9
void test_OLESpecTickerExample( IStorage* pstg )
{
Status( "Generate the Stock Ticker example from the OLE Programmer's Ref\n" );
// ------
// Locals
// ------
FMTID fmtid;
PROPSPEC propspec;
LPOLESTR oszPropSetName = OLESTR( "Stock Quote" );
LPOLESTR oszTickerSymbolName = OLESTR( "Ticker Symbol" );
LPOLESTR oszOpenName = OLESTR( "Opening Price" );
LPOLESTR oszCloseName = OLESTR( "Last Closing Price" );
LPOLESTR oszHighName = OLESTR( "High Price" );
LPOLESTR oszLowName = OLESTR( "Low Price" );
LPOLESTR oszLastName = OLESTR( "Last Price" );
LPOLESTR oszVolumeName = OLESTR( "Volume" );
// ---------------------------------
// Create a new simple property set.
// ---------------------------------
IPropertySetStorage *pPropSetStg = NULL; // TSafeStorage< IPropertySetStorage > pPropSetStg(pstg);
IPropertyStorage *pPropStg;
ULONG cStorageRefs = GetRefCount( pstg );
Check( S_OK, StgToPropSetStg( pstg, &pPropSetStg ));
UuidCreate( &fmtid );
Check(S_OK, pPropSetStg->Create(fmtid,
NULL,
PROPSETFLAG_DEFAULT, // Unicode
STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_DIRECT | STGM_READWRITE,
&pPropStg));
// ---------------------------------------------
// Fill in the simply property set's dictionary.
// ---------------------------------------------
// Write the property set's name.
PROPID pidDictionary = 0;
Check(S_OK, pPropStg->WritePropertyNames(1, &pidDictionary, &oszPropSetName ));
// Write the High price, forcing the dictionary to pad.
propspec.ulKind = PRSPEC_PROPID;
propspec.propid = PID_HIGH;
Check(S_OK, pPropStg->WritePropertyNames(1, &propspec.propid, &oszHighName ));
// Write the ticker symbol.
propspec.propid = PID_SYMBOL;
Check(S_OK, pPropStg->WritePropertyNames(1, &propspec.propid, &oszTickerSymbolName));
// Write the rest of the dictionary.
propspec.propid = PID_LOW;
Check(S_OK, pPropStg->WritePropertyNames(1, &propspec.propid, &oszLowName));
propspec.propid = PID_OPEN;
Check(S_OK, pPropStg->WritePropertyNames(1, &propspec.propid, &oszOpenName));
propspec.propid = PID_CLOSE;
Check(S_OK, pPropStg->WritePropertyNames(1, &propspec.propid, &oszCloseName));
propspec.propid = PID_LAST;
Check(S_OK, pPropStg->WritePropertyNames(1, &propspec.propid, &oszLastName));
propspec.propid = PID_VOLUME;
Check(S_OK, pPropStg->WritePropertyNames(1, &propspec.propid, &oszVolumeName));
// Write out the ticker symbol.
propspec.propid = PID_SYMBOL;
PROPVARIANT propvar;
propvar.vt = VT_LPWSTR;
propvar.pwszVal = L"MSFT";
Check(S_OK, pPropStg->WriteMultiple(1, &propspec, &propvar, 2));
// ----
// Exit
// ----
Check(S_OK, pPropStg->Commit( STGC_DEFAULT ));
Check(0, pPropStg->Release());
Check(S_OK, pstg->Commit( STGC_DEFAULT ));
RELEASE_INTERFACE( pPropSetStg );
Check( cStorageRefs, GetRefCount(pstg) );
return;
} // test_OLESpecTickerExample()
void
test_Office( LPOLESTR wszTestFile )
{
Status( "Generate Office Property Sets\n" );
IStorage *pStg = NULL;
IPropertyStorage *pPStgSumInfo=NULL, *pPStgDocSumInfo=NULL, *pPStgUserDefined=NULL;
IPropertySetStorage *pPSStg = NULL; // TSafeStorage<IPropertySetStorage> pPSStg;
PROPVARIANT propvarWrite, propvarRead;
PROPSPEC propspec;
PropVariantInit( &propvarWrite );
PropVariantInit( &propvarRead );
// Create the file
Check( S_OK, g_pfnStgCreateStorageEx( wszTestFile,
STGM_CREATE | STGM_READWRITE | STGM_SHARE_EXCLUSIVE,
DetermineStgFmt( g_enumImplementation ),
0L,
NULL,
NULL,
IID_IPropertySetStorage,
(void**) &pPSStg ));
// Create the SummaryInformation property set.
Check(S_OK, pPSStg->Create( FMTID_SummaryInformation,
NULL,
(g_Restrictions & RESTRICT_UNICODE_ONLY) ? PROPSETFLAG_DEFAULT : PROPSETFLAG_ANSI,
STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_DIRECT | STGM_READWRITE,
&pPStgSumInfo ));
// Write a Title to the SumInfo property set.
PropVariantInit( &propvarWrite );
propvarWrite.vt = VT_LPSTR;
propvarWrite.pszVal = "Title from PropTest";
propspec.ulKind = PRSPEC_PROPID;
propspec.propid = PID_TITLE;
Check( S_OK, pPStgSumInfo->WriteMultiple( 1, &propspec, &propvarWrite, PID_FIRST_USABLE ));
Check( S_OK, pPStgSumInfo->ReadMultiple( 1, &propspec, &propvarRead ));
Check( TRUE, propvarWrite.vt == propvarRead.vt );
Check( FALSE, strcmp( propvarWrite.pszVal, propvarRead.pszVal ));
g_pfnPropVariantClear( &propvarRead );
PropVariantInit( &propvarRead );
pPStgSumInfo->Release();
pPStgSumInfo = NULL;
// Create the DocumentSummaryInformation property set.
Check(S_OK, pPSStg->Create( FMTID_DocSummaryInformation,
NULL,
(g_Restrictions & RESTRICT_UNICODE_ONLY ) ? PROPSETFLAG_DEFAULT: PROPSETFLAG_ANSI,
STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_DIRECT | STGM_READWRITE,
&pPStgDocSumInfo ));
// Write a word-count to the DocSumInfo property set.
PropVariantInit( &propvarWrite );
propvarWrite.vt = VT_I4;
propvarWrite.lVal = 100;
propspec.ulKind = PRSPEC_PROPID;
propspec.propid = PID_WORDCOUNT;
Check( S_OK, pPStgDocSumInfo->WriteMultiple( 1, &propspec, &propvarWrite, PID_FIRST_USABLE ));
Check( S_OK, pPStgDocSumInfo->ReadMultiple( 1, &propspec, &propvarRead ));
Check( TRUE, propvarWrite.vt == propvarRead.vt );
Check( TRUE, propvarWrite.lVal == propvarRead.lVal );
g_pfnPropVariantClear( &propvarRead );
PropVariantInit( &propvarRead );
pPStgDocSumInfo->Release();
pPStgDocSumInfo = NULL;
// Create the UserDefined property set.
Check(S_OK, pPSStg->Create( FMTID_UserDefinedProperties,
NULL,
(g_Restrictions & RESTRICT_UNICODE_ONLY) ? PROPSETFLAG_DEFAULT : PROPSETFLAG_ANSI,
STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_DIRECT | STGM_READWRITE,
&pPStgUserDefined ));
// Write named string to the UserDefined property set.
PropVariantInit( &propvarWrite );
propvarWrite.vt = VT_LPSTR;
propvarWrite.pszVal = "User-Defined string from PropTest";
propspec.ulKind = PRSPEC_LPWSTR;
propspec.lpwstr = OLESTR("PropTest String");
Check( S_OK, pPStgUserDefined->WriteMultiple( 1, &propspec, &propvarWrite, PID_FIRST_USABLE ));
Check( S_OK, pPStgUserDefined->ReadMultiple( 1, &propspec, &propvarRead ));
Check( TRUE, propvarWrite.vt == propvarRead.vt );
Check( FALSE, strcmp( propvarWrite.pszVal, propvarRead.pszVal ));
g_pfnPropVariantClear( &propvarRead );
PropVariantInit( &propvarRead );
pPStgUserDefined->Release();
pPStgUserDefined = NULL;
RELEASE_INTERFACE(pPSStg);
// And we're done! (Everything releases automatically)
return;
}
void
test_Office2(IStorage *pStorage)
{
if( g_Restrictions & RESTRICT_NON_HIERARCHICAL ) return;
Status( "Testing Office Property Sets\n" );
IStorage *pSubStorage = NULL; // TSafeStorage< IStorage > pSubStorage;
IPropertySetStorage *pPropSetStg = NULL; // TSafeStorage< IPropertySetStorage > pPropSetStg;
IPropertyStorage *pPropStg = NULL; // TSafeStorage< IPropertyStorage > pPropStg;
CPropSpec cpropspec;
// ----------------------------------
// Create a sub-storage for this test
// ----------------------------------
Check(S_OK, pStorage->CreateStorage( OLESTR("test_Office2"),
STGM_CREATE | STGM_READWRITE | STGM_SHARE_EXCLUSIVE,
0, 0, &pSubStorage ));
Check(S_OK, StgToPropSetStg( pSubStorage, &pPropSetStg ));
// --------------------------------------------------------
// Test the Create/Delete of the DocumentSummaryInformation
// property set (this requires special code because it
// has two sections).
// --------------------------------------------------------
// Create & Delete a DSI propset with just the first section.
Check(S_OK, pPropSetStg->Create(FMTID_DocSummaryInformation,
NULL,
PROPSETFLAG_DEFAULT,
STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_DIRECT | STGM_READWRITE,
&pPropStg));
pPropStg->Release(); pPropStg = NULL;
Check(S_OK, pPropSetStg->Delete( FMTID_DocSummaryInformation ));
// Create & Delete a DSI propset with just the second section
Check(S_OK, pPropSetStg->Create(FMTID_UserDefinedProperties,
NULL,
PROPSETFLAG_DEFAULT,
STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_DIRECT | STGM_READWRITE,
&pPropStg ));
pPropStg->Release(); pPropStg = NULL;
Check(S_OK, pPropSetStg->Delete( FMTID_UserDefinedProperties ));
Check(S_OK, pPropSetStg->Delete( FMTID_DocSummaryInformation ));
// --------------------------------------------
// Test the Create/Open of the DSI property set
// --------------------------------------------
// Create & Delete a DocumentSummaryInformation propset with both sections.
// If you delete the DSI propset first, it should delete both sections.
// If you delete the UD propset first, the DSI propset should still
// remain. We'll loop twice, trying both combinations.
for( int i = 0; i < 2; i++ )
{
// Create the first section.
Check(S_OK, pPropSetStg->Create(FMTID_DocSummaryInformation,
NULL,
PROPSETFLAG_DEFAULT,
STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_DIRECT | STGM_READWRITE,
&pPropStg));
pPropStg->Release(); pPropStg = NULL;
// Create the second section.
Check(S_OK, pPropSetStg->Create(FMTID_UserDefinedProperties,
NULL,
PROPSETFLAG_DEFAULT,
STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_DIRECT | STGM_READWRITE,
&pPropStg));
pPropStg->Release(); pPropStg = NULL;
if( i == 0 )
{
// Delete the second section, then the first.
Check(S_OK, pPropSetStg->Delete( FMTID_UserDefinedProperties ));
Check(S_OK, pPropSetStg->Delete( FMTID_DocSummaryInformation ));
}
else
{
// Delete the first section, then *attempt* to delete the second.
Check(S_OK, pPropSetStg->Delete( FMTID_DocSummaryInformation ));
Check(STG_E_FILENOTFOUND, pPropSetStg->Delete( FMTID_UserDefinedProperties ));
}
} // for( i = 0; i < 2; i++ )
// ------------------------------------------------------------------
// Verify that we can create the UD propset (the 2nd section) without
// harming the first section.
// ------------------------------------------------------------------
{
CPropSpec rgcpropspec[2];
CPropVariant rgcpropvarWrite[2];
CPropVariant cpropvarRead;
// Create the first section.
Check(S_OK, pPropSetStg->Create(FMTID_DocSummaryInformation,
NULL,
PROPSETFLAG_DEFAULT,
STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_DIRECT | STGM_READWRITE,
&pPropStg));
// Write a property to the first section.
rgcpropspec[0] = OLESTR("Test DSI Property");
rgcpropvarWrite[0] = (DWORD) 1;
Check(S_OK, pPropStg->WriteMultiple( 1, rgcpropspec[0], &rgcpropvarWrite[0],
PID_FIRST_USABLE ));
pPropStg->Release(); pPropStg = NULL;
// *Create* the second section
Check(S_OK, pPropSetStg->Create(FMTID_UserDefinedProperties,
NULL,
PROPSETFLAG_DEFAULT,
STGM_SHARE_EXCLUSIVE | STGM_READWRITE | STGM_CREATE,
&pPropStg ));
// Write a property to the second section
rgcpropspec[1] = OLESTR("Test UD Property");
rgcpropvarWrite[1] = (DWORD) 2;
Check(S_OK, pPropStg->WriteMultiple( 1, rgcpropspec[1], &rgcpropvarWrite[1],
PID_FIRST_USABLE ));
pPropStg->Release(); pPropStg = NULL;
// Verify the properties from each of the sections.
Check(S_OK, pPropSetStg->Open(FMTID_DocSummaryInformation,
STGM_SHARE_EXCLUSIVE | STGM_READWRITE,
&pPropStg ));
Check(S_OK, pPropStg->ReadMultiple( 1, rgcpropspec[0], &cpropvarRead ));
Check(TRUE, rgcpropvarWrite[0] == cpropvarRead );
cpropvarRead.Clear();
pPropStg->Release(); pPropStg = NULL;
Check(S_OK, pPropSetStg->Open(FMTID_UserDefinedProperties,
STGM_SHARE_EXCLUSIVE | STGM_READWRITE,
&pPropStg ));
Check(S_OK, pPropStg->ReadMultiple( 1, rgcpropspec[1], &cpropvarRead ));
Check(TRUE, rgcpropvarWrite[1] == cpropvarRead );
cpropvarRead.Clear();
pPropStg->Release(); pPropStg = NULL;
}
// -------------------------------------
// Test special properties in DocSumInfo
// -------------------------------------
// This verifies that when we Create a DocSumInfo
// property set, and write a Vector or LPSTRs,
// we can read it again. We test this because
// Vectors of LPSTRs are a special case in the DocSumInfo,
// and the Create & Open path are slightly different
// in CPropertySetStream::_LoadHeader.
// Create a new property set.
Check(S_OK, pPropSetStg->Create(FMTID_DocSummaryInformation,
NULL,
PROPSETFLAG_DEFAULT,
STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_DIRECT | STGM_READWRITE,
&pPropStg));
// Create a vector of LPSTRs. Make the strings
// varying lengths to ensure we get plenty of
// opportunity for alignment problems.
CPropVariant cpropvarWrite, cpropvarRead;
cpropvarWrite[3] = "12345678";
cpropvarWrite[2] = "1234567";
cpropvarWrite[1] = "123456";
cpropvarWrite[0] = "12345";
Check(TRUE, cpropvarWrite.Count() == 4 );
// Write the property
cpropspec = OLESTR("A Vector of LPSTRs");
Check(S_OK, pPropStg->WriteMultiple( 1, cpropspec, &cpropvarWrite, 2 ));
// Read the property back.
Check(S_OK, pPropStg->ReadMultiple( 1, cpropspec, &cpropvarRead ));
// Verify that we read what we wrote.
for( i = 0; i < (int) cpropvarWrite.Count(); i++ )
{
Check(0, strcmp( (LPSTR) cpropvarWrite[i], (LPSTR) cpropvarRead[i] ));
}
// ----
// Exit
// ----
RELEASE_INTERFACE(pSubStorage);
RELEASE_INTERFACE(pPropSetStg);
RELEASE_INTERFACE(pPropStg);
return;
}
void test_PropVariantCopy( )
{
Status( "PropVariantCopy\n" );
PROPVARIANT propvarCopy;
PropVariantInit( &propvarCopy );
VERSIONEDSTREAM VersionedStream;
UuidCreate( &VersionedStream.guidVersion );
VersionedStream.pStream = NULL;
for( int i = 0; i < CPROPERTIES_ALL; i++ )
{
Check(S_OK, g_pfnPropVariantCopy( &propvarCopy, &g_rgcpropvarAll[i] )); // g_pfnPropVariantCopy( &propvarCopy, &g_rgcpropvarAll[i] ));
Check(S_OK, CPropVariant::Compare( &propvarCopy, &g_rgcpropvarAll[i] ));
g_pfnPropVariantClear( &propvarCopy );
// If this is a stream, take the opportunity to do a test of vt_versioned_stream.
if( VT_STREAM == g_rgcpropvarAll[i].vt )
{
VersionedStream.pStream = g_rgcpropvarAll[i].pStream;
CPropVariant cpropvar = VersionedStream;
Check( S_OK, g_pfnPropVariantCopy( &propvarCopy, &cpropvar ));
Check( S_OK, CPropVariant::Compare( &propvarCopy, &cpropvar ));
g_pfnPropVariantClear( &propvarCopy );
}
}
Check( S_OK, ResetRGPropVar( g_rgcpropvarAll ));
}
#define PERFORMANCE_ITERATIONS 300
#define STABILIZATION_ITERATIONS 10
void
test_Performance( IStorage *pStg )
{
//#ifndef _MAC
if( g_Restrictions & RESTRICT_NON_HIERARCHICAL ) return;
Status( "Performance\n" );
CPropVariant rgcpropvar[2];
CPropSpec rgpropspec[2];
IPropertySetStorage *pPSStg = NULL; // TSafeStorage< IPropertySetStorage > pPSStg( pStg );
Check( S_OK, StgToPropSetStg( pStg, &pPSStg ));
IPropertyStorage *pPStg = NULL; // TSafeStorage< IPropertyStorage > pPStg;
IStream *pStm = NULL; // TSafeStorage< IStream > pStm;
FMTID fmtid;
ULONG ulCount;
DWORD dwSumTimes;
FILETIME filetimeStart, filetimeEnd;
BYTE *pPropertyBuffer;
ULONG cbPropertyBuffer;
UuidCreate( &fmtid );
rgcpropvar[0][0] = L"I wish I were an Oscar Meyer wiener,";
rgcpropvar[0][1] = L"That is what I'd truly like to be.";
rgcpropvar[1][0] = "For if I were an Oscar Meyer wiener,";
rgcpropvar[1][1] = "Everyone would be in love with me.";
Check(TRUE, (VT_LPWSTR | VT_VECTOR) == rgcpropvar[0].VarType() );
Check(TRUE, (VT_LPSTR | VT_VECTOR) == rgcpropvar[1].VarType() );
// ----------------
// Test an IStorage
// ----------------
// Create a buffer to write which is the same size as
// the properties in rgcpropvar.
cbPropertyBuffer = sizeof(WCHAR)
*
(2 + wcslen(rgcpropvar[0][0]) + wcslen(rgcpropvar[0][1]));
cbPropertyBuffer += (2 + strlen(rgcpropvar[1][0]) + strlen(rgcpropvar[1][1]));
pPropertyBuffer = new BYTE[ cbPropertyBuffer ];
PRINTF( " Docfile CreateStream/Write/Release = " );
dwSumTimes = 0;
// Perform the test iterations
for( ulCount = 0;
ulCount < PERFORMANCE_ITERATIONS + STABILIZATION_ITERATIONS;
ulCount++ )
{
if( ulCount == STABILIZATION_ITERATIONS )
CoFileTimeNow( &filetimeStart );
Check(S_OK, pStg->CreateStream( OLESTR("StoragePerformance"),
STGM_CREATE | STGM_DIRECT | STGM_READWRITE | STGM_SHARE_EXCLUSIVE,
0L, 0L,
&pStm ));
Check(S_OK, pStm->Write( pPropertyBuffer, cbPropertyBuffer, NULL ));
pStm->Release(); pStm = NULL;
}
CoFileTimeNow( &filetimeEnd );
filetimeEnd -= filetimeStart;
PRINTF( "%4.2f ms\n", (float)filetimeEnd.dwLowDateTime
/
10000 // # of 100 nanosec units in 1 ms
/
PERFORMANCE_ITERATIONS );
// ------------------------------------------------------
// Try Creating a Property Set and writing two properties
// ------------------------------------------------------
rgpropspec[0] = OLESTR("First Property");
rgpropspec[1] = OLESTR("Second Property");
PRINTF( " PropSet Create(Overwrite)/WriteMultiple/Release = " );
dwSumTimes = 0;
for( ulCount = 0;
ulCount < PERFORMANCE_ITERATIONS + STABILIZATION_ITERATIONS;
ulCount++ )
{
if( ulCount == STABILIZATION_ITERATIONS )
CoFileTimeNow( &filetimeStart) ;
Check(S_OK, pPSStg->Create( fmtid,
NULL,
PROPSETFLAG_DEFAULT | PROPSETFLAG_NONSIMPLE,
STGM_CREATE | STGM_READWRITE | STGM_SHARE_EXCLUSIVE,
&pPStg ));
Check(S_OK, pPStg->WriteMultiple( 2, rgpropspec, rgcpropvar, PID_FIRST_USABLE ));
pPStg->Release(); pPStg = NULL;
}
CoFileTimeNow( &filetimeEnd );
filetimeEnd -= filetimeStart;
PRINTF( "%4.2f ms\n", (float)filetimeEnd.dwLowDateTime
/
10000 // 100 ns units to 1 ms units
/
PERFORMANCE_ITERATIONS );
// ------------------------------------------------------
// WriteMultiple (with named properties) Performance Test
// ------------------------------------------------------
PRINTF( " WriteMultiple (named properties) = " );
Check(S_OK, pPSStg->Create( fmtid,
NULL,
PROPSETFLAG_DEFAULT | PROPSETFLAG_NONSIMPLE,
STGM_CREATE | STGM_READWRITE | STGM_SHARE_EXCLUSIVE,
&pPStg ));
for( ulCount = 0;
ulCount < PERFORMANCE_ITERATIONS + STABILIZATION_ITERATIONS;
ulCount++ )
{
if( ulCount == STABILIZATION_ITERATIONS )
CoFileTimeNow( &filetimeStart );
for( int i = 0; i < CPROPERTIES_ALL; i++ )
{
Check(S_OK, pPStg->WriteMultiple( 1, &g_rgcpropspecAll[i], &g_rgcpropvarAll[i], PID_FIRST_USABLE ));
}
Check( S_OK, ResetRGPropVar( g_rgcpropvarAll ));
}
CoFileTimeNow( &filetimeEnd );
filetimeEnd -= filetimeStart;
PRINTF( "%4.2f ms\n", (float) filetimeEnd.dwLowDateTime
/
10000 // 100 ns units to 1 ms units
/
PERFORMANCE_ITERATIONS );
pPStg->Release();
pPStg = NULL;
// --------------------------------------------------------
// WriteMultiple (with unnamed properties) Performance Test
// --------------------------------------------------------
{
CPropSpec rgcpropspecPIDs[ CPROPERTIES_ALL ];
PRINTF( " WriteMultiple (unnamed properties) = " );
Check(S_OK, pPSStg->Create( fmtid,
NULL,
PROPSETFLAG_DEFAULT | PROPSETFLAG_NONSIMPLE,
STGM_CREATE | STGM_READWRITE | STGM_SHARE_EXCLUSIVE,
&pPStg ));
for( ulCount = 0; ulCount < CPROPERTIES_ALL; ulCount++ )
{
rgcpropspecPIDs[ ulCount ] = ulCount + PID_FIRST_USABLE;
}
for( ulCount = 0;
ulCount < PERFORMANCE_ITERATIONS + STABILIZATION_ITERATIONS;
ulCount++ )
{
if( ulCount == STABILIZATION_ITERATIONS )
CoFileTimeNow( &filetimeStart );
for( int i = 0; i < CPROPERTIES_ALL; i++ )
{
Check(S_OK, pPStg->WriteMultiple( 1, &rgcpropspecPIDs[i], &g_rgcpropvarAll[i], PID_FIRST_USABLE ));
}
Check( S_OK, ResetRGPropVar( g_rgcpropvarAll ));
}
CoFileTimeNow( &filetimeEnd );
filetimeEnd -= filetimeStart;
PRINTF( "%4.2f ms\n", (float) filetimeEnd.dwLowDateTime
/
10000 // 100 ns units to 1 ms units
/
PERFORMANCE_ITERATIONS );
pPStg->Release();
pPStg = NULL;
}
//#endif // #ifndef _MAC
} // test_Performance()
//
// Function: test_CoFileTimeNow
//
// This function has nothing to do with the property set code,
// but a property test happenned to expose a bug in it, so this
// was just as good a place as any to test the fix.
//
void
test_CoFileTimeNow()
{
#ifndef _MAC // No need to test this on the Mac, and we can't
// because it doesn't support SYSTEMTIME.
Status( "CoFileTimeNow " );
FILETIME ftCoFileTimeNow;
FILETIME ftCalculated;
SYSTEMTIME stCalculated;
// Test the input validation
Check(E_INVALIDARG, CoFileTimeNow( NULL ));
Check(E_INVALIDARG, CoFileTimeNow( (FILETIME*) 0x01234567 ));
// The bug in CoFileTimeNow caused it to report a time that was
// 900 ms short, 50% of the time. So let's just bounds check
// it several times as a verification.
for( int i = 0; i < 20; i++ )
{
Check(S_OK, CoFileTimeNow( &ftCoFileTimeNow ));
GetSystemTime(&stCalculated);
Check(TRUE, SystemTimeToFileTime(&stCalculated, &ftCalculated));
Check(TRUE, ftCoFileTimeNow <= ftCalculated );
Check(S_OK, CoFileTimeNow( &ftCoFileTimeNow ));
Check(TRUE, ftCoFileTimeNow >= ftCalculated );
// The CoFileTimeNow bug caused it to report the correct
// time for a second, then the 900 ms short time for a second.
// So let's sleep in this loop and ensure that we cover both
// seconds.
if( g_fVerbose )
PRINTF( "." );
Sleep(200);
}
PRINTF( "\n" );
#endif // #ifndef _MAC
}
void
test_PROPSETFLAG_UNBUFFERED( IStorage *pStg )
{
// ----------
// Initialize
// ----------
if( PROPIMP_DOCFILE_OLE32 != g_enumImplementation
&&
PROPIMP_DOCFILE_IPROP != g_enumImplementation )
return;
Status( "PROPSETFLAG_UNBUFFERED\n" );
IStorage *pStgBase = NULL;
IPropertyStorage *pPropStgUnbuffered = NULL, *pPropStgBuffered = NULL;
IStream *pstmUnbuffered = NULL, *pstmBuffered = NULL;
CPropSpec cpropspec;
CPropVariant cpropvar;
FMTID fmtidUnbuffered, fmtidBuffered;
OLECHAR oszPropStgNameUnbuffered[ CCH_MAX_PROPSTG_NAME+1 ],
oszPropStgNameBuffered[ CCH_MAX_PROPSTG_NAME+1 ];
// Generate two FMTIDs
UuidCreate( &fmtidUnbuffered );
UuidCreate( &fmtidBuffered );
// ----------------------------
// Create the Property Storages
// ----------------------------
// Create a transacted Storage
Check( S_OK, pStg->CreateStorage(
OLESTR("test_PROPSETFLAG_UNBUFFERED"),
STGM_CREATE | STGM_TRANSACTED | STGM_READWRITE | STGM_SHARE_EXCLUSIVE,
0L, 0L,
&pStgBase ));
// Verify that we have the necessary APIs
Check( TRUE, g_pfnFmtIdToPropStgName && g_pfnPropStgNameToFmtId
&& g_pfnStgCreatePropSetStg && g_pfnStgCreatePropStg
&& g_pfnStgOpenPropStg );
// What are the property storages' stream names?
g_pfnFmtIdToPropStgName( &fmtidUnbuffered, oszPropStgNameUnbuffered );
g_pfnFmtIdToPropStgName( &fmtidBuffered, oszPropStgNameBuffered );
// Create Streams for the property storages
Check( S_OK, pStgBase->CreateStream(
oszPropStgNameUnbuffered,
STGM_CREATE | STGM_READWRITE | STGM_SHARE_EXCLUSIVE,
0L, 0L,
&pstmUnbuffered ));
Check( S_OK, pStgBase->CreateStream(
oszPropStgNameBuffered,
STGM_CREATE | STGM_READWRITE | STGM_SHARE_EXCLUSIVE,
0L, 0L,
&pstmBuffered ));
// Create two direct-mode IPropertyStorages (one buffered, one not)
Check( S_OK, g_pfnStgCreatePropStg( (IUnknown*) pstmUnbuffered,
fmtidUnbuffered,
&CLSID_NULL,
PROPSETFLAG_UNBUFFERED,
0L, // Reserved
&pPropStgUnbuffered ));
pPropStgUnbuffered->Commit( STGC_DEFAULT );
pstmUnbuffered->Release(); pstmUnbuffered = NULL;
Check( S_OK, g_pfnStgCreatePropStg( (IUnknown*) pstmBuffered,
fmtidBuffered,
&CLSID_NULL,
PROPSETFLAG_DEFAULT,
0L, // Reserved
&pPropStgBuffered ));
pPropStgBuffered->Commit( STGC_DEFAULT );
pstmBuffered->Release(); pstmBuffered = NULL;
// -------------------------
// Write, Commit, and Revert
// -------------------------
// Write to both property storages
cpropvar = "A Test String";
cpropspec = OLESTR("Property Name");
Check( S_OK, pPropStgUnbuffered->WriteMultiple( 1,
cpropspec,
&cpropvar,
PID_FIRST_USABLE ));
Check( S_OK, pPropStgBuffered->WriteMultiple( 1,
cpropspec,
&cpropvar,
PID_FIRST_USABLE ));
// Commit the base Storage. This should only cause
// the Unbuffered property to be commited.
pStgBase->Commit( STGC_DEFAULT );
// Revert the base Storage, and release the property storages.
// This should cause the property in the buffered property storage
// to be lost.
pStgBase->Revert();
pPropStgUnbuffered->Release(); pPropStgUnbuffered = NULL;
pPropStgBuffered->Release(); pPropStgBuffered = NULL;
// -----------------------------
// Re-Open the property storages
// -----------------------------
// Open the property storage Streams
Check( S_OK, pStgBase->OpenStream( oszPropStgNameUnbuffered,
0L,
STGM_READWRITE | STGM_SHARE_EXCLUSIVE,
0L,
&pstmUnbuffered ));
Check( S_OK, pStgBase->OpenStream( oszPropStgNameBuffered,
0L,
STGM_READWRITE | STGM_SHARE_EXCLUSIVE,
0L,
&pstmBuffered ));
// Get IPropertyStorage interfaces
Check( S_OK, g_pfnStgOpenPropStg( (IUnknown*) pstmUnbuffered,
fmtidUnbuffered,
PROPSETFLAG_UNBUFFERED,
0L, // Reserved
&pPropStgUnbuffered ));
pstmUnbuffered->Release(); pstmUnbuffered = NULL;
Check( S_OK, g_pfnStgOpenPropStg( (IUnknown*) pstmBuffered,
fmtidBuffered,
PROPSETFLAG_DEFAULT,
0L, // Reserved
&pPropStgBuffered ));
pstmBuffered->Release(); pstmBuffered = NULL;
// --------------------
// Validate the results
// --------------------
// We should only find the property in the un-buffered property set.
cpropvar.Clear();
Check( S_OK, pPropStgUnbuffered->ReadMultiple( 1, cpropspec, &cpropvar ));
cpropvar.Clear();
Check( S_FALSE, pPropStgBuffered->ReadMultiple( 1, cpropspec, &cpropvar ));
cpropvar.Clear();
} // test_PROPSETFLAG_UNBUFFERED()
void
test_PropStgNameConversion2()
{
Status( "FmtIdToPropStgName & PropStgNameToFmtId\n" );
// ------
// Locals
// ------
FMTID fmtidOriginal, fmtidNew;
OLECHAR oszPropStgName[ CCH_MAX_PROPSTG_NAME+1 ];
// ----------------------------------
// Do a simple conversion and inverse
// ----------------------------------
UuidCreate( &fmtidOriginal );
fmtidNew = FMTID_NULL;
Check( S_OK, g_pfnFmtIdToPropStgName( &fmtidOriginal, oszPropStgName ));
Check( S_OK, g_pfnPropStgNameToFmtId( oszPropStgName, &fmtidNew ));
Check( TRUE, fmtidOriginal == fmtidNew );
// -----------------------
// Check the special-cases
// -----------------------
// Summary Information
Check( S_OK, g_pfnFmtIdToPropStgName( &FMTID_SummaryInformation, oszPropStgName ));
Check( 0, ocscmp( oszPropStgName, oszSummaryInformation ));
Check( S_OK, g_pfnPropStgNameToFmtId( oszPropStgName, &fmtidNew ));
Check( TRUE, FMTID_SummaryInformation == fmtidNew );
// DocSumInfo (first section)
Check( S_OK, g_pfnFmtIdToPropStgName( &FMTID_DocSummaryInformation, oszPropStgName ));
Check( 0, ocscmp( oszPropStgName, oszDocSummaryInformation ));
Check( S_OK, g_pfnPropStgNameToFmtId( oszPropStgName, &fmtidNew ));
Check( TRUE, FMTID_DocSummaryInformation == fmtidNew );
// DocSumInfo (second section)
Check( S_OK, g_pfnFmtIdToPropStgName( &FMTID_UserDefinedProperties, oszPropStgName ));
Check( 0, ocscmp( oszPropStgName, oszDocSummaryInformation ));
Check( S_OK, g_pfnPropStgNameToFmtId( oszPropStgName, &fmtidNew ));
Check( TRUE, FMTID_DocSummaryInformation == fmtidNew );
// GlobalInfo (for PictureIt!)
Check( S_OK, g_pfnFmtIdToPropStgName( &fmtidGlobalInfo, oszPropStgName ));
Check( 0, ocscmp( oszPropStgName, oszGlobalInfo ));
Check( S_OK, g_pfnPropStgNameToFmtId( oszPropStgName, &fmtidNew ));
Check( TRUE, fmtidGlobalInfo == fmtidNew );
// ImageContents (for PictureIt!)
Check( S_OK, g_pfnFmtIdToPropStgName( &fmtidImageContents, oszPropStgName ));
Check( 0, ocscmp( oszPropStgName, oszImageContents ));
Check( S_OK, g_pfnPropStgNameToFmtId( oszPropStgName, &fmtidNew ));
Check( TRUE, fmtidImageContents == fmtidNew );
// ImageInfo (for PictureIt!)
Check( S_OK, g_pfnFmtIdToPropStgName( &fmtidImageInfo, oszPropStgName ));
Check( 0, ocscmp( oszPropStgName, oszImageInfo ));
Check( S_OK, g_pfnPropStgNameToFmtId( oszPropStgName, &fmtidNew ));
Check( TRUE, fmtidImageInfo == fmtidNew );
} // test_PropStgNameConversion()
void
test_PropStgNameConversion( IStorage *pStg )
{
if( g_Restrictions & RESTRICT_NON_HIERARCHICAL ) return;
Status( "Special-case property set names\n" );
// ------
// Locals
// ------
IStorage *pStgSub = NULL;
IPropertyStorage *pPropStg = NULL;
IPropertySetStorage *pPropSetStg = NULL;
IEnumSTATSTG *pEnumStg = NULL;
IEnumSTATPROPSETSTG *pEnumPropSet = NULL;
STATSTG rgstatstg[ NUM_WELL_KNOWN_PROPSETS ];
STATPROPSETSTG rgstatpropsetstg[ NUM_WELL_KNOWN_PROPSETS ];
UINT i;
DWORD cEnum;
BOOL bSumInfo= FALSE,
bDocSumInfo= FALSE,
bGlobalInfo= FALSE,
bImageContents= FALSE,
bImageInfo= FALSE;
// ------------------------------
// Create a Storage for this test
// ------------------------------
Check( S_OK, pStg->CreateStorage( OLESTR("Special Cases"),
STGM_CREATE | STGM_READWRITE | STGM_SHARE_EXCLUSIVE,
0, 0,
&pStgSub ));
// And get an IPropertySetStorage
Check( S_OK, StgToPropSetStg( pStgSub, &pPropSetStg ));
// --------------------------------------------------
// Create one of each of the well-known property sets
// --------------------------------------------------
Check( S_OK, pPropSetStg->Create( FMTID_SummaryInformation,
&CLSID_NULL,
PROPSETFLAG_ANSI,
STGM_CREATE | STGM_READWRITE | STGM_SHARE_EXCLUSIVE,
&pPropStg ));
RELEASE_INTERFACE( pPropStg );
Check( S_OK, pPropSetStg->Create( FMTID_DocSummaryInformation,
&CLSID_NULL,
PROPSETFLAG_ANSI,
STGM_CREATE | STGM_READWRITE | STGM_SHARE_EXCLUSIVE,
&pPropStg ));
RELEASE_INTERFACE( pPropStg );
Check( S_OK, pPropSetStg->Create( FMTID_UserDefinedProperties,
&CLSID_NULL,
PROPSETFLAG_ANSI,
STGM_CREATE | STGM_READWRITE | STGM_SHARE_EXCLUSIVE,
&pPropStg ));
RELEASE_INTERFACE( pPropStg );
Check( S_OK, pPropSetStg->Create( fmtidGlobalInfo,
&CLSID_NULL,
PROPSETFLAG_ANSI,
STGM_CREATE | STGM_READWRITE | STGM_SHARE_EXCLUSIVE,
&pPropStg ));
RELEASE_INTERFACE( pPropStg );
Check( S_OK, pPropSetStg->Create( fmtidImageContents,
&CLSID_NULL,
PROPSETFLAG_ANSI,
STGM_CREATE | STGM_READWRITE | STGM_SHARE_EXCLUSIVE,
&pPropStg ));
RELEASE_INTERFACE( pPropStg );
Check( S_OK, pPropSetStg->Create( fmtidImageInfo,
&CLSID_NULL,
PROPSETFLAG_ANSI,
STGM_CREATE | STGM_READWRITE | STGM_SHARE_EXCLUSIVE,
&pPropStg ));
RELEASE_INTERFACE( pPropStg );
// ---------------------------------
// Verify the FMTID->Name conversion
// ---------------------------------
// We verify this by enumerating the Storage's streams,
// and checking for the expected names (e.g., we should see
// "SummaryInformation", "DocumentSummaryInformation", etc.)
Check( S_OK, pStgSub->EnumElements( 0, NULL, 0, &pEnumStg ));
// Get all of the names.
Check( S_FALSE, pEnumStg->Next( NUM_WELL_KNOWN_PROPSETS,
rgstatstg,
&cEnum ));
// There should only be WellKnown-1 stream names, since
// the UserDefined property set is part of the
// DocumentSummaryInformation stream.
Check( TRUE, cEnum == NUM_WELL_KNOWN_PROPSETS - 1 );
for( i = 0; i < cEnum; i++ )
{
if( !ocscmp( rgstatstg[i].pwcsName, oszSummaryInformation ))
bSumInfo= TRUE;
else if( !ocscmp( rgstatstg[i].pwcsName, oszDocSummaryInformation ))
bDocSumInfo= TRUE;
else if( !ocscmp( rgstatstg[i].pwcsName, oszGlobalInfo ))
bGlobalInfo= TRUE;
else if( !ocscmp( rgstatstg[i].pwcsName, oszImageContents ))
bImageContents= TRUE;
else if( !ocscmp( rgstatstg[i].pwcsName, oszImageInfo ))
bImageInfo= TRUE;
delete [] rgstatstg[i].pwcsName;
}
// Verify that we found all the names we expected to find.
Check( TRUE, bSumInfo && bDocSumInfo
&& bGlobalInfo && bImageContents && bImageInfo );
RELEASE_INTERFACE( pEnumStg );
// ---------------------------------
// Verify the Name->FMTID Conversion
// ---------------------------------
// We do this by enumerating the property sets with IPropertySetStorage,
// and verify that it correctly converts the Stream names to the
// expected FMTIDs.
bSumInfo = bDocSumInfo = bGlobalInfo = bImageContents = bImageInfo = FALSE;
// Get the enumerator.
Check( S_OK, pPropSetStg->Enum( &pEnumPropSet ));
// Get all the property sets.
Check( S_FALSE, pEnumPropSet->Next( NUM_WELL_KNOWN_PROPSETS,
rgstatpropsetstg,
&cEnum ));
Check( TRUE, cEnum == NUM_WELL_KNOWN_PROPSETS - 1 );
// Look for each of the expected FMTIDs. We only look at WellKnown-1,
// because the UserDefined property set doesn't get enumerated.
for( i = 0; i < NUM_WELL_KNOWN_PROPSETS - 1; i++ )
{
if( rgstatpropsetstg[i].fmtid == FMTID_SummaryInformation )
bSumInfo = TRUE;
else if( rgstatpropsetstg[i].fmtid == FMTID_DocSummaryInformation )
bDocSumInfo = TRUE;
else if( rgstatpropsetstg[i].fmtid == fmtidGlobalInfo )
bGlobalInfo = TRUE;
else if( rgstatpropsetstg[i].fmtid == fmtidImageContents )
bImageContents = TRUE;
else if( rgstatpropsetstg[i].fmtid == fmtidImageInfo )
bImageInfo = TRUE;
}
// NOTE: There is no way(?) to test the name-to-FMTID
// conversion for the UserDefined property set without
// calling the conversion function directly, but that
// function isn't exported on Win95.
// Verify that we found all of the expected FMTIDs
Check( TRUE, bSumInfo && bDocSumInfo
&& bGlobalInfo && bImageContents && bImageInfo );
RELEASE_INTERFACE( pEnumPropSet );
RELEASE_INTERFACE( pPropSetStg );
RELEASE_INTERFACE( pStgSub );
} // test_PropStgNameConversion()
//-----------------------------------------------------------------------------
//
// Function: test_SimpleLeaks
//
// This is a simple leak test. It doesn't test all functionality for
// leaks; it just checks the common path: create, open, read, write,
// and delete.
//
//-----------------------------------------------------------------------------
void test_SimpleLeaks( LPOLESTR poszDir )
{
IStorage *pStg = NULL;
IPropertySetStorage *pPropSetStg = NULL;
SYSTEM_PROCESS_INFORMATION spiStart, spiEnd;
OLECHAR oszTempFile[ MAX_PATH + 1 ];
ocscpy( oszTempFile, poszDir );
ocscat( oszTempFile, OLESTR("SimpleLeakTest") );
Status( "Simple Leak Test " );
Check( STATUS_SUCCESS, GetProcessInfo(&spiStart) );
for( long i = 0; i < 1*1000*1000; i++ )
{
if( i % (50*1000) == 0 )
PRINTF( "x");
CPropSpec rgpropspec[2];
CPropVariant rgpropvarWrite[2], rgpropvarRead[2];
IPropertyStorage *pPropStg = NULL;
Check( S_OK, g_pfnStgCreateStorageEx( oszTempFile,
STGM_CREATE | STGM_READWRITE | STGM_SHARE_EXCLUSIVE
|
( ((i&1) && !(g_Restrictions & RESTRICT_DIRECT_ONLY)) ? STGM_TRANSACTED : STGM_DIRECT ),
DetermineStgFmt( g_enumImplementation ),
0L,
NULL,
NULL,
IID_IPropertySetStorage,
(void**) &pPropSetStg));
Check( S_OK, pPropSetStg->Create( FMTID_NULL, NULL,
( (i&2) && !(g_Restrictions & RESTRICT_UNICODE_ONLY) ? PROPSETFLAG_ANSI : PROPSETFLAG_DEFAULT )
|
( (i&4) && !(g_Restrictions & RESTRICT_SIMPLE_ONLY) ? PROPSETFLAG_NONSIMPLE : PROPSETFLAG_DEFAULT ),
STGM_CREATE | STGM_READWRITE | STGM_SHARE_EXCLUSIVE
|
( (i&8) && !(g_Restrictions & RESTRICT_DIRECT_ONLY) ? STGM_TRANSACTED : STGM_DIRECT ),
&pPropStg ));
rgpropspec[0] = OLESTR("Property Name");
rgpropspec[1] = 1000;
rgpropvarWrite[0] = "Hello, world";
rgpropvarWrite[1] = (ULONG) 23;
Check( S_OK, pPropStg->WriteMultiple( 2, rgpropspec, rgpropvarWrite, PID_FIRST_USABLE ));
Check( S_OK, pPropStg->Commit( STGC_DEFAULT ));
Check( 0, pPropStg->Release() );
Check( S_OK, pPropSetStg->Open( FMTID_NULL,
( (i&16) && !(g_Restrictions & RESTRICT_DIRECT_ONLY) ? STGM_TRANSACTED : STGM_DIRECT )
|
STGM_READWRITE | STGM_SHARE_EXCLUSIVE,
&pPropStg ));
Check( S_OK, pPropStg->ReadMultiple( 2, rgpropspec, rgpropvarRead ));
Check( TRUE, rgpropvarRead[0] == rgpropvarWrite[0]
&&
rgpropvarRead[1] == rgpropvarWrite[1] );
Check( S_OK, pPropStg->DeleteMultiple( 2, rgpropspec ));
Check( S_OK, pPropStg->Commit( STGC_DEFAULT ));
Check( 0, pPropStg->Release() );
Check( S_OK, pPropSetStg->Delete( FMTID_NULL ));
Check( 0, pPropSetStg->Release() );
}
Check( STATUS_SUCCESS, GetProcessInfo(&spiEnd) );
if( g_fVerbose )
{
PRINTF( "\n" );
PRINTF( " process id %I64u\n", (ULONG_PTR) spiEnd.UniqueProcessId );
PRINTF( " threads %lu, %lu\n", spiStart.NumberOfThreads, spiEnd.NumberOfThreads );
PRINTF( " handles %lu, %lu\n", spiStart.HandleCount, spiEnd.HandleCount );
PRINTF( " virtual size %lu, %lu\n", spiStart.VirtualSize, spiEnd.VirtualSize );
PRINTF( " peak virtual size %lu, %lu\n", spiStart.PeakVirtualSize, spiEnd.PeakVirtualSize );
PRINTF( " working set %lu, %lu\n", spiStart.WorkingSetSize, spiEnd.WorkingSetSize );
PRINTF( " peak working set %lu, %lu\n", spiStart.PeakWorkingSetSize, spiEnd.PeakWorkingSetSize );
PRINTF( " pagefile usage %lu, %lu\n", spiStart.PagefileUsage, spiEnd.PagefileUsage );
PRINTF( " peak pagefile usage %lu, %lu\n", spiStart.PeakPagefileUsage, spiEnd.PeakPagefileUsage );
PRINTF( " private memory %lu, %lu\n", spiStart.PrivatePageCount, spiEnd.PrivatePageCount );
PRINTF( " quota paged pool %lu, %lu\n", spiStart.QuotaPagedPoolUsage, spiEnd.QuotaPagedPoolUsage );
PRINTF( " peak quota paged pool %lu, %lu\n", spiStart.QuotaPeakPagedPoolUsage, spiEnd.QuotaPeakPagedPoolUsage );
PRINTF( " quota non-paged pool %lu, %lu\n", spiStart.QuotaNonPagedPoolUsage, spiEnd.QuotaNonPagedPoolUsage );
PRINTF( " peak quota non-paged pool %lu, %lu\n", spiStart.QuotaPeakNonPagedPoolUsage, spiEnd.QuotaPeakNonPagedPoolUsage );
}
// Ensure that the working set and pagefile usage didn't change by
// more than 5%
ULONG ulWorkingSetDifference = spiEnd.WorkingSetSize > spiStart.WorkingSetSize
? spiEnd.WorkingSetSize - spiStart.WorkingSetSize
: spiStart.WorkingSetSize - spiEnd.WorkingSetSize;
ULONG ulPagefileUsageDifference = spiEnd.PagefileUsage > spiStart.PagefileUsage
? spiEnd.PagefileUsage - spiStart.PagefileUsage
: spiStart.PagefileUsage - spiEnd.PagefileUsage;
Check( TRUE,
( ulWorkingSetDifference == 0
||
spiStart.WorkingSetSize/ulWorkingSetDifference >= 20
)
&&
( ulPagefileUsageDifference == 0
||
spiStart.PagefileUsage/ulPagefileUsageDifference >= 20
)
);
} // test_SimpleLeaks
//-----------------------------------------------------------------------------
//
// Function: test_SimpleDocFile
//
// This function tests PropSet functionality on Simple DocFile.
// This test comes in multiple phases:
// 1) A simple docfile is created and a minimal amount of data is stored
// in it.
// 2) The docfile is closed and opened again. The test attempts to write
// a small string to the property storage in it. This should succeed.
// Then it attempts to write a 4K string, which should fail.
// 3) The docfile is closed and opened again. The test writes 3 small
// strings to the prop storage. This should be successful.
//
// 4) The docfile is deleted. A new docfile with a property set storage is
// created, and more than 4K data is written to it.
// 5) The docfile is opened and writing additional data to it should fail.
//
//-----------------------------------------------------------------------------
#define FOUR_K_SIZE 0x1000 // Make it at least 4K.
#define THREE_H_SIZE 300 // 300 bytes
#define ONE_H_SIZE 100 // 100 bytes
void
test_SimpleDocFile(LPOLESTR oszDir)
{
IStorage *pDfStg = NULL;
IPropertySetStorage *pPropSetStg = NULL;
IPropertyStorage *pPropStg = NULL;
OLECHAR oszFile[MAX_PATH];
CPropSpec rgPropSpec[3];
CPropVariant rgPropVariant[3];
LPSTR pFourKString;
int i;
if( RESTRICT_NON_HIERARCHICAL & g_Restrictions ) return; // NFF doesn't support simp mode
Status( "Simple-mode docfile\n" );
//
// Generate a filename from the directory name.
//
ocscpy( oszFile, oszDir );
ocscat( oszFile, OLESTR( "SimpDoc.stg" ));
//
// allocate a buffer with 1 less than 4K
// and fill it with characters.
//
pFourKString = new CHAR[ FOUR_K_SIZE ];
Check(TRUE, pFourKString != NULL);
pFourKString[0] = '\0';
for (i=0; i < ((FOUR_K_SIZE/8)-1); i++)
{
strcat(pFourKString,"abcd1234");
}
strcat(pFourKString,"abcd123");
rgPropSpec[0] = 0x10;
rgPropSpec[1] = 0x11;
rgPropSpec[2] = 0x12;
//-------------------
// 1st Test - setup
//-------------------
// Create a Docfile.
//
Check( S_OK, g_pfnStgCreateStorageEx( oszFile,
STGM_CREATE | STGM_READWRITE | STGM_SHARE_EXCLUSIVE | STGM_SIMPLE,
DetermineStgFmt( g_enumImplementation ),
0L, NULL, NULL,
DetermineStgIID( g_enumImplementation ),
reinterpret_cast<void**>(&pDfStg) ));
Check(S_OK, StgToPropSetStg( pDfStg, &pPropSetStg ));
// Test that we can QI between IStorage and IPropertySetStorage
if( UsingQIImplementation() )
{
IStorage *pstg2 = NULL, *pstg3 = NULL;
IPropertySetStorage *ppropsetstg2 = NULL, *ppropsetstg3 = NULL;
ULONG cRefs = GetRefCount( pDfStg );
Check( S_OK, pDfStg->QueryInterface( IID_IStorage, reinterpret_cast<void**>(&pstg2) ));
Check( S_OK, pstg2->QueryInterface( IID_IPropertySetStorage, reinterpret_cast<void**>(&ppropsetstg2) ));
Check( S_OK, ppropsetstg2->QueryInterface( IID_IStorage, reinterpret_cast<void**>(&pstg3) ));
Check( TRUE, pstg2 == pstg3 );
Check( S_OK, pstg3->QueryInterface( IID_IPropertySetStorage, reinterpret_cast<void**>(&ppropsetstg3) ));
Check( TRUE, ppropsetstg2 == ppropsetstg3 );
RELEASE_INTERFACE(ppropsetstg3);
RELEASE_INTERFACE(ppropsetstg2);
RELEASE_INTERFACE(pstg3);
Check( cRefs, RELEASE_INTERFACE(pstg2) );
}
Check( S_OK, pPropSetStg->Create( FMTID_UserDefinedProperties,
&CLSID_NULL,
PROPSETFLAG_ANSI,
STGM_READWRITE | STGM_SHARE_EXCLUSIVE,
&pPropStg ));
//
// Write several strings to the property storage
//
rgPropVariant[0] = "Hello, world";
Check(S_OK, pPropStg->WriteMultiple(1, rgPropSpec, rgPropVariant, PID_FIRST_USABLE));
rgPropVariant[0] = "New string for offset 0";
Check(S_OK, pPropStg->WriteMultiple(1, rgPropSpec, rgPropVariant, PID_FIRST_USABLE));
rgPropVariant[1] = "First string for offset 1";
Check(S_OK, pPropStg->WriteMultiple(3, rgPropSpec, rgPropVariant, PID_FIRST_USABLE));
//
// Release the storages and docfile.
//
RELEASE_INTERFACE(pPropStg);
RELEASE_INTERFACE(pPropSetStg);
RELEASE_INTERFACE(pDfStg);
//--------------
// 2nd Test
//--------------
//
// Now Open the DocFile and storages
// and write a small stream followed by a 4K stream.
//
//
Check(S_OK, g_pfnStgOpenStorageEx(oszFile,
STGM_READWRITE | STGM_SHARE_EXCLUSIVE | STGM_SIMPLE,
STGFMT_ANY,
0L, NULL, NULL,
IID_IStorage,
reinterpret_cast<void**>(&pDfStg) ));
Check(S_OK, StgToPropSetStg( pDfStg, &pPropSetStg ));
Check(S_OK, pPropSetStg->Open(FMTID_UserDefinedProperties,
STGM_SHARE_EXCLUSIVE | STGM_READWRITE, &pPropStg));
//
// Write a small string followed by a string that is at least 4K.
// The large string write should fail because the simple stream allocates
// a minimum size stream of 4K, and on an Open will not allow the stream to
// grow.
//
rgPropVariant[0] = "After Open, Hello, world";
rgPropVariant[1] = pFourKString;
rgPropVariant[2] = "Another string after the long one";
Check(S_OK, pPropStg->WriteMultiple(1, rgPropSpec, rgPropVariant, PID_FIRST_USABLE));
Check(STG_E_INVALIDFUNCTION, pPropStg->WriteMultiple(2, rgPropSpec, rgPropVariant, PID_FIRST_USABLE));
Check(STG_E_INVALIDFUNCTION, pPropStg->WriteMultiple(3, rgPropSpec, rgPropVariant, PID_FIRST_USABLE));
Check(S_OK, pPropStg->WriteMultiple(1, rgPropSpec, rgPropVariant, PID_FIRST_USABLE));
RELEASE_INTERFACE(pPropStg);
RELEASE_INTERFACE(pPropSetStg);
RELEASE_INTERFACE(pDfStg);
//--------------
// 3rd Test
//--------------
//
// Open the DocFile again, and write smaller strings to the same
// location.
//
Check(S_OK, g_pfnStgOpenStorageEx(oszFile,
STGM_READWRITE | STGM_SHARE_EXCLUSIVE | STGM_SIMPLE,
STGFMT_ANY,
0, NULL, NULL,
IID_IStorage,
reinterpret_cast<void**>(&pDfStg) ));
Check(S_OK, StgToPropSetStg( pDfStg, &pPropSetStg ));
Check(S_OK, pPropSetStg->Open(FMTID_UserDefinedProperties,
STGM_SHARE_EXCLUSIVE | STGM_READWRITE, &pPropStg));
//
// The smaller strings can be written because they fit in under the 4K
// size of the simple stream buffer.
//
rgPropVariant[0] = "2nd open, small string";
rgPropVariant[1] = "small string2";
rgPropVariant[2] = "small string3";
Check(S_OK, pPropStg->WriteMultiple(1, rgPropSpec, rgPropVariant, PID_FIRST_USABLE));
Check(S_OK, pPropStg->WriteMultiple(2, rgPropSpec, rgPropVariant, PID_FIRST_USABLE));
Check(S_OK, pPropStg->WriteMultiple(3, rgPropSpec, rgPropVariant, PID_FIRST_USABLE));
RELEASE_INTERFACE(pPropStg);
RELEASE_INTERFACE(pPropSetStg);
RELEASE_INTERFACE(pDfStg);
//---------------------------------
// 4th Test - Create Large PropSet
//---------------------------------
//
// Create a Docfile and fill with more than 4K.
//
Check( S_OK, g_pfnStgCreateStorageEx( oszFile,
STGM_CREATE | STGM_READWRITE | STGM_SHARE_EXCLUSIVE | STGM_SIMPLE,
DetermineStgFmt( g_enumImplementation ),
0L, NULL, NULL,
DetermineStgIID( g_enumImplementation ),
reinterpret_cast<void**>(&pDfStg) ));
Check(S_OK, StgToPropSetStg( pDfStg, &pPropSetStg ));
Check( S_OK, pPropSetStg->Create( FMTID_NULL,
&CLSID_NULL,
PROPSETFLAG_ANSI,
STGM_READWRITE | STGM_SHARE_EXCLUSIVE,
&pPropStg ));
rgPropSpec[0] = 0x10;
rgPropSpec[1] = 0x11;
rgPropSpec[2] = 0x12;
//
// Write several strings to the property storage
// The first one is a 4K string.
//
rgPropVariant[0] = pFourKString;
rgPropVariant[1] = "First string for offset 1";
rgPropVariant[2] = "small string3";
Check(S_OK, pPropStg->WriteMultiple(3, rgPropSpec, rgPropVariant, PID_FIRST_USABLE));
//
// Release the storages and docfile.
//
RELEASE_INTERFACE(pPropStg);
RELEASE_INTERFACE(pPropSetStg);
RELEASE_INTERFACE(pDfStg);
//--------------
// 5th Test
//--------------
//
// Open the DocFile again, and write the same strings in a different
// order.
//
Check(S_OK, g_pfnStgOpenStorageEx(oszFile,
STGM_READWRITE | STGM_SHARE_EXCLUSIVE | STGM_SIMPLE,
STGFMT_ANY,
0, NULL, NULL,
IID_IStorage,
reinterpret_cast<void**>(&pDfStg) ));
Check(S_OK, StgToPropSetStg( pDfStg, &pPropSetStg ));
Check(S_OK, pPropSetStg->Open(CLSID_NULL,
STGM_SHARE_EXCLUSIVE | STGM_READWRITE, &pPropStg));
//
// The smaller strings can be written because they fit in under the 4K
// size of the simple stream buffer.
//
rgPropVariant[0] = "small string0";
rgPropVariant[1] = "First string for offset 1";
rgPropVariant[2] = pFourKString;
Check(S_OK, pPropStg->WriteMultiple(3, rgPropSpec, rgPropVariant, PID_FIRST_USABLE));
RELEASE_INTERFACE(pPropStg);
RELEASE_INTERFACE(pPropSetStg);
RELEASE_INTERFACE(pDfStg);
//--------------
// 6th Test
//--------------
//
// Open the DocFile again, and write larger strings to the same
// location. This should fail.
//
Check(S_OK, g_pfnStgOpenStorageEx(oszFile,
STGM_READWRITE | STGM_SHARE_EXCLUSIVE | STGM_SIMPLE,
STGFMT_ANY,
0, NULL, NULL,
IID_IStorage,
reinterpret_cast<void**>(&pDfStg) ));
Check(S_OK, StgToPropSetStg( pDfStg, &pPropSetStg ));
Check(S_OK, pPropSetStg->Open(CLSID_NULL,
STGM_SHARE_EXCLUSIVE | STGM_READWRITE, &pPropStg));
//
// Now write the same thing again, only with one extra character.
// This should fail.
//
rgPropVariant[0] = "First string for offset 0";
rgPropVariant[1] = pFourKString;
rgPropVariant[2] = "small string00000";
Check(STG_E_INVALIDFUNCTION, pPropStg->WriteMultiple(3, rgPropSpec, rgPropVariant, PID_FIRST_USABLE));
RELEASE_INTERFACE(pPropStg);
RELEASE_INTERFACE(pPropSetStg);
RELEASE_INTERFACE(pDfStg);
delete [] pFourKString;
//--------------
// 7th Test - - A NON-SIMPLE MODE TEST
//--------------
//
// Create and write to a property set with an element of 400 bytes.
// Then delete 100 bytes. Commit the changes. The property set should
// have shrunk by at least 100 bytes.
//
// allocate a buffer with 300 bytes and fill it.
// and fill it with characters.
//
LPSTR pThreeHString = NULL;
LPSTR pOneHString = NULL;
//
// Fill the 3 Hundred Byte String
//
pThreeHString = new CHAR[ THREE_H_SIZE ];
Check(TRUE, pThreeHString != NULL);
pThreeHString[0] = '\0';
for (i=0; i < ((THREE_H_SIZE/8)-1); i++)
{
strcat(pThreeHString,"abcd1234");
}
strcat(pThreeHString,"abc");
//
// Fill the 1 Hundred Byte String
//
pOneHString = new CHAR[ ONE_H_SIZE ];
Check(TRUE, pOneHString != NULL);
pOneHString[0] = '\0';
for (i=0; i < ((ONE_H_SIZE/8)-1); i++)
{
strcat(pOneHString,"xyxy8787");
}
strcat(pOneHString,"xyx");
//
// Create a Docfile and fill with the string
//
Check( S_OK, g_pfnStgCreateStorageEx( oszFile,
STGM_CREATE | STGM_READWRITE | STGM_SHARE_EXCLUSIVE,
DetermineStgFmt( g_enumImplementation ),
0, NULL, NULL,
DetermineStgIID( g_enumImplementation ),
reinterpret_cast<void**>(&pDfStg) ));
Check(S_OK, StgToPropSetStg( pDfStg, &pPropSetStg ));
Check( S_OK, pPropSetStg->Create( FMTID_NULL,
&CLSID_NULL,
PROPSETFLAG_ANSI,
STGM_READWRITE | STGM_SHARE_EXCLUSIVE,
&pPropStg ));
rgPropSpec[0] = 0x10;
rgPropSpec[1] = 0x11;
//
// Write the string to the property storage
//
rgPropVariant[0] = pThreeHString;
rgPropVariant[1] = pOneHString;
Check(S_OK, pPropStg->WriteMultiple(2, rgPropSpec, rgPropVariant, PID_FIRST_USABLE));
//
// Commit the changes and close.
//
Check(S_OK, pPropStg->Commit( STGC_DEFAULT ));
RELEASE_INTERFACE(pPropStg);
RELEASE_INTERFACE(pPropSetStg);
RELEASE_INTERFACE(pDfStg);
//
// Check the size of the property set.
//
Check(S_OK, g_pfnStgOpenStorageEx(oszFile,
STGM_READWRITE | STGM_SHARE_EXCLUSIVE,
STGFMT_ANY,
0, NULL, NULL,
IID_IStorage,
reinterpret_cast<void**>(&pDfStg) ));
IStream *pStm;
STATSTG StatBuf;
OLECHAR ocsPropSetName[30];
DWORD cbStream;
RtlGuidToPropertySetName(&FMTID_NULL, ocsPropSetName);
Check(S_OK, pDfStg->OpenStream(
ocsPropSetName,
NULL,
STGM_SHARE_EXCLUSIVE | STGM_READWRITE,
0,
&pStm));
Check(S_OK, pStm->Stat( &StatBuf,STATFLAG_NONAME));
if (StatBuf.cbSize.HighPart != 0)
{
printf("FAILURE: test_SimpleDocFile: Test 7: Size High part is not zero\n");
}
cbStream = StatBuf.cbSize.LowPart;
RELEASE_INTERFACE(pStm);
//
// Delete
//
Check(S_OK, StgToPropSetStg( pDfStg, &pPropSetStg ));
Check(S_OK, pPropSetStg->Open(CLSID_NULL,
STGM_SHARE_EXCLUSIVE | STGM_READWRITE, &pPropStg));
Check(S_OK, pPropStg->DeleteMultiple(1, &rgPropSpec[1]));
//
// Commit the changes and close.
//
Check(S_OK, pPropStg->Commit( STGC_DEFAULT ));
RELEASE_INTERFACE(pPropStg);
RELEASE_INTERFACE(pPropSetStg);
RELEASE_INTERFACE(pDfStg);
//
// Check the size of the property set.
//
Check(S_OK, g_pfnStgOpenStorageEx(oszFile,
STGM_READWRITE | STGM_SHARE_EXCLUSIVE,
STGFMT_ANY,
0, NULL, NULL,
IID_IStorage,
reinterpret_cast<void**>(&pDfStg) ));
RtlGuidToPropertySetName(&FMTID_NULL, ocsPropSetName);
Check(S_OK, pDfStg->OpenStream(
ocsPropSetName,
NULL,
STGM_SHARE_EXCLUSIVE | STGM_READWRITE,
0,
&pStm));
Check(S_OK, pStm->Stat( &StatBuf,STATFLAG_NONAME));
Check(TRUE, (StatBuf.cbSize.HighPart == 0));
Check(TRUE, (cbStream - StatBuf.cbSize.LowPart > 100));
//
// Release the storages and docfile.
//
delete [] pThreeHString;
delete [] pOneHString;
RELEASE_INTERFACE(pStm);
RELEASE_INTERFACE(pDfStg);
} // test_SimpleDocFile
//-----------------------------------------------------------------------------
//
// Function: test_ex_api
//
// This function tests the StgOpenStorageEx API to make sure it correctly
// opens an NTFS flat file property set when called with STGFMT_ANY for a
// property set that was created on an NTFS flat file.
//
//-----------------------------------------------------------------------------
void
test_ex_api(LPOLESTR oszDir)
{
IStorage *pDfStg = NULL;
IPropertySetStorage *pPropSetStg = NULL;
IPropertyStorage *pPropStg = NULL;
OLECHAR oszFile[MAX_PATH];
CPropSpec rgPropSpec[3];
CPropVariant rgPropVariant[3];
LPSTR pFourKString;
int i;
HRESULT hr;
FMTID fmtidAnsi;
Status( "Ex API Tests\n" );
//
// Generate a filename from the directory name.
//
ocscpy( oszFile, oszDir );
ocscat( oszFile, OLESTR( "StgApi.dat" ));
//
// Create a property set storage and a prop storage
//
Check( S_OK, g_pfnStgCreateStorageEx( oszFile,
STGM_CREATE | STGM_READWRITE | STGM_SHARE_EXCLUSIVE,
DetermineStgFmt( g_enumImplementation ),
0L,
NULL,
NULL,
IID_IPropertySetStorage,
(void**) &pPropSetStg));
Check(S_OK,pPropSetStg->Create( FMTID_NULL, NULL,
PROPSETFLAG_DEFAULT,
STGM_READWRITE | STGM_SHARE_EXCLUSIVE,
&pPropStg ));
//
// Write a string to it.
//
rgPropSpec[0] = 0x10;
rgPropVariant[0] = "Hello, world";
Check(S_OK, pPropStg->WriteMultiple(1, rgPropSpec, rgPropVariant, PID_FIRST_USABLE));
//
// Close it
//
pPropStg->Release();
pPropStg = NULL;
pPropSetStg->Release();
pPropSetStg = NULL;
//
// Open it.
//
Check(S_OK,g_pfnStgOpenStorageEx( oszFile,
STGM_READWRITE | STGM_SHARE_EXCLUSIVE,
STGFMT_ANY,
0L,
NULL,
NULL,
IID_IPropertySetStorage,
(void**) &pPropSetStg ));
UuidCreate( &fmtidAnsi );
//
// Attempt to create an ANSI prop storage
//
Check(S_OK, pPropSetStg->Create( fmtidAnsi, &CLSID_NULL,
PROPSETFLAG_ANSI,
STGM_READWRITE | STGM_SHARE_EXCLUSIVE,
&pPropStg ));
//
// Clean up before exiting.
//
if (pPropStg)
{
pPropStg->Release();
pPropStg = NULL;
}
if (pPropSetStg)
{
pPropSetStg->Release();
pPropSetStg = NULL;
}
}
void
test_UnsupportedProperties( IStorage *pStg )
{
IPropertySetStorage *pPropSetStg = NULL;
IPropertyStorage *pPropStg = NULL;
CPropVariant rgcpropvarWrite[2], cpropvarRead;
CPropSpec rgcpropspec[2];
Status( "Unsupported VarTypes\n" );
FMTID fmtid;
UuidCreate(&fmtid);
// Start by creating a property set with a couple of properties in it.
Check( S_OK, StgToPropSetStg( pStg, &pPropSetStg ));
Check( S_OK, pPropSetStg->Create( fmtid, NULL,
PROPSETFLAG_DEFAULT | PROPSETFLAG_CASE_SENSITIVE,
STGM_CREATE|STGM_READWRITE|STGM_SHARE_EXCLUSIVE,
&pPropStg ));
rgcpropvarWrite[0] = (long) 1234; // VT_I4
rgcpropvarWrite[1] = (short) 56; // VT_I2
rgcpropspec[0] = PID_FIRST_USABLE;
rgcpropspec[1] = PID_FIRST_USABLE + 1;
Check( S_OK, pPropStg->WriteMultiple( 2, rgcpropspec, rgcpropvarWrite, PID_FIRST_USABLE ));
// Modify the first property so that it has an invalid VT
RELEASE_INTERFACE( pPropStg );
ModifyPropertyType( pStg, fmtid, rgcpropspec[0].propid, 0x500 );
// Try to read that property back (the one with the invalid VT)
Check( S_OK, pPropSetStg->Open( fmtid, STGM_READWRITE|STGM_SHARE_EXCLUSIVE, &pPropStg ));
Check( HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED),
pPropStg->ReadMultiple( 1, &rgcpropspec[0], &cpropvarRead ));
// Verify that we can read back the other property
Check( S_OK, pPropStg->ReadMultiple( 1, &rgcpropspec[1], &cpropvarRead ));
Check( TRUE, cpropvarRead == rgcpropvarWrite[1] );
// And verify that we can't write a property with an invalid VT
rgcpropvarWrite[0].vt = 0x500;
Check( HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED),
pPropStg->WriteMultiple( 1, &rgcpropspec[0], &rgcpropvarWrite[0], PID_FIRST_USABLE ));
RELEASE_INTERFACE( pPropStg );
RELEASE_INTERFACE( pPropSetStg );
}
Reference in a new issue View git blame Copy permalink