archive
/
windows-server-2003
mirror of https://github.com/selfrender/Windows-Server-2003
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Leaked source code of windows server 2003
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4 Commits
1 Branch
0 Tags
1.5 GiB
 
 
 
 
 
 
Branch: master
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'master'
${ noResults }
windows-server-2003/com/oleutest/stgbvt/ctolestg/tests/stgbase/stgtests.cxx

5886 lines
160 KiB
Raw Permalink Blame History

//-------------------------------------------------------------------------
//
// Microsoft OLE
// Copyright (C) Microsoft Corporation, 1994 - 1995.
//
// File: stgtsts.cxx
//
// Contents: storage base tests basically pertaining to IStorage interface
//
// Functions:
//
// History: 10-July-1996 NarindK Created.
// 27-Mar-97 SCousens conversionified
// 06-Aug-97 FarzanaR cleaned up tests for stress
// BUGBUG : this file still requires to be cleaned up for stress.
//
//--------------------------------------------------------------------------
#include <dfheader.hxx>
#pragma hdrstop
#include "init.hxx"
// externs
extern BOOL g_fRevert;
//----------------------------------------------------------------------------
//
// Test: STGTEST_100
//
// Synopsis: A root docfile and child IStorage are created and committed.
// The child IStorage is released and then destroyed. The root is
// then committed and a new child IStorage is created with the same
// name as the original one. The child IStorage and root docfile
// are then released without committing. The root docfile is then
// reinstantiated. The test attempts to instantiate a child
// IStorage with the name used for the original one. The test
// verifies that no such IStorage exists because it should have been
// deleted.
//
// Arguments:[argc]
// [argv]
//
// Returns: HRESULT
//
// History: 10-July-1996 NarindK Created.
//
// Notes: This test runs in transacted, and transacted deny write modes
//
// New Test Notes:
// 1. Old File: DFCOMREL.CXX
// 2. Old name of test : MiscCommitRelease Test
// New Name of test : STGTEST_100
// 3. To run the test, do the following at command prompt.
// a. stgbase /seed:2 /dfdepth:0-0 /dfstg:0-0 /dfstm:0-0 /t:STGTEST-100
// /dfRootMode:xactReadWriteShEx /dfStgMode:xactReadWriteShEx
// b. stgbase /seed:2 /dfdepth:0-0 /dfstg:0-0 /dfstm:0-0 /t:STGTEST-100
// /dfRootMode:xactReadWriteShDenyW /dfStgMode:xactReadWriteShEx
//
// BUGNOTE: Conversion: STGTEST-100
//
//-----------------------------------------------------------------------------
HRESULT STGTEST_100(int argc, char *argv[])
{
HRESULT hr = S_OK;
ChanceDF *pTestChanceDF = NULL;
VirtualDF *pTestVirtualDF = NULL;
VirtualCtrNode *pVirtualDFRoot = NULL;
DG_STRING *pdgu = NULL;
USHORT usErr = 0;
VirtualCtrNode *pvcnRootNewChildStg = NULL;
LPTSTR pRootNewChildStgName = NULL;
DWORD dwRootMode = 0;
DWORD dwStgMode = 0;
BOOL fPass = TRUE;
DH_FUNCENTRY(NULL, DH_LVL_DFLIB, _TEXT("STGTEST_100"));
DH_TRACE((DH_LVL_TRACE1, TEXT("--------------------------------------------")) );
DH_TRACE((DH_LVL_TRACE1, TEXT("Test variation STGTEST_100 started.")) );
DH_TRACE((DH_LVL_TRACE1, TEXT("Attempt storage commit/release operations")) );
// Create our ChanceDF and VirtualDF
hr = CreateTestDocfile (argc,
argv,
&pVirtualDFRoot,
&pTestVirtualDF,
&pTestChanceDF);
// if creating the docfile - bail here
if (NULL != pTestChanceDF && DoingCreate ())
{
UINT ulSeed = pTestChanceDF->GetSeed ();
CleanupTestDocfile (&pVirtualDFRoot,
&pTestVirtualDF,
&pTestChanceDF,
FALSE);
return (HRESULT)ulSeed;
}
if (S_OK == hr)
{
dwRootMode = pTestChanceDF->GetRootMode();
dwStgMode = pTestChanceDF->GetStgMode();
DH_TRACE((
DH_LVL_TRACE1,
TEXT("Run Mode for STGTEST_100, Access mode: %lx"),
dwRootMode));
}
// Commit root. BUGBUG already commited
if(S_OK == hr)
{
hr = pVirtualDFRoot->Commit(STGC_DEFAULT);
if (S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Commit completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Commit unsuccessful, hr=0x%lx."),
hr));
}
}
// Get DG_STRING object pointer
if (S_OK == hr)
{
pdgu = pTestVirtualDF->GetDataGenUnicode();
DH_ASSERT(NULL != pdgu) ;
}
// Adds a new storage to the root storage.
if(S_OK == hr)
{
// Generate random name for storage
hr = GenerateRandomName(pdgu,MINLENGTH,MAXLENGTH,&pRootNewChildStgName);
DH_HRCHECK(hr, TEXT("GenerateRandomName")) ;
}
if(S_OK == hr)
{
hr = AddStorage(
pTestVirtualDF,
pVirtualDFRoot,
pRootNewChildStgName,
dwStgMode,
&pvcnRootNewChildStg);
DH_HRCHECK(hr, TEXT("AddStorage")) ;
if(S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualStmNode::AddStorage completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualStmNode::AddStorage not successful, hr=0x%lx."),
hr));
}
}
// Commit root.
if(S_OK == hr)
{
hr = pVirtualDFRoot->Commit(STGC_DEFAULT);
if (S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Commit completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Commit unsuccessful, hr=0x%lx."),
hr));
}
}
// Release child storage
if (S_OK == hr)
{
hr = pvcnRootNewChildStg->Close();
if (S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Close completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Close unsuccessful, hr=0x%lx.")));
}
}
// Destroy child storage
if (S_OK == hr)
{
hr = DestroyStorage(pTestVirtualDF, pvcnRootNewChildStg);
if (S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("DestroyStorage completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("DestroyStorage unsuccessful, hr=0x%lx.")));
}
}
// Commit root.
if(S_OK == hr)
{
hr = pVirtualDFRoot->Commit(STGC_DEFAULT);
if (S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Commit completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Commit unsuccessful, hr=0x%lx."),
hr));
}
}
// Add a child storage to root with same name
if(S_OK == hr)
{
hr = AddStorage(
pTestVirtualDF,
pVirtualDFRoot,
pRootNewChildStgName,
dwStgMode,
&pvcnRootNewChildStg);
DH_HRCHECK(hr, TEXT("AddStorage")) ;
if(S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualStmNode::AddStorage completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualStmNode::AddStorage not successful, hr=0x%lx."),
hr));
}
}
// Release root w/o commiting
if (S_OK == hr)
{
hr = pVirtualDFRoot->Close();
if (S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Close completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Close unsuccessful, hr=0x%lx."),
hr));
}
}
// Release child storage
if (S_OK == hr)
{
hr = pvcnRootNewChildStg->Close();
if (S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Close completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Close unsuccessful, hr=0x%lx.")));
}
}
// Open root
if (S_OK == hr)
{
hr = pVirtualDFRoot->OpenRoot(
NULL,
dwRootMode,
NULL,
0);
DH_HRCHECK(hr, TEXT("VirtualCtrNode::Open")) ;
if (S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Open completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Open unsuccessful, hr=0x%lx."),
hr));
}
}
// Open child storage that was deleted first time, and second time when
// created wasn't committed.
if (S_OK == hr)
{
hr = pvcnRootNewChildStg->Open(
NULL,
dwStgMode,
NULL,
0);
if (STG_E_FILENOTFOUND == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Open unsuccessful as exp,hr=0x%lx."),
hr));
}
else
{
HRESULT hr2;
DH_TRACE((
DH_LVL_TRACE1,
TEXT("Open should fail with STG_E_FILENOTFOUND, hr=0x%lx."),
hr));
fPass = FALSE;
// close it coz we found & opened it
if (S_OK == hr)
{
hr2 = pvcnRootNewChildStg->Close();
DH_HRCHECK(hr2, TEXT("VirtualStgNode::Close")) ;
}
}
hr = S_OK;
}
// Release root
if (S_OK == hr)
{
hr = pVirtualDFRoot->Close();
if (S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Close completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Close unsuccessful, hr=0x%lx."),
hr));
}
}
// if everything goes well, log test as passed else failed.
if ((S_OK == hr) && (TRUE == fPass))
{
DH_LOG((LOG_PASS, TEXT("Test variation STGTEST_100 passed.")) );
}
else
{
DH_LOG((LOG_FAIL,
TEXT("Test variation STGTEST_100 failed, hr=0x%lx."),
hr) );
// test failed. make sure it failed.
hr = FirstError (hr, E_FAIL);
}
// Cleanup
CleanupTestDocfile (&pVirtualDFRoot,
&pTestVirtualDF,
&pTestChanceDF,
S_OK == hr);
// Delete strings
if(NULL != pRootNewChildStgName)
{
delete pRootNewChildStgName;
pRootNewChildStgName = NULL;
}
// Stop logging the test
DH_TRACE((DH_LVL_TRACE1, TEXT("Test variation STGTEST_100 finished")) );
DH_TRACE((DH_LVL_TRACE1, TEXT("--------------------------------------------")) );
return hr;
}
//----------------------------------------------------------------------------
//
// Test: STGTEST_101
//
// Synopsis: Creates a root docfile, stats, and verifies that the CLSID == NULL
// and state bits = 0. The test tries various random combinations
// of setting state bits, changing class ids, committing changes
// sometimes, reverting at others. After every event, the test
// checks to ensure that the state bits and class id are set
// correctly. It then creates a child IStorage and repeats the
// above actions.
//
// Arguments:[argc]
// [argv]
//
// Returns: HRESULT
//
// Notes: This test runs in direct, transacted, and transacted deny write
// modes
//
// History: 14-July-1996 NarindK Created.
//
// New Test Notes:
// 1. Old File: DFSET.CXX
// 2. Old name of test : MiscSetItems Test
// New Name of test : STGTEST_101
// 3. To run the test, do the following at command prompt.
// a. stgbase /seed:2 /dfdepth:0-0 /dfstg:0-0 /dfstm:0-0 /t:STGTEST-101
// /dfRootMode:dirReadWriteShEx
// b. stgbase /seed:2 /dfdepth:0-0 /dfstg:0-0 /dfstm:0-0 /t:STGTEST-101
// /dfRootMode:xactReadWriteShEx
// c. stgbase /seed:2 /dfdepth:1-3 /dfstg:0-0 /dfstm:0-0 /t:STGTEST-101
// /dfRootMode:xactReadWriteShDenyW
// 4. To run for conversion, add /dfStgType:conversion to each of the above
// 5. To run for nssfile, add /dfStgType:nssfile to each of the above
//
// BUGNOTE: Conversion: STGTEST-101
//
//-----------------------------------------------------------------------------
HRESULT STGTEST_101(int argc, char *argv[])
{
HRESULT hr = S_OK;
ChanceDF *pTestChanceDF = NULL;
VirtualDF *pTestVirtualDF = NULL;
VirtualCtrNode *pVirtualDFRoot = NULL;
VirtualCtrNode *pvcnRootNewChildStg = NULL;
DG_STRING *pdgu = NULL;
DG_INTEGER *pdgi = NULL;
USHORT usErr = 0;
LPTSTR pRootNewChildStgName = NULL;
DWORD dwRootMode = 0;
DWORD dwStgMode = 0;
BOOL fPass = TRUE;
STATSTG statStg;
DH_FUNCENTRY(NULL, DH_LVL_DFLIB, _TEXT("STGTEST_101"));
DH_TRACE((DH_LVL_TRACE1, TEXT("--------------------------------------------")) );
DH_TRACE((DH_LVL_TRACE1, TEXT("Test variation STGTEST_101 started.")) );
DH_TRACE((DH_LVL_TRACE1, TEXT("Attempt Misc setting state bits/class id'")) );
// Create our ChanceDF and VirtualDF
hr = CreateTestDocfile (argc,
argv,
&pVirtualDFRoot,
&pTestVirtualDF,
&pTestChanceDF);
// if creating the docfile - bail here
if (NULL != pTestChanceDF && DoingCreate ())
{
UINT ulSeed = pTestChanceDF->GetSeed ();
CleanupTestDocfile (&pVirtualDFRoot,
&pTestVirtualDF,
&pTestChanceDF,
FALSE);
return (HRESULT)ulSeed;
}
if (S_OK == hr)
{
dwRootMode = pTestChanceDF->GetRootMode();
dwStgMode = pTestChanceDF->GetStgMode();
DH_TRACE((
DH_LVL_TRACE1,
TEXT("Run Mode for STGTEST_101, Access mode: %lx"),
dwRootMode));
}
// Get DG_INTEGER object pointer
if (S_OK == hr)
{
pdgi = pTestVirtualDF->GetDataGenInteger();
DH_ASSERT(NULL != pdgi) ;
}
// Get DG_STRING object pointer
if (S_OK == hr)
{
pdgu = pTestVirtualDF->GetDataGenUnicode();
DH_ASSERT(NULL != pdgu) ;
}
// Call Stat on root.
if (S_OK == hr)
{
statStg.grfStateBits = 0;
hr = pVirtualDFRoot->Stat(&statStg, STATFLAG_NONAME);
DH_HRCHECK(hr, TEXT("VirtualCtrNode::Stat")) ;
if (S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Stat completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Stat unsuccessful, hr=0x%lx."),
hr));
}
// Check CLSID from STATSTG structure
if((S_OK == hr) && (IsEqualCLSID(statStg.clsid, CLSID_NULL)))
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("Root DocFile has CLSID_NULL as expected.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("Root DocFile doesn't have CLSID_NULL unexpectedly.")));
fPass = FALSE;
}
// Check state bits from STATSTG structure.
if((S_OK == hr) && (0 == statStg.grfStateBits))
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("Root DocFile has grfStateBits equal to 0 as expected.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("Root DocFile doesn't have grfStateBits = 0 unexpectedly.")));
fPass = FALSE;
}
}
// Commit root.
if(S_OK == hr)
{
hr = pVirtualDFRoot->Commit(STGC_DEFAULT);
if (S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Commit completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Commit unsuccessful, hr=0x%lx."),
hr));
}
}
// Call SetItemsInStorage on Root
if (S_OK == hr)
{
hr = SetItemsInStorage(pVirtualDFRoot, pdgi);
DH_HRCHECK(hr, TEXT("SetItemsInStorage")) ;
}
// Adds a new storage to the root storage.
if(S_OK == hr)
{
// Generate random name for storage
hr = GenerateRandomName(pdgu,MINLENGTH,MAXLENGTH,&pRootNewChildStgName);
DH_HRCHECK(hr, TEXT("GenerateRandomName")) ;
}
if(S_OK == hr)
{
hr = AddStorage(
pTestVirtualDF,
pVirtualDFRoot,
pRootNewChildStgName,
dwStgMode,
&pvcnRootNewChildStg);
DH_HRCHECK(hr, TEXT("AddStorage")) ;
if(S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualStmNode::AddStorage completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualStmNode::AddStorage not successful, hr=0x%lx."),
hr));
}
}
// Call Stat on new child storage.
if (S_OK == hr)
{
statStg.grfStateBits = 0;
hr = pvcnRootNewChildStg->Stat(&statStg, STATFLAG_NONAME);
DH_HRCHECK(hr, TEXT("VirtualCtrNode::Stat")) ;
if (S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Stat completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Stat unsuccessful, hr=0x%lx."),
hr));
}
// Check CLSID from STATSTG structure
if((S_OK == hr) && (IsEqualCLSID(statStg.clsid, CLSID_NULL)))
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("Child Storage has CLSID_NULL as expected.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("Child storage doesn't have CLSID_NULL unexpectedly.")));
fPass = FALSE;
}
// Check state bits from STATSTG structure.
if((S_OK == hr) && (0 == statStg.grfStateBits))
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("Child Storage has grfStateBits equal to 0 as expected.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("Child Storage doesn't have grfStateBits=0 unexpectedly.")));
fPass = FALSE;
}
}
// Commit root.
if(S_OK == hr)
{
hr = pVirtualDFRoot->Commit(STGC_DEFAULT);
if (S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Commit completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Commit unsuccessful, hr=0x%lx."),
hr));
}
}
// Call SetItemsInStorage on Child storage
if (S_OK == hr)
{
hr = SetItemsInStorage(pvcnRootNewChildStg, pdgi);
DH_HRCHECK(hr, TEXT("SetItemsInStorage")) ;
}
// Release child storage.
if (S_OK == hr)
{
hr = pvcnRootNewChildStg->Close();
if (S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Close completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Close unsuccessful, hr=0x%lx."),
hr));
}
}
// Release root.
if (S_OK == hr)
{
hr = pVirtualDFRoot->Close();
if (S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Close completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Close unsuccessful, hr=0x%lx."),
hr));
}
}
// if everything goes well, log test as passed else failed.
if ((S_OK == hr) && (TRUE == fPass))
{
DH_LOG((LOG_PASS, TEXT("Test variation STGTEST_101 passed.")) );
}
else
{
DH_LOG((LOG_FAIL,
TEXT("Test variation STGTEST_101 failed, hr=0x%lx."),
hr) );
// test failed. make sure it failed.
hr = FirstError (hr, E_FAIL);
}
// Cleanup
CleanupTestDocfile (&pVirtualDFRoot,
&pTestVirtualDF,
&pTestChanceDF,
S_OK == hr);
// Delete temp strings
if(NULL != pRootNewChildStgName)
{
delete pRootNewChildStgName;
pRootNewChildStgName = NULL;
}
// Stop logging the test
DH_TRACE((DH_LVL_TRACE1, TEXT("Test variation STGTEST_101 finished")) );
DH_TRACE((DH_LVL_TRACE1, TEXT("--------------------------------------------")) );
return hr;
}
//----------------------------------------------------------------------------
//
// Test: STGTEST_102
//
// Synopsis: The test attempts various illegitimate operations regarding the
// renaming and deletion of contained IStorages.
//
// Arguments:[argc]
// [argv]
//
// Returns: HRESULT
//
// Notes: This test runs in direct, transacted, and transacted deny write
// modes
//
// History: 10-July-1996 NarindK Created.
//
// New Test Notes:
// 1. Old File: IRENDEST.CXX
// 2. Old name of test : IllegitRenDest Test
// New Name of test : STGTEST_102
// 3. To run the test, do the following at command prompt.
// a. stgbase /seed:2 /dfdepth:0-0 /dfstg:0-0 /dfstm:0-0 /t:STGTEST-102
// /dfRootMode:dirReadWriteShEx /dfStgMode:dirReadWriteShEx /labmode
// b. stgbase /seed:2 /dfdepth:0-0 /dfstg:0-0 /dfstm:0-0 /t:STGTEST-102
// /dfRootMode:xactReadWriteShEx /dfStgMode:xactReadWriteShEx /labmode
// c. stgbase /seed:2 /dfdepth:0-0 /dfstg:0-0 /dfstm:0-0 /t:STGTEST-102
// /dfRootMode:xactReadWriteShDenyW /dfStgMode:xactReadWriteShEx
// /labmode
// 4. To run for conversion, add /dfStgType:conversion to each of the above
// 5. To run for nssfile, add /dfStgType:nssfile to each of the above
//
// BUGNOTE: Conversion: STGTEST-102
//
//-----------------------------------------------------------------------------
HRESULT STGTEST_102(int argc, char *argv[])
{
HRESULT hr = S_OK;
ChanceDF *pTestChanceDF = NULL;
VirtualDF *pTestVirtualDF = NULL;
VirtualCtrNode *pVirtualDFRoot = NULL;
DG_STRING *pdgu = NULL;
USHORT usErr = 0;
VirtualCtrNode *pvcnRootNewChildStg = NULL;
VirtualCtrNode *pvcnRootNewChildStg0 = NULL;
VirtualCtrNode *pvcnRootNewChildStg1 = NULL;
LPTSTR pRootNewChildStgName = NULL;
LPTSTR ptszNonExist = TEXT("NonExistStg");
LPTSTR ptszNonExistNew = TEXT("NonExistStgNew");
LPOLESTR poszNonExist = NULL;
LPOLESTR poszNonExistNew = NULL;
DWORD dwRootMode = 0;
DWORD dwStgMode = 0;
BOOL fPass = TRUE;
ULONG i = 0;
LPSTORAGE pStgRoot = NULL;
DH_FUNCENTRY(NULL, DH_LVL_DFLIB, _TEXT("STGTEST_102"));
DH_TRACE((DH_LVL_TRACE1, TEXT("--------------------------------------------")) );
DH_TRACE((DH_LVL_TRACE1, TEXT("Test variation STGTEST_102 started.")) );
DH_TRACE((DH_LVL_TRACE1, TEXT("Attempt illegitimate storage rename/del ops")) );
// Create our ChanceDF and VirtualDF
hr = CreateTestDocfile (argc,
argv,
&pVirtualDFRoot,
&pTestVirtualDF,
&pTestChanceDF);
// if creating the docfile - bail here
if (NULL != pTestChanceDF && DoingCreate ())
{
UINT ulSeed = pTestChanceDF->GetSeed ();
CleanupTestDocfile (&pVirtualDFRoot,
&pTestVirtualDF,
&pTestChanceDF,
FALSE);
return (HRESULT)ulSeed;
}
if (S_OK == hr)
{
dwRootMode = pTestChanceDF->GetRootMode();
dwStgMode = pTestChanceDF->GetStgMode();
DH_TRACE((
DH_LVL_TRACE1,
TEXT("Run Mode for STGTEST_102, Access mode: %lx"),
dwRootMode));
}
// Get DG_STRING object pointer
if (S_OK == hr)
{
pdgu = pTestVirtualDF->GetDataGenUnicode();
DH_ASSERT(NULL != pdgu) ;
}
// create two new IStorages and save their names.
for (i=0;i<2;i++)
{
// Adds a new storage to the root storage.
if(S_OK == hr)
{
// Generate random name for storage
hr = GenerateRandomName(
pdgu,
MINLENGTH,
MAXLENGTH,
&pRootNewChildStgName);
DH_HRCHECK(hr, TEXT("GenerateRandomName")) ;
}
if(S_OK == hr)
{
hr = AddStorage(
pTestVirtualDF,
pVirtualDFRoot,
pRootNewChildStgName,
dwStgMode,
&pvcnRootNewChildStg);
DH_HRCHECK(hr, TEXT("AddStorage")) ;
if(S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualStmNode::AddStorage completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualStmNode::AddStorage not successful, hr=0x%lx."),
hr));
}
}
// Commit root.
if(S_OK == hr)
{
hr = pVirtualDFRoot->Commit(STGC_DEFAULT);
if (S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Commit completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Commit unsuccessful, hr=0x%lx."),
hr));
}
}
// Release child storage
if (S_OK == hr)
{
hr = pvcnRootNewChildStg->Close();
if (S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Close completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Close unsuccessful, hr=0x%lx.")));
}
}
if(S_OK == hr)
{
if(i == 0)
{
pvcnRootNewChildStg0 = pvcnRootNewChildStg;
}
else
{
pvcnRootNewChildStg1 = pvcnRootNewChildStg;
}
}
// Delete temp strings
if(NULL != pRootNewChildStgName)
{
delete pRootNewChildStgName;
pRootNewChildStgName = NULL;
}
// Break out of loop under failure conditions
if(S_OK != hr)
{
break;
}
}
// verify that the IStorages have been created by attempting to
// instantiate them
// Break out of loop under failure conditions
for (i=0; i<2 && S_OK == hr; i++)
{
if(i == 0)
{
pvcnRootNewChildStg = pvcnRootNewChildStg0;
}
else
{
pvcnRootNewChildStg = pvcnRootNewChildStg1;
}
hr = pvcnRootNewChildStg->Open(
NULL,
dwStgMode | STGM_FAILIFTHERE,
NULL,
0);
if (S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Open completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Open unsuccessful, hr=0x%lx."),
hr));
}
// Release child storage
if (S_OK == hr)
{
hr = pvcnRootNewChildStg->Close();
if (S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Close completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Close unsuccessful, hr=0x%lx.")));
}
}
}
// Attempt to rename the storage to a name that already exists.
if(S_OK == hr)
{
hr = pvcnRootNewChildStg0->Rename(
pvcnRootNewChildStg1->GetVirtualCtrNodeName());
if(STG_E_ACCESSDENIED == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Rename failed as exp, hr = 0x%lx."),
hr));
hr = S_OK;
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Rename didn't fail as exp, hr = 0x%lx."),
hr));
fPass = FALSE;
}
}
// Attempt to rename an element that doesn't exist.
// Covert the names to OLECHAR
if(S_OK == hr)
{
// Convert test name to OLECHAR
hr = TStringToOleString(ptszNonExist, &poszNonExist);
DH_HRCHECK(hr, TEXT("TStringToOleString")) ;
}
if(S_OK == hr)
{
// Convert test name to OLECHAR
hr = TStringToOleString(ptszNonExistNew, &poszNonExistNew);
DH_HRCHECK(hr, TEXT("TStringToOleString")) ;
}
// First get IStorage pointer for root
if(S_OK == hr)
{
pStgRoot = pVirtualDFRoot->GetIStoragePointer();
DH_ASSERT(NULL != pStgRoot);
hr = pStgRoot->RenameElement(
poszNonExist,
poszNonExistNew);
if(STG_E_FILENOTFOUND == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("IStorage::Rename failed as exp, hr = 0x%lx."),
hr));
hr = S_OK;
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("IStorage::Rename didn't fail as exp, hr = 0x%lx."),
hr));
fPass = FALSE;
}
}
// Attempt to delete an element that doesn't exist.
if(S_OK == hr)
{
hr = pStgRoot->DestroyElement(poszNonExist);
if(STG_E_FILENOTFOUND == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("IStorage::Destroy failed as exp, hr = 0x%lx."),
hr));
hr = S_OK;
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("IStorage::Destroy didn't fail as exp, hr = 0x%lx."),
hr));
fPass = FALSE;
}
}
// Release root
if (S_OK == hr)
{
hr = pVirtualDFRoot->Close();
if (S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Close completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Close unsuccessful, hr=0x%lx."),
hr));
}
}
// if everything goes well, log test as passed else failed.
if ((S_OK == hr) && (TRUE == fPass))
{
DH_LOG((LOG_PASS, TEXT("Test variation STGTEST_102 passed.")) );
}
else
{
DH_LOG((LOG_FAIL,
TEXT("Test variation STGTEST_102 failed, hr=0x%lx."),
hr) );
// test failed. make sure it failed.
hr = FirstError (hr, E_FAIL);
}
// Cleanup
CleanupTestDocfile (&pVirtualDFRoot,
&pTestVirtualDF,
&pTestChanceDF,
S_OK == hr);
// Delete strings
if(NULL != poszNonExist)
{
delete poszNonExist;
poszNonExist = NULL;
}
if(NULL != poszNonExistNew)
{
delete poszNonExistNew;
poszNonExistNew = NULL;
}
// Stop logging the test
DH_TRACE((DH_LVL_TRACE1, TEXT("Test variation STGTEST_102 finished")) );
DH_TRACE((DH_LVL_TRACE1, TEXT("--------------------------------------------")) );
return hr;
}
//----------------------------------------------------------------------------
//
// Test: STGTEST_103
//
// Synopsis: A random docfile with some storages and some streams is generated.
// The root docfile is commited and closed.
// The root docfile is then instantiated & an enumerator is obtained. For
// each object found, the object is renamed to a new name but the old
// name is saved. An attempt is made to instantiate the object with
// the old name, this attempt should fail. The renamed object is then
// instantiated with the new name to verify that the rename worked. The
// object is then destroyed. This occurs for every object returned by
// the enumerator. The root docfile is then committed, the enumerator
// is released, and a new enumerator is obtained. The root docfile
// is enumerated to verify that no elements exist.
//
// Arguments:[argc]
// [argv]
//
// Returns: HRESULT
//
// Notes: This test runs in direct, transacted, and transacted deny write
// modes
//
// History: 11-July-1996 NarindK Created.
//
// New Test Notes:
// 1. Old File: LDRENDES.CXX
// 2. Old name of test : LegitRenDestNormal Test
// New Name of test : STGTEST_103
// 3. To run the test, do the following at command prompt.
// a. stgbase /seed:2 /dfdepth:1-1 /dfstg:1-3 /dfstm:2-3 /t:STGTEST-103
// /dfRootMode:dirReadWriteShEx /dfStgMode:dirReadWriteShEx
// b. stgbase /seed:2 /dfdepth:1-1 /dfstg:1-3 /dfstm:2-3 /t:STGTEST-103
// /dfRootMode:xactReadWriteShEx /dfStgMode:xactReadWriteShEx
// c. stgbase /seed:2 /dfdepth:1-1 /dfstg:1-3 /dfstm:2-3 /t:STGTEST-103
// /dfRootMode:xactReadWriteShDenyW /dfStgMode:xactReadWriteShEx
// 4. To run for conversion, add /dfStgType:conversion to each of the above
// 5. To run for nssfile, add /dfStgType:nssfile to each of the above
//
// BUGNOTE: Conversion: STGTEST-103
//
//-----------------------------------------------------------------------------
HRESULT STGTEST_103(int argc, char *argv[])
{
HRESULT hr = S_OK;
ChanceDF *pTestChanceDF = NULL;
VirtualDF *pTestVirtualDF = NULL;
VirtualCtrNode *pVirtualDFRoot = NULL;
DG_STRING *pdgu = NULL;
USHORT usErr = 0;
DWORD dwRootMode = 0;
DWORD dwStgMode = 0;
LPENUMSTATSTG penumWalk = NULL;
LPMALLOC pMalloc = NULL;
LPSTORAGE pStgRoot = NULL;
LPSTORAGE pStgChild = NULL;
LPSTREAM pStmChild = NULL;
ULONG ulRef = 0;
BOOL fPass = TRUE;
BOOL fRenamedOK = TRUE;
LPTSTR ptszNewName = NULL;
LPOLESTR poszNewName = NULL;
LPTSTR ptszOldName = NULL;
LPOLESTR poszOldName = NULL;
STATSTG statStg;
DH_FUNCENTRY(NULL, DH_LVL_DFLIB, _TEXT("STGTEST_103"));
DH_TRACE((DH_LVL_TRACE1, TEXT("--------------------------------------------")) );
DH_TRACE((DH_LVL_TRACE1, TEXT("Test variation STGTEST_103 started.")) );
DH_TRACE((DH_LVL_TRACE1, TEXT("Attempt legit rename/deleted ops on stgs/stms")));
// Create our ChanceDF and VirtualDF
hr = CreateTestDocfile (argc,
argv,
&pVirtualDFRoot,
&pTestVirtualDF,
&pTestChanceDF);
// if creating the docfile - bail here
if (NULL != pTestChanceDF && DoingCreate ())
{
UINT ulSeed = pTestChanceDF->GetSeed ();
CleanupTestDocfile (&pVirtualDFRoot,
&pTestVirtualDF,
&pTestChanceDF,
FALSE);
return (HRESULT)ulSeed;
}
if (S_OK == hr)
{
dwRootMode = pTestChanceDF->GetRootMode();
dwStgMode = pTestChanceDF->GetStgMode();
DH_TRACE((
DH_LVL_TRACE1,
TEXT("Run Mode for STGTEST_103, Access mode: %lx"),
dwRootMode));
}
// Commit substorages BUGBUG df already commited
if (S_OK == hr)
{
hr = ParseVirtualDFAndCommitAllOpenStgs(
pVirtualDFRoot,
STGC_DEFAULT,
NODE_EXC_TOPSTG);
DH_HRCHECK(hr, TEXT("ParseVirtualDFAndCloseOpenStgsStms"));
}
// Commit root.
if(S_OK == hr)
{
hr = pVirtualDFRoot->Commit(STGC_DEFAULT);
if (S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Commit completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Commit unsuccessful, hr=0x%lx."),
hr));
}
}
// Release root and all substorages/streams too
if (S_OK == hr)
{
hr = ParseVirtualDFAndCloseOpenStgsStms(
pVirtualDFRoot,
NODE_EXC_TOPSTG);
DH_HRCHECK(hr, TEXT("ParseVirtualDFAndCloseOpenStgsStms"));
}
// Release root
if(S_OK == hr)
{
hr = pVirtualDFRoot->Close();
if (S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Close completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Close unsuccessful, hr=0x%lx."),
hr));
}
}
// Reopen the root.
if (S_OK == hr)
{
hr = pVirtualDFRoot->OpenRoot(
NULL,
dwRootMode,
NULL,
0);
DH_HRCHECK(hr, TEXT("VirtualCtrNode::Open")) ;
if (S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Open completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Open unsuccessful, hr=0x%lx."),
hr));
}
}
// Call EnumElements to get a enumerator
if(S_OK == hr)
{
hr = pVirtualDFRoot->EnumElements(0, NULL, 0, &penumWalk);
DH_HRCHECK(hr, TEXT("VirtualCtrNode::EnumElements")) ;
if(S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::EnumElements passed as expected")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::EnumElements unexpectedly failed hr=0x%lx"),
hr));
}
}
// First get pMalloc that would be used to free up the name string from
// STATSTG.
if ( S_OK == hr )
{
hr = CoGetMalloc(MEMCTX_TASK, &pMalloc);
DH_HRCHECK(hr, TEXT("CoGetMalloc")) ;
}
if(S_OK == hr)
{
pStgRoot = pVirtualDFRoot->GetIStoragePointer();
DH_ASSERT(NULL != pStgRoot);
// Get DG_STRING object pointer
if (S_OK == hr)
{
pdgu = pTestVirtualDF->GetDataGenUnicode();
DH_ASSERT(NULL != pdgu) ;
}
}
while(S_OK == hr && S_OK == penumWalk->Next(1, &statStg, NULL))
{
// loop to rename object until a unique name is found, typically
// this will happen the first time and we'll fall out of the loop,
// but in the event of a duplicate name we have to keep trying.
fRenamedOK = FALSE;
while ((fRenamedOK == FALSE) && (S_OK == hr))
{
if(S_OK == hr)
{
// Generate random name for the element
hr = GenerateRandomName(
pdgu,
MINLENGTH,
MAXLENGTH,
&ptszNewName);
DH_HRCHECK(hr, TEXT("GenerateRandomName")) ;
}
if(S_OK == hr)
{
// Convert above name to OLECHAR
hr = TStringToOleString(ptszNewName, &poszNewName);
DH_HRCHECK(hr, TEXT("TStringToOleString")) ;
}
// Convert old name as retrieved from STATSTG structure to OLECHAR
// by first converting it to TSTR and then to OLECHAR.
if(S_OK == hr)
{
// Convert old name statStg.pwcsName to TCHAR
hr = OleStringToTString(statStg.pwcsName, &ptszOldName);
DH_HRCHECK(hr, TEXT("OleStringToTString")) ;
}
if(S_OK == hr)
{
// Now Convert old name to OLECHAR
hr = TStringToOleString(ptszOldName, &poszOldName);
DH_HRCHECK(hr, TEXT("TStringToOleString")) ;
}
if(S_OK == hr)
{
// Rename the element to new name
hr = pStgRoot->RenameElement(
poszOldName,
poszNewName);
}
if(S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("IStorage::RenameElement successful as exp.")));
fRenamedOK = TRUE;
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("IStorage::RenameElement failed unexp, hr = 0x%lx."),
hr));
break;
}
} // ((fRenamedOK == FALSE) && (S_OK == hr))
// verify that the rename worked by first trying to instantiate
// the object with the original name (this should fail) and
// then instantiate it with the new name.
if((S_OK == hr) && (statStg.type == STGTY_STORAGE))
{
hr = pStgRoot->OpenStorage(
poszOldName,
NULL,
dwStgMode,
NULL,
0,
&pStgChild);
if((NULL == pStgChild) && (STG_E_FILENOTFOUND == hr))
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("Instantiation with old name fail exp, hr = 0x%lx "),
hr));
hr = S_OK;
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("Instantiation with old name pass unexp, hr = 0x%lx"),
hr));
hr = S_FALSE;
}
if(S_OK == hr)
{
hr = pStgRoot->OpenStorage(
poszNewName,
NULL,
dwStgMode,
NULL,
0,
&pStgChild);
DH_HRCHECK(hr, TEXT("IStorage::OpenStorage")) ;
if(S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("Instantiation with new name pass as exp")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("Instantiation with new name fail unexp, hr=0x%lx"),
hr));
}
}
// Release the element
if(NULL != pStgChild)
{
ulRef = pStgChild->Release();
DH_ASSERT(0 == ulRef);
pStgChild = NULL;
}
} // ((S_OK == hr) && (statStg.type == STGTY_STORAGE))
if ((S_OK == hr) && (statStg.type == STGTY_STREAM))
{
//element is a stream
hr = pStgRoot->OpenStream(
poszOldName,
NULL,
STGM_READ | STGM_SHARE_EXCLUSIVE,
0,
&pStmChild);
if((NULL == pStmChild) && (STG_E_FILENOTFOUND == hr))
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("Instantiation with old name fail exp, hr = 0x%lx "),
hr));
hr = S_OK;
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("Instantiation with old name pass unexp,hr = 0x%lx "),
hr));
hr = S_FALSE;
}
if(S_OK == hr)
{
hr = pStgRoot->OpenStream(
poszNewName,
NULL,
STGM_READ | STGM_SHARE_EXCLUSIVE,
0,
&pStmChild);
DH_HRCHECK(hr, TEXT("IStorage::OpenStream")) ;
if(S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("Instantiation with new name pass as exp")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("Instantiation with new name fail unexp, hr=0x%lx"),
hr));
}
}
// Release the element
if(NULL != pStmChild)
{
ulRef = pStmChild->Release();
DH_ASSERT(0 == ulRef);
pStmChild = NULL;
}
} // if ((S_OK == hr) && (statStg.type == STGTY_STREAM))
// Destroy the element
if(S_OK == hr)
{
hr = pStgRoot->DestroyElement(poszNewName);
DH_HRCHECK(hr, TEXT("IStorage::DestroyElement")) ;
if(S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("IStorage::DestoryElement succeeded as expected.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("IStorage::DestoryElement fail unexp, hr = 0x%lx."),
hr));
}
}
// Release resources
if ( NULL != statStg.pwcsName)
{
pMalloc->Free(statStg.pwcsName);
statStg.pwcsName = NULL;
}
if(NULL != ptszNewName)
{
delete ptszNewName;
ptszNewName = NULL;
}
if(NULL != poszNewName)
{
delete poszNewName;
poszNewName = NULL;
}
if(NULL != ptszOldName)
{
delete ptszOldName;
ptszOldName = NULL;
}
if(NULL != poszOldName)
{
delete poszOldName;
poszOldName = NULL;
}
}
// Commit root.
if(S_OK == hr)
{
hr = pVirtualDFRoot->Commit(STGC_DEFAULT);
if (S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Commit completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Commit unsuccessful, hr=0x%lx."),
hr));
}
}
// Release penumWalk
if(NULL != penumWalk)
{
ulRef = penumWalk->Release();
DH_ASSERT(0 == ulRef);
penumWalk = NULL;
}
// Call EnumElements to get a enumerator again
if(S_OK == hr)
{
hr = pVirtualDFRoot->EnumElements(0, NULL, 0, &penumWalk);
DH_HRCHECK(hr, TEXT("VirtualCtrNode::EnumElements")) ;
if(S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::EnumElements passed as expected")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::EnumElements unexpectedly failed hr=0x%lx"),
hr));
}
}
// Try to call next on it. All elements should have been deleted
while(S_OK == hr && S_OK == penumWalk->Next(1, &statStg, NULL))
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("All elements should have been deleted.")));
fPass = FALSE;
}
// Release root
if(S_OK == hr)
{
hr = pVirtualDFRoot->Close();
if (S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Close completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Close unsuccessful, hr=0x%lx."),
hr));
}
}
// Release pMalloc
if(NULL != pMalloc)
{
pMalloc->Release();
pMalloc = NULL;
}
// Release penumWalk
if(NULL != penumWalk)
{
ulRef = penumWalk->Release();
DH_ASSERT(0 == ulRef);
penumWalk = NULL;
}
// if everything goes well, log test as passed else failed.
if ((S_OK == hr) && (TRUE == fPass))
{
DH_LOG((LOG_PASS, TEXT("Test variation STGTEST_103 passed.")) );
}
else
{
DH_LOG((LOG_FAIL,
TEXT("Test variation STGTEST_103 failed, hr=0x%lx."),
hr) );
// test failed. make sure it failed.
hr = FirstError (hr, E_FAIL);
}
// Cleanup
CleanupTestDocfile (&pVirtualDFRoot,
&pTestVirtualDF,
&pTestChanceDF,
S_OK == hr);
// Stop logging the test
DH_TRACE((DH_LVL_TRACE1, TEXT("Test variation STGTEST_103 finished")) );
DH_TRACE((DH_LVL_TRACE1, TEXT("--------------------------------------------")) );
return hr;
}
//----------------------------------------------------------------------------
//
// Test: STGTEST_104
//
// Synopsis: This test first creates a root docfile. Two child IStorages
// are created inside of it.
// Child IStorage A is renamed to name C, child IStorage B is
// renamed to name A, child IStorage C (was originally A) is
// renames to B. The root docfile is committed. Verify
// proper renaming and no errors.
//
// Arguments:[argc]
// [argv]
//
// Returns: HRESULT
//
// Notes: This test runs in direct, transacted, and transacted deny write
// modes
//
// History: 11-July-1996 NarindK Created.
//
// New Test Notes:
// 1. Old File: LDRENSWP.CXX
// 2. Old name of test : LegitRenDestSwap Test
// New Name of test : STGTEST_104
// 3. To run the test, do the following at command prompt.
// a. stgbase /seed:2 /dfdepth:0-0 /dfstg:0-0 /dfstm:0-0 /t:STGTEST-104
// /dfRootMode:dirReadWriteShEx /dfStgMode:dirReadWriteShEx
// b. stgbase /seed:2 /dfdepth:0-0 /dfstg:0-0 /dfstm:0-0 /t:STGTEST-104
// /dfRootMode:xactReadWriteShEx /dfStgMode:xactReadWriteShEx
// c. stgbase /seed:2 /dfdepth:0-0 /dfstg:0-0 /dfstm:0-0 /t:STGTEST-104
// /dfRootMode:xactReadWriteShDenyW /dfStgMode:xactReadWriteShEx
// 4. To run for conversion, add /dfStgType:conversion to each of the above
// 5. To run for nssfile, add /dfStgType:nssfile to each of the above
//
// BUGNOTE: Conversion: STGTEST-104
//
//-----------------------------------------------------------------------------
HRESULT STGTEST_104(int argc, char *argv[])
{
HRESULT hr = S_OK;
ChanceDF *pTestChanceDF = NULL;
VirtualDF *pTestVirtualDF = NULL;
VirtualCtrNode *pVirtualDFRoot = NULL;
DG_STRING *pdgu = NULL;
USHORT usErr = 0;
VirtualCtrNode *pvcnRootNewChildStg0 = NULL;
LPTSTR pRootNewChildStgName0 = NULL;
VirtualCtrNode *pvcnRootNewChildStg1 = NULL;
LPTSTR pRootNewChildStgName1 = NULL;
DWORD dwRootMode = 0;
DWORD dwStgMode = 0;
DH_FUNCENTRY(NULL, DH_LVL_DFLIB, _TEXT("STGTEST_104"));
DH_TRACE((DH_LVL_TRACE1, TEXT("--------------------------------------------")) );
DH_TRACE((DH_LVL_TRACE1, TEXT("Test variation STGTEST_104 started.")) );
DH_TRACE((DH_LVL_TRACE1, TEXT("Attempt rename swap operations on child stgs")) );
// Create our ChanceDF and VirtualDF
hr = CreateTestDocfile (argc,
argv,
&pVirtualDFRoot,
&pTestVirtualDF,
&pTestChanceDF);
// if creating the docfile - bail here
if (NULL != pTestChanceDF && DoingCreate ())
{
UINT ulSeed = pTestChanceDF->GetSeed ();
CleanupTestDocfile (&pVirtualDFRoot,
&pTestVirtualDF,
&pTestChanceDF,
FALSE);
return (HRESULT)ulSeed;
}
if (S_OK == hr)
{
dwRootMode = pTestChanceDF->GetRootMode();
dwStgMode = pTestChanceDF->GetStgMode();
DH_TRACE((
DH_LVL_TRACE1,
TEXT("Run Mode for STGTEST_104, Access mode: %lx"),
dwRootMode));
}
// Get DG_STRING object pointer
if (S_OK == hr)
{
pdgu = pTestVirtualDF->GetDataGenUnicode();
DH_ASSERT(NULL != pdgu) ;
}
// Adds first new child storage to the root storage.
if(S_OK == hr)
{
// Generate random name for first child storage
hr = GenerateRandomName(
pdgu,
MINLENGTH,
MAXLENGTH,
&pRootNewChildStgName0);
DH_HRCHECK(hr, TEXT("GenerateRandomName")) ;
}
if(S_OK == hr)
{
hr = AddStorage(
pTestVirtualDF,
pVirtualDFRoot,
pRootNewChildStgName0,
dwStgMode,
&pvcnRootNewChildStg0);
DH_HRCHECK(hr, TEXT("AddStorage")) ;
if(S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualStmNode::AddStorage completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualStmNode::AddStorage not successful, hr=0x%lx."),
hr));
}
}
// Adds second new child storage to the root storage.
if(S_OK == hr)
{
// Generate random name for first child storage
hr = GenerateRandomName(
pdgu,
MINLENGTH,
MAXLENGTH,
&pRootNewChildStgName1);
DH_HRCHECK(hr, TEXT("GenerateRandomName")) ;
}
if(S_OK == hr)
{
hr = AddStorage(
pTestVirtualDF,
pVirtualDFRoot,
pRootNewChildStgName1,
dwStgMode,
&pvcnRootNewChildStg1);
DH_HRCHECK(hr, TEXT("AddStorage")) ;
if(S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualStmNode::AddStorage completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualStmNode::AddStorage not successful, hr=0x%lx."),
hr));
}
}
// Commit root.
if(S_OK == hr)
{
hr = pVirtualDFRoot->Commit(STGC_DEFAULT);
if (S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Commit completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Commit unsuccessful, hr=0x%lx."),
hr));
}
}
// Can't rename open storages so release the child storages
// Release first child storage.
if (S_OK == hr)
{
hr = pvcnRootNewChildStg0->Close();
if (S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Close completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Close unsuccessful, hr=0x%lx.")));
}
}
// Release second child storage.
if (S_OK == hr)
{
hr = pvcnRootNewChildStg1->Close();
if (S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Close completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Close unsuccessful, hr=0x%lx.")));
}
}
// Attempt to rename the first child storage to RootDocFile's name
if(S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("pvcnRootNewChildStg0's old name, %s."),
pvcnRootNewChildStg0->GetVirtualCtrNodeName()));
hr = pvcnRootNewChildStg0->Rename(
pVirtualDFRoot->GetVirtualCtrNodeName());
if(S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Rename passed as exp, new name %s."),
pvcnRootNewChildStg0->GetVirtualCtrNodeName()));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Rename failed unexp, hr = 0x%lx."),
hr));
}
}
// Attempt to rename the second child storage to first child stg's name
if(S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("pvcnRootNewChildStg1's old name, %s."),
pvcnRootNewChildStg1->GetVirtualCtrNodeName()));
hr = pvcnRootNewChildStg1->Rename(pRootNewChildStgName0);
if(S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Rename passed as exp, new name %s."),
pvcnRootNewChildStg1->GetVirtualCtrNodeName()));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Rename failed unexp, hr = 0x%lx."),
hr));
}
}
// Attempt to rename third child storage (was originally first child
// storage) to second child stg's name
if(S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("pvcnRootNewChildStg0's old name, %s."),
pvcnRootNewChildStg0->GetVirtualCtrNodeName()));
hr = pvcnRootNewChildStg0->Rename(pRootNewChildStgName1);
if(S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Rename passed as exp, new name %s."),
pvcnRootNewChildStg0->GetVirtualCtrNodeName()));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Rename failed unexp, hr = 0x%lx."),
hr));
}
}
// Release root
if (S_OK == hr)
{
hr = pVirtualDFRoot->Close();
if (S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Close completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Close unsuccessful, hr=0x%lx."),
hr));
}
}
// if everything goes well, log test as passed else failed.
if (S_OK == hr)
{
DH_LOG((LOG_PASS, TEXT("Test variation STGTEST_104 passed.")) );
}
else
{
DH_LOG((LOG_FAIL,
TEXT("Test variation STGTEST_104 failed, hr=0x%lx."),
hr) );
}
// Cleanup
CleanupTestDocfile (&pVirtualDFRoot,
&pTestVirtualDF,
&pTestChanceDF,
S_OK == hr);
// Delete strings
if(NULL != pRootNewChildStgName0)
{
delete pRootNewChildStgName0;
pRootNewChildStgName0 = NULL;
}
if(NULL != pRootNewChildStgName1)
{
delete pRootNewChildStgName1;
pRootNewChildStgName1 = NULL;
}
// Stop logging the test
DH_TRACE((DH_LVL_TRACE1, TEXT("Test variation STGTEST_104 finished")) );
DH_TRACE((DH_LVL_TRACE1, TEXT("--------------------------------------------")) );
return hr;
}
//----------------------------------------------------------------------------
//
// Test: STGTEST_105
//
// Synopsis: A random docfile with random number of storages and streams is
// generated. Root is committed and closed.
// The root docfile is instantiated and the CRC is computed for the
// entire docfile. A new root docfile with a random name is then
// created and a CRC is generated for the empty root docfile. An
// enumerator is obtained on the source docfile, each element returned
// is MoveElementTo()'d the destination docfile. If fRevertAfterMove
// equals TRUE, the dest is reverted, else the dest is committed.
// The dest is released and reinstantiated and CRC'd. If the dest
// was reverted, the CRC is compared against the empty CRC for a match.
// Otherwise, we compare against the original root docfile CRC. The
// original file is CRC'd again to verify that STGMOVE_COPY didn't
// move the elements from orginal position but copied them, the CRC
// now computed should match with the one calculated originally.
//
// This tests differs from STGTEST-107 in the way that MoveElementTo
// is called with STGMOVE_COPY flag instead of STGMOVE_MOVE.
//
// Arguments:[argc]
// [argv]
//
// Returns: HRESULT
//
// Notes: This test runs in direct, transacted, and transacted deny write
// modes
//
// History: 12-July-1996 NarindK Created.
//
// New Test Notes:
// 1. Old File: LVROOT.CXX
// 2. Old name of test : LegitMoveDFToRootDF Test
// New Name of test : STGTEST_105
// 3. To run the test, do the following at command prompt.
// a. stgbase /seed:2 /dfdepth:1-3 /dfstg:1-3 /dfstm:2-3 /t:STGTEST-105
// /dfRootMode:dirReadWriteShEx
// b. stgbase /seed:2 /dfdepth:1-3 /dfstg:1-3 /dfstm:2-3 /t:STGTEST-105
// /dfRootMode:xactReadWriteShEx
// c. stgbase /seed:2 /dfdepth:1-3 /dfstg:1-3 /dfstm:2-3 /t:STGTEST-105
// /dfRootMode:xactReadWriteShDenyW
// d. stgbase /seed:2 /dfdepth:1-3 /dfstg:1-3 /dfstm:2-3 /t:STGTEST-105
// /dfRootMode:xactReadWriteShEx /frevertaftermove
// e. stgbase /seed:2 /dfdepth:1-3 /dfstg:1-3 /dfstm:2-3 /t:STGTEST-105
// /dfRootMode:xactReadWriteShDenyW /frevertaftermove
// 4. To run for conversion, add /dfStgType:conversion to each of the above
// 5. To run for nssfile, add /dfStgType:nssfile to each of the above
// BUGBUG: dont have /stdblock up yet. -scousens
// BUGBUG: note this fails sometimes for nssfiles need to dig deeper -scousens working seed=21590084
//
// In case of direct mode, the flag revertaftermove is not meaningful since
// changes are always directly written to disk doc file.
//
// BUGNOTE: Conversion: STGTEST-105
//
//-----------------------------------------------------------------------------
HRESULT STGTEST_105(int argc, char *argv[])
{
HRESULT hr = S_OK;
HRESULT hr2 = S_OK;
ChanceDF *pTestChanceDF = NULL;
VirtualDF *pTestVirtualDF = NULL;
VirtualCtrNode *pVirtualDFRoot = NULL;
DG_STRING *pdgu = NULL;
USHORT usErr = 0;
LPTSTR ptszRootNewDocFile = NULL;
LPOLESTR poszRootNewDocFile = NULL;
DWORD dwRootMode = 0;
LPSTORAGE pStgRoot1 = NULL;
LPSTORAGE pStgRoot2 = NULL;
LPSTORAGE pStgRoot11 = NULL;
ULONG ulRef = 0;
DWORD dwCRC1 = 0;
DWORD dwCRC2 = 0;
DWORD dwCRC3 = 0;
DWORD dwCRC4 = 0;
LPMALLOC pMalloc = NULL;
LPENUMSTATSTG penumWalk = NULL;
LPTSTR ptszElementName = NULL;
LPOLESTR poszElementName = NULL;
BOOL fPass = TRUE;
STATSTG statStg;
DH_FUNCENTRY(NULL, DH_LVL_DFLIB, _TEXT("STGTEST_105"));
DH_TRACE((DH_LVL_TRACE1, TEXT("--------------------------------------------")) );
DH_TRACE((DH_LVL_TRACE1, TEXT("Test variation STGTEST_105 started.")) );
DH_TRACE((DH_LVL_TRACE1, TEXT("Attempt MoveElementTo-STGMOVE_COPY operations")));
// Create our ChanceDF and VirtualDF
hr = CreateTestDocfile (argc,
argv,
&pVirtualDFRoot,
&pTestVirtualDF,
&pTestChanceDF);
// if creating the docfile - bail here
if (NULL != pTestChanceDF && DoingCreate ())
{
UINT ulSeed = pTestChanceDF->GetSeed ();
CleanupTestDocfile (&pVirtualDFRoot,
&pTestVirtualDF,
&pTestChanceDF,
FALSE);
return (HRESULT)ulSeed;
}
if (S_OK == hr)
{
dwRootMode = pTestChanceDF->GetRootMode();
DH_TRACE((
DH_LVL_TRACE1,
TEXT("Run Mode for STGTEST_105, Access mode: %lx"),
dwRootMode));
}
// Commit substorages
if (S_OK == hr)
{
hr = ParseVirtualDFAndCommitAllOpenStgs(
pVirtualDFRoot,
STGC_DEFAULT,
NODE_EXC_TOPSTG);
DH_HRCHECK(hr, TEXT("ParseVirtualDFAndCloseOpenStgsStms"));
}
// Commit root.
if(S_OK == hr)
{
hr = pVirtualDFRoot->Commit(STGC_DEFAULT);
if (S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Commit completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Commit unsuccessful, hr=0x%lx."),
hr));
}
}
// Release root and all substorages/streams too
if (S_OK == hr)
{
hr = ParseVirtualDFAndCloseOpenStgsStms(
pVirtualDFRoot,
NODE_INC_TOPSTG);
DH_HRCHECK(hr, TEXT("ParseVirtualDFAndCloseOpenStgsStms"));
}
// Open the root only
if (S_OK == hr)
{
hr = pVirtualDFRoot->OpenRoot(
NULL,
dwRootMode,
NULL,
0);
DH_HRCHECK(hr, TEXT("VirtualCtrNode::Open")) ;
if (S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Open completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Open unsuccessful, hr=0x%lx."),
hr));
}
}
// Calculate CRC for entire DocFile without the RootDocfile name
if(S_OK == hr)
{
pStgRoot1 = pVirtualDFRoot->GetIStoragePointer();
DH_ASSERT(NULL != pStgRoot1);
hr = CalculateCRCForDocFile(pStgRoot1, VERIFY_EXC_TOPSTG_NAME, &dwCRC1);
DH_HRCHECK(hr, TEXT("CalculateCRCForDocFile")) ;
}
// Get DG_STRING object pointer
if (S_OK == hr)
{
pdgu = pTestVirtualDF->GetDataGenUnicode();
DH_ASSERT(NULL != pdgu) ;
}
if(S_OK == hr)
{
// Generate random name for first child storage
hr = GenerateRandomName(
pdgu,
MINLENGTH,
MAXLENGTH,
&ptszRootNewDocFile);
DH_HRCHECK(hr, TEXT("GenerateRandomName")) ;
}
if(S_OK == hr)
{
// Convert RootDocFile name to OLECHAR
hr = TStringToOleString(ptszRootNewDocFile, &poszRootNewDocFile);
DH_HRCHECK(hr, TEXT("TStringToOleString")) ;
}
if (S_OK == hr)
{
hr = StgCreateDocfile(
poszRootNewDocFile,
dwRootMode,
0,
&pStgRoot2);
DH_HRCHECK(hr, TEXT("StgCreateDocFile")) ;
if(S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("StgCreateDocfile successful as exp.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("StgCreateDocfile not successful, hr=0x%lx."),
hr));
}
}
if(S_OK == hr)
{
hr = CalculateCRCForDocFile(pStgRoot2, VERIFY_EXC_TOPSTG_NAME, &dwCRC2);
DH_HRCHECK(hr, TEXT("CalculateCRCForDocFile")) ;
}
// Call EnumElements to get a enumerator for first DocFile
if(S_OK == hr)
{
hr = pVirtualDFRoot->EnumElements(0, NULL, 0, &penumWalk);
DH_HRCHECK(hr, TEXT("VirtualCtrNode::EnumElements")) ;
if(S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::EnumElements passed as expected")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::EnumElements unexpectedly failed hr=0x%lx"),
hr));
}
}
// First get pMalloc that would be used to free up the name string from
// STATSTG.
if ( S_OK == hr )
{
hr = CoGetMalloc(MEMCTX_TASK, &pMalloc);
DH_HRCHECK(hr, TEXT("CoGetMalloc")) ;
}
while((S_OK == hr) && (S_OK == penumWalk->Next(1, &statStg, NULL)))
{
if(S_OK == hr)
{
// Convert statStg.pwcsName to TCHAR
hr = OleStringToTString(statStg.pwcsName, &ptszElementName);
DH_HRCHECK(hr, TEXT("OleStringToTString")) ;
}
if(S_OK == hr)
{
// Now Convert old name to OLECHAR
hr = TStringToOleString(ptszElementName, &poszElementName);
DH_HRCHECK(hr, TEXT("TStringToOleString")) ;
}
if(S_OK == hr)
{
// Move the element to second DocFile
hr = pStgRoot1->MoveElementTo(
poszElementName,
pStgRoot2,
poszElementName,
STGMOVE_COPY);
DH_HRCHECK(hr, TEXT("IStorage::MoveElementTo")) ;
if(S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("IStorage::MoveElementTo passed as expected")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("IStorage::MoveElementTo unexpectedly failed hr=0x%lx"),
hr));
}
}
// Release resources
if ( NULL != statStg.pwcsName)
{
pMalloc->Free(statStg.pwcsName);
statStg.pwcsName = NULL;
}
if(NULL != ptszElementName)
{
delete ptszElementName;
ptszElementName = NULL;
}
if(NULL != poszElementName)
{
delete poszElementName;
poszElementName = NULL;
}
// Break out of loop in error case
if(S_OK != hr)
{
break;
}
}
// Commit or Revert the second docfile as the case may be.
if((S_OK == hr) && (FALSE == g_fRevert))
{
hr = pStgRoot2->Commit(STGC_DEFAULT);
if(S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("IStorage::Commit completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("IStorage::Commit unsuccessful, hr=0x%lx."),
hr));
}
}
else
if((S_OK == hr) && (TRUE == g_fRevert))
{
hr = pStgRoot2->Revert();
if(S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("IStorage::Revert completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("IStorage::Revert unsuccessful, hr=0x%lx."),
hr));
}
}
// Close the second DocFile
if(NULL != pStgRoot2)
{
ulRef = pStgRoot2->Release();
DH_ASSERT(0 == ulRef);
pStgRoot2 = NULL;
}
// Open it again and do StgIsStorageFile to verify.
if(S_OK == hr)
{
hr = StgOpenStorage(
poszRootNewDocFile,
NULL,
dwRootMode,
NULL,
0,
&pStgRoot2);
DH_HRCHECK(hr, TEXT("StgOpenStorage")) ;
if (S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("StgOpenStorage completed successfully.")));
DH_ASSERT(NULL != pStgRoot2);
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("StgOpenStorage unsuccessful, hr=0x%lx."),
hr));
}
}
// Do StgIsStorageFile to verify
if(S_OK == hr)
{
hr = StgIsStorageFile(poszRootNewDocFile);
DH_HRCHECK(hr, TEXT("StgIsStorageFile")) ;
if (S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("StgIsStorageFile completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("StgIsStorageFile unsuccessful, hr=0x%lx."),
hr));
}
}
// Calculate CRC on this second Root DocFile.
if(S_OK == hr)
{
hr = CalculateCRCForDocFile(pStgRoot2, VERIFY_EXC_TOPSTG_NAME, &dwCRC3);
DH_HRCHECK(hr, TEXT("CalculateCRCForDocFile")) ;
// Compare CRC's
if((S_OK == hr) && ( FALSE == g_fRevert))
{
if (dwCRC3 == dwCRC1)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("CRC's for docfile1 & docfile2 after commit match.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("CRC for docfile1 & docfile2 aftr commit don't match")));
fPass = FALSE;
}
}
else
if((S_OK == hr) && ( TRUE == g_fRevert))
{
if (dwCRC3 == dwCRC2)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("CRC's for docfile2 before & after Revert match.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("CRC for docfile2 before & after Revert don't match")));
fPass = FALSE;
}
}
}
// Close the second DocFile
if(NULL != pStgRoot2)
{
ulRef = pStgRoot2->Release();
DH_ASSERT(0 == ulRef);
pStgRoot2 = NULL;
}
// Release penumWalk
if(NULL != penumWalk)
{
ulRef = penumWalk->Release();
DH_ASSERT(0 == ulRef);
penumWalk = NULL;
}
// Release root
if (S_OK == hr)
{
hr = pVirtualDFRoot->Close();
if (S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Close completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Close unsuccessful, hr=0x%lx."),
hr));
}
}
// Open the Root DocFile again to verify the STGMOVE_COPY flags specified
// while doing MoveElementTo
if (S_OK == hr)
{
hr = pVirtualDFRoot->OpenRoot(
NULL,
dwRootMode,
NULL,
0);
if (S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Open completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Open unsuccessful, hr=0x%lx."),
hr));
}
}
// Now get the CRC again on the original DocFile to verify that flag
// STGMOVE_COPY copied the elements and not moved them, so this CRC
// should match with CRC originally obtained on this DocFile.
if(S_OK == hr)
{
pStgRoot11 = pVirtualDFRoot->GetIStoragePointer();
DH_ASSERT(NULL != pStgRoot11);
hr = CalculateCRCForDocFile(pStgRoot11, VERIFY_EXC_TOPSTG_NAME,&dwCRC4);
DH_HRCHECK(hr, TEXT("CalculateCRCForDocFile")) ;
if(S_OK == hr)
{
if (dwCRC4 == dwCRC1)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("CRC's for original docfle match after move as copy.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("CRC for original DF don't match after move as copy.")));
fPass = FALSE;
}
}
}
// Release the first root docfile
if (S_OK == hr)
{
hr = pVirtualDFRoot->Close();
if (S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Close completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Close unsuccessful, hr=0x%lx."),
hr));
}
}
// if everything goes well, log test as passed else failed.
if ((S_OK == hr) && (TRUE == fPass))
{
DH_LOG((LOG_PASS, TEXT("Test variation STGTEST_105 passed.")) );
}
else
{
DH_LOG((LOG_FAIL,
TEXT("Test variation STGTEST_105 failed, hr=0x%lx."),
hr) );
// test failed. make sure it failed.
hr = FirstError (hr, E_FAIL);
}
// Cleanup
CleanupTestDocfile (&pVirtualDFRoot,
&pTestVirtualDF,
&pTestChanceDF,
S_OK == hr);
// Release pMalloc
if(NULL != pMalloc)
{
pMalloc->Release();
pMalloc = NULL;
}
// Delete strings
if(NULL != poszRootNewDocFile)
{
delete poszRootNewDocFile;
poszRootNewDocFile = NULL;
}
// Delete the second docfile on disk
if((S_OK == hr) && (NULL != ptszRootNewDocFile))
{
if(FALSE == DeleteFile(ptszRootNewDocFile))
{
hr2 = HRESULT_FROM_WIN32(GetLastError()) ;
DH_HRCHECK(hr2, TEXT("DeleteFile")) ;
}
}
// Delete temp string
if(NULL != ptszRootNewDocFile)
{
delete ptszRootNewDocFile;
ptszRootNewDocFile = NULL;
}
// Stop logging the test
DH_TRACE((DH_LVL_TRACE1, TEXT("Test variation STGTEST_105 finished")) );
DH_TRACE((DH_LVL_TRACE1, TEXT("--------------------------------------------")) );
return hr;
}
//----------------------------------------------------------------------------
//
// Test: STGTEST_106
//
// Synopsis: This test first creates a root docfile. A child IStorage is
// then created with STGM_DENY_WRITE set. An IStream is created
// inside the child IStorage and a random number of bytes are
// written to it. The stream is released, the child and root
// IStorages are committed, and the child IStorage is released.
// The child IStorage is instantiated in STGM_TRANSACTED mode
// and then released. A count of the files in the current directory
// is then made and saved. The child IStorage is then instantiated
// in STGM_TRANSACTED | STGM_DENY_WRITE mode and another count is
// made. We then verify that only 1 scratch file was created,
// indicating that for STGM_DENY_WRITE mode, no copy is made of
// the instantiated IStorage.
//
// Arguments:[argc]
// [argv]
//
// Returns: HRESULT
//
// History: 26-July-1996 NarindK Created.
//
// Notes: THIS TEST IS NOT APPLICABLE WITH PRESENT STORAGE CODE, PRESENT
// ONLY FOR DOCUMENTATION/REFERENCE PURPOSES. BY DESIGN, THE PRESENT
// DOCFILE REQUIRES THAT ALL SUBSTORAGES/SUBSTREAMS BE CREATED/OPENED
// WITH STGM_SHARE_EXCLUSIVE FLAG.
//
// This test runs in transacted modes
//
// New Test Notes:
// 1. Old File: LITWWDW.CXX
// 2. Old name of test : LegitInstRootTwwDenyWrite test
// New Name of test : STGTEST_106
// 3. To run the test, do the following at command prompt.
// stgbase /t:STGTEST-106
// 4. To run for conversion, add /dfStgType:conversion to the above
// 5. To run for nssfile, add /dfStgType:nssfile to the above
//
// BUGNOTE: Conversion: STGTEST-106
//
//-----------------------------------------------------------------------------
HRESULT STGTEST_106(ULONG ulSeed)
{
#ifdef _MAC
DH_TRACE((DH_LVL_TRACE1, TEXT("!!!!!!!!!!!!!STGTEST_106 crashes")) );
DH_TRACE((DH_LVL_TRACE1, TEXT("!!!!!!!!!!!!!To be investigated")) );
return E_NOTIMPL;
#else
HRESULT hr = S_OK;
ChanceDF *pTestChanceDF = NULL;
VirtualDF *pTestVirtualDF = NULL;
VirtualCtrNode *pVirtualDFRoot = NULL;
VirtualCtrNode *pvcnRootNewChildStg = NULL;
VirtualStmNode *pvsnNewChildStream = NULL;
DWORD dwRootMode = STGM_READWRITE | STGM_TRANSACTED;
DG_STRING *pdgu = NULL;
DG_INTEGER *pdgi = NULL;
USHORT usErr = 0;
LPTSTR ptszRootName = NULL;
LPTSTR ptszRootNewChildStgName = NULL;
LPTSTR ptszStreamName = NULL;
BOOL fPass = TRUE;
LPTSTR ptcsBuffer = NULL;
ULONG culWritten = 0;
ULONG culFilesInDirectory = 0;
ULONG cb = 0;
DWCRCSTM dwMemCRC;
DWCRCSTM dwActCRC;
CDFD cdfd;
dwMemCRC.dwCRCSum = dwActCRC.dwCRCSum = 0;
DH_FUNCENTRY(NULL, DH_LVL_DFLIB, _TEXT("STGTEST_106"));
DH_TRACE((DH_LVL_TRACE1, TEXT("--------------------------------------------")) );
DH_TRACE((DH_LVL_TRACE1, TEXT("Test variation STGTEST_106 started.")) );
DH_TRACE((DH_LVL_TRACE1,
TEXT("Attempt operations on child storage in transacted mode.")));
if(S_OK == hr)
{
// Create a new DataGen object to create random UNICODE strings.
pdgu = new(NullOnFail) DG_STRING(ulSeed);
if (NULL == pdgu)
{
hr = E_OUTOFMEMORY;
}
else
{
//want to create only one seed. Once that has been done,
//use what we created from now on.
ulSeed = pdgu->GetSeed ();
}
}
// Generate RootDocFile name
if(S_OK == hr)
{
hr=GenerateRandomName(pdgu, MINLENGTH,MAXLENGTH, &ptszRootName);
DH_HRCHECK(hr, TEXT("GenerateRandomName")) ;
}
if(S_OK == hr)
{
cdfd.cDepthMin = 0;
cdfd.cDepthMax = 0;
cdfd.cStgMin = 0;
cdfd.cStgMax = 0;
cdfd.cStmMin = 0;
cdfd.cStmMax = 0;
cdfd.cbStmMin = 0;
cdfd.cbStmMax = 0;
cdfd.ulSeed = ulSeed;
cdfd.dwRootMode = dwRootMode | STGM_CREATE;
hr = CreateTestDocfile (&cdfd,
ptszRootName,
&pVirtualDFRoot,
&pTestVirtualDF,
&pTestChanceDF);
DH_HRCHECK(hr, TEXT("CreateTestDocfile"));
}
// if creating the docfile - bail here
if (NULL != pTestChanceDF && DoingCreate ())
{
ulSeed = pTestChanceDF->GetSeed ();
CleanupTestDocfile (&pVirtualDFRoot,
&pTestVirtualDF,
&pTestChanceDF,
FALSE);
return (HRESULT)ulSeed;
}
// Adds a new storage to the root storage.
if(S_OK == hr)
{
// Generate random name for storage
hr = GenerateRandomName(
pdgu,
MINLENGTH,
MAXLENGTH,
&ptszRootNewChildStgName);
DH_HRCHECK(hr, TEXT("GenerateRandomName")) ;
}
if(S_OK == hr)
{
hr = AddStorage(
pTestVirtualDF,
pVirtualDFRoot,
ptszRootNewChildStgName,
dwRootMode | STGM_SHARE_DENY_WRITE | STGM_FAILIFTHERE,
&pvcnRootNewChildStg);
DH_HRCHECK(hr, TEXT("AddStorage")) ;
if(S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::AddStorage completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::AddStorage not successful, hr=0x%lx."),
hr));
}
}
// Now add a stream to this child storage
// Generate random name for stream
if(S_OK == hr)
{
hr=GenerateRandomName(pdgu, MINLENGTH,MAXLENGTH, &ptszStreamName);
DH_HRCHECK(hr, TEXT("GenerateRandomName")) ;
}
// Get DG_INTEGER object pointer
if (S_OK == hr)
{
pdgi = pTestVirtualDF->GetDataGenInteger();
DH_ASSERT(NULL != pdgi);
}
if (S_OK == hr)
{
// Generate random size for stream.
usErr = pdgi->Generate(&cb, 1, USHRT_MAX);
if (DG_RC_SUCCESS != usErr)
{
hr = E_FAIL;
}
}
if(S_OK == hr)
{
hr = AddStream(
pTestVirtualDF,
pvcnRootNewChildStg,
ptszStreamName,
cb,
STGM_READWRITE |
STGM_SHARE_EXCLUSIVE |
STGM_FAILIFTHERE,
&pvsnNewChildStream);
DH_HRCHECK(hr, TEXT("AddStream")) ;
if(S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualStmNode::AddStream completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualStmNode::AddStream not successful, hr=0x%lx."),
hr));
}
}
// Write random data into stream
if(S_OK == hr)
{
hr = GenerateRandomString(pdgu, cb, cb, &ptcsBuffer);
DH_HRCHECK(hr, TEXT("GenerateRandomString")) ;
}
if(S_OK == hr)
{
hr = pvsnNewChildStream->Write(
ptcsBuffer,
cb,
&culWritten);
DH_HRCHECK(hr, TEXT("IStream::Write")) ;
}
// Calculate the CRC for stream name and data
if(S_OK == hr)
{
hr = CalculateInMemoryCRCForStm(
pvsnNewChildStream,
ptcsBuffer,
cb,
&dwMemCRC);
DH_HRCHECK(hr, TEXT("CalculateInMemoryCRCForStm")) ;
}
// Release stream
if (S_OK == hr)
{
hr = pvsnNewChildStream->Close();
if (S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualStmNode::Close completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualStmNode::Close unsuccessful, hr=0x%lx.")));
}
}
// Now do a commit of child storage with STGC_ONLYIFCURRENT.
if (S_OK == hr)
{
hr = pvcnRootNewChildStg->Commit(STGC_ONLYIFCURRENT);
DH_HRCHECK(hr, TEXT("VirtualCtrNode::Commit")) ;
if (S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Commit completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Commit unsuccessful, hr=0x%lx."),
hr));
}
}
// Now do a commit of root storage with STGC_ONLYIFCURRENT.
if (S_OK == hr)
{
hr = pVirtualDFRoot->Commit(STGC_ONLYIFCURRENT);
DH_HRCHECK(hr, TEXT("VirtualCtrNode::Commit")) ;
if (S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Commit completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Commit unsuccessful, hr=0x%lx."),
hr));
}
}
// Close the child storage
if (S_OK == hr)
{
hr = pvcnRootNewChildStg->Close();
DH_HRCHECK(hr, TEXT("VirtualCtrNode::Close")) ;
if (S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Close completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Close unsuccessful, hr=0x%lx."),
hr));
}
}
// Open the child storage
if (S_OK == hr)
{
hr = pvcnRootNewChildStg->Open(
NULL,
dwRootMode | STGM_SHARE_EXCLUSIVE,
NULL,
0);
DH_HRCHECK(hr, TEXT("VirtualCtrNode::Open")) ;
if (S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Open completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Open unsuccessful, hr=0x%lx."),
hr));
}
}
// Close the child storage
if (S_OK == hr)
{
hr = pvcnRootNewChildStg->Close();
DH_HRCHECK(hr, TEXT("VirtualCtrNode::Close")) ;
if (S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Close completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Close unsuccessful, hr=0x%lx."),
hr));
}
}
// count number of files in directory
if (S_OK == hr)
{
culFilesInDirectory = CountFilesInDirectory(WILD_MASK);
}
// Open the with STGM_SHARE_DENY_WRITE
if (S_OK == hr)
{
hr = pvcnRootNewChildStg->Open(
NULL,
dwRootMode | STGM_SHARE_DENY_WRITE,
NULL,
0);
DH_HRCHECK(hr, TEXT("VirtualCtrNode::Open")) ;
if (S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Open completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Open unsuccessful, hr=0x%lx."),
hr));
}
}
// Check number of files
if(S_OK == hr)
{
if((culFilesInDirectory + 1) != CountFilesInDirectory(WILD_MASK))
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT(">1 scratch file unexp STGM_SHARE_DENY_WRITE inst.")));
hr = S_FALSE;
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("1 scratchfile as exp STGM_SHARE_DENY_WRITE inst")));
}
}
// OpenStream
if (S_OK == hr)
{
hr = pvsnNewChildStream->Open(
NULL,
dwRootMode | STGM_SHARE_DENY_WRITE,
0);
DH_HRCHECK(hr, TEXT("VirtualStmNode::Open")) ;
if (S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualStmNode::Open completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualStmNode::Open unsuccessful, hr=0x%lx."),
hr));
}
}
// Read stream, CRC and verify
if(S_OK == hr)
{
hr = ReadAndCalculateDiskCRCForStm(pvsnNewChildStream,&dwActCRC);
DH_HRCHECK(hr, TEXT("ReadAndCalculateDiskCRCForStm")) ;
if (S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("ReadAndCalculateDiskCRCForStm function successful.")));
if(dwActCRC.dwCRCSum == dwMemCRC.dwCRCSum)
{
DH_TRACE((DH_LVL_TRACE1, TEXT("CRC's for pvsnNewChildStream match.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("CRC's for pvsnNewChildStream don't match.")));
fPass = FALSE;
}
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("ReadAndCalculateDiskCRCForStm not successful, hr=0x%lx."),
hr));
}
}
// Close the stream in child storage
if (S_OK == hr)
{
hr = pvsnNewChildStream->Close();
DH_HRCHECK(hr, TEXT("VirtualStmNode::Close")) ;
if (S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualStmNode::Close completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualStmNode::Close unsuccessful, hr=0x%lx."),
hr));
}
}
// Close the child storage
if (S_OK == hr)
{
hr = pvcnRootNewChildStg->Close();
DH_HRCHECK(hr, TEXT("VirtualCtrNode::Close")) ;
if (S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Close completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Close unsuccessful, hr=0x%lx."),
hr));
}
}
// Close the root
if (S_OK == hr)
{
hr = pVirtualDFRoot->Close();
DH_HRCHECK(hr, TEXT("VirtualCtrNode::Close")) ;
if (S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Close completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Close unsuccessful, hr=0x%lx."),
hr));
}
}
// if everything goes well, log test as passed else failed.
if (S_OK == hr)
{
DH_LOG((LOG_PASS, TEXT("Test variation STGTEST_106 passed.")) );
}
else
{
DH_LOG((LOG_FAIL,
TEXT("Test variation STGTEST_106 failed, hr=0x%lx."),
hr) );
}
// Cleanup
CleanupTestDocfile (&pVirtualDFRoot,
&pTestVirtualDF,
&pTestChanceDF,
S_OK == hr);
// Delete DataGen object
if(NULL != pdgu)
{
delete pdgu;
pdgu = NULL;
}
// Delete temp string
if(NULL != ptszRootNewChildStgName)
{
delete ptszRootNewChildStgName;
ptszRootNewChildStgName = NULL;
}
if(NULL != ptszStreamName)
{
delete ptszStreamName;
ptszStreamName = NULL;
}
if(NULL != ptcsBuffer)
{
delete ptcsBuffer;
ptcsBuffer = NULL;
}
// Delete temp string
if(NULL != ptszRootName)
{
delete ptszRootName;
ptszRootName = NULL;
}
// Stop logging the test
DH_TRACE((DH_LVL_TRACE1, TEXT("Test variation STGTEST_106 finished")) );
DH_TRACE((DH_LVL_TRACE1, TEXT("--------------------------------------------")) );
return hr;
#endif //_MAC
}
//----------------------------------------------------------------------------
//
// Test: STGTEST_107
//
// Synopsis: A random docfile with random number of storages and streams is
// generated. Root is committed and closed.
// The root docfile is instantiated and the CRC is computed for the
// entire docfile. A new root docfile with a random name is then
// created and a CRC is generated for the empty root docfile. An
// enumerator is obtained on the source docfile, each element returned
// is MoveElementTo()'d with STGM_MOVE to the destination docfile.
// If fRevertAfterMove equals TRUE, the dest is reverted, else the
// dest is committed. The dest is released and reinstantiated and
// CRC'd. If the dest was reverted, the CRC is compared against the
// empty CRC for a match. Otherwise, we compare against the original
// root docfile CRC. Original file is CRC'd again to verify that
// STGMOVE_MOVE moved the elements from orginal position instead of
// copying, the CRC now computed should differ from the one calculated
// originally.
//
// This tests differs from STGTEST-105 in the way that MoveElementTo
// is called with STGMOVE_MOVE flag instead of STGMOVE_COPY.
//
// Arguments:[argc]
// [argv]
//
// Returns: HRESULT
//
// Notes: This test runs in direct, transacted, and transacted deny write
// modes
//
// History: 8-Aug-1996 NarindK Created.
//
// New Test Notes:
// 1. Old File: A part of STORAGE.CXX
// 2. Old name of test : A part of STORAGE_TEST Test
// New Name of test : STGTEST_107
// 3. To run the test, do the following at command prompt.
// a. stgbase /seed:2 /dfdepth:1-3 /dfstg:1-3 /dfstm:2-3 /t:STGTEST-107
// /dfRootMode:dirReadWriteShEx /dfStgMode:dirReadWriteShEx
// b. stgbase /seed:2 /dfdepth:1-3 /dfstg:1-3 /dfstm:2-3 /t:STGTEST-107
// /dfRootMode:xactReadWriteShEx /dfStgMode:xactReadWriteShEx
// c. stgbase /seed:2 /dfdepth:1-3 /dfstg:1-3 /dfstm:2-3 /t:STGTEST-107
// /dfRootMode:xactReadWriteShDenyW /dfStgMode:xactReadWriteShEx
// d. stgbase /seed:2 /dfdepth:1-3 /dfstg:1-3 /dfstm:2-3 /t:STGTEST-107
// /dfRootMode:xactReadWriteShEx /dfStgMode:xactReadWriteShEx
// /frevertaftermove
// e. stgbase /seed:2 /dfdepth:1-3 /dfstg:1-3 /dfstm:2-3 /t:STGTEST-107
// /dfRootMode:xactReadWriteShDenyW /dfStgMode:xactReadWriteShEx
// /frevertaftermove
// 4. To run for conversion, add /dfStgType:conversion to each of the above
// 5. To run for nssfile, add /dfStgType:nssfile to each of the above
// BUGBUG: dont have /stdblock up yet. -scousens
//
// In case of direct mode, the flag revertaftermove is not meaningful since
// changes are always directly written to disk doc file.
//
// BUGNOTE: Conversion: STGTEST-107
//
//-----------------------------------------------------------------------------
HRESULT STGTEST_107(int argc, char *argv[])
{
HRESULT hr = S_OK;
HRESULT hr2 = S_OK;
ChanceDF *pTestChanceDF = NULL;
VirtualDF *pTestVirtualDF = NULL;
VirtualCtrNode *pVirtualDFRoot = NULL;
DG_STRING *pdgu = NULL;
USHORT usErr = 0;
LPTSTR ptszRootNewDocFile = NULL;
LPOLESTR poszRootNewDocFile = NULL;
DWORD dwRootMode = 0;
LPSTORAGE pStgRoot1 = NULL;
LPSTORAGE pStgRoot2 = NULL;
LPSTORAGE pStgRoot11 = NULL;
ULONG ulRef = 0;
DWORD dwCRC1 = 0;
DWORD dwCRC2 = 0;
DWORD dwCRC3 = 0;
DWORD dwCRC4 = 0;
LPMALLOC pMalloc = NULL;
LPENUMSTATSTG penumWalk = NULL;
LPTSTR ptszElementName = NULL;
LPOLESTR poszElementName = NULL;
BOOL fPass = TRUE;
STATSTG statStg;
DH_FUNCENTRY(NULL, DH_LVL_DFLIB, _TEXT("STGTEST_107"));
DH_TRACE((DH_LVL_TRACE1, TEXT("--------------------------------------------")) );
DH_TRACE((DH_LVL_TRACE1, TEXT("Test variation STGTEST_107 started.")) );
DH_TRACE((DH_LVL_TRACE1, TEXT("Attempt MoveElementTo-STGMOVE_MOVE operations")));
// Create our ChanceDF and VirtualDF
hr = CreateTestDocfile (argc,
argv,
&pVirtualDFRoot,
&pTestVirtualDF,
&pTestChanceDF);
// if creating the docfile - bail here
if (NULL != pTestChanceDF && DoingCreate ())
{
UINT ulSeed = pTestChanceDF->GetSeed ();
CleanupTestDocfile (&pVirtualDFRoot,
&pTestVirtualDF,
&pTestChanceDF,
FALSE);
return (HRESULT)ulSeed;
}
if (S_OK == hr)
{
dwRootMode = pTestChanceDF->GetRootMode();
DH_TRACE((
DH_LVL_TRACE1,
TEXT("Run Mode for STGTEST_107, Access mode: %lx"),
dwRootMode));
}
// Commit all substgs BUGBUG df already commited
if (S_OK == hr)
{
hr = ParseVirtualDFAndCommitAllOpenStgs(
pVirtualDFRoot,
STGC_DEFAULT,
NODE_EXC_TOPSTG);
DH_HRCHECK(hr, TEXT("ParseVirtualDFAndCloseOpenStgsStms"));
}
// Commit root.
if(S_OK == hr)
{
hr = pVirtualDFRoot->Commit(STGC_DEFAULT);
if (S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Commit completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Commit unsuccessful, hr=0x%lx."),
hr));
}
}
// Release root and all substorages/streams too
if (S_OK == hr)
{
hr = ParseVirtualDFAndCloseOpenStgsStms(
pVirtualDFRoot,
NODE_INC_TOPSTG);
DH_HRCHECK(hr, TEXT("ParseVirtualDFAndCloseOpenStgsStms"));
}
// Open the root only
if (S_OK == hr)
{
hr = pVirtualDFRoot->OpenRoot(
NULL,
dwRootMode,
NULL,
0);
DH_HRCHECK(hr, TEXT("VirtualCtrNode::Open")) ;
if (S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Open completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Open unsuccessful, hr=0x%lx."),
hr));
}
}
// Calculate CRC for entire DocFile without the RootDocfile name
if(S_OK == hr)
{
pStgRoot1 = pVirtualDFRoot->GetIStoragePointer();
DH_ASSERT(NULL != pStgRoot1);
hr = CalculateCRCForDocFile(pStgRoot1, VERIFY_EXC_TOPSTG_NAME, &dwCRC1);
DH_HRCHECK(hr, TEXT("CalculateCRCForDocFile")) ;
}
// Get DG_STRING object pointer
if (S_OK == hr)
{
pdgu = pTestVirtualDF->GetDataGenUnicode();
DH_ASSERT(NULL != pdgu) ;
}
if(S_OK == hr)
{
// Generate random name for first child storage
hr = GenerateRandomName(
pdgu,
MINLENGTH,
MAXLENGTH,
&ptszRootNewDocFile);
DH_HRCHECK(hr, TEXT("GenerateRandomName")) ;
}
if(S_OK == hr)
{
// Convert RootDocFile name to OLECHAR
hr = TStringToOleString(ptszRootNewDocFile, &poszRootNewDocFile);
DH_HRCHECK(hr, TEXT("TStringToOleString")) ;
}
if (S_OK == hr)
{
hr = StgCreateDocfile(
poszRootNewDocFile,
dwRootMode,
0,
&pStgRoot2);
DH_HRCHECK(hr, TEXT("StgCreateDocFile")) ;
if(S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("StgCreateDocfile successful as exp.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("StgCreateDocfile not successful, hr=0x%lx."),
hr));
}
}
if(S_OK == hr)
{
hr = CalculateCRCForDocFile(pStgRoot2, VERIFY_EXC_TOPSTG_NAME, &dwCRC2);
DH_HRCHECK(hr, TEXT("CalculateCRCForDocFile")) ;
}
// Call EnumElements to get a enumerator for first DocFile
if(S_OK == hr)
{
hr = pVirtualDFRoot->EnumElements(0, NULL, 0, &penumWalk);
DH_HRCHECK(hr, TEXT("VirtualCtrNode::EnumElements")) ;
if(S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::EnumElements passed as expected")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::EnumElements unexpectedly failed hr=0x%lx"),
hr));
}
}
// First get pMalloc that would be used to free up the name string from
// STATSTG.
if ( S_OK == hr )
{
hr = CoGetMalloc(MEMCTX_TASK, &pMalloc);
DH_HRCHECK(hr, TEXT("CoGetMalloc")) ;
}
while(S_OK == hr && S_OK == penumWalk->Next(1, &statStg, NULL))
{
if(S_OK == hr)
{
// Convert statStg.pwcsName to TCHAR
hr = OleStringToTString(statStg.pwcsName, &ptszElementName);
DH_HRCHECK(hr, TEXT("OleStringToTString")) ;
}
if(S_OK == hr)
{
// Now Convert old name to OLECHAR
hr = TStringToOleString(ptszElementName, &poszElementName);
DH_HRCHECK(hr, TEXT("TStringToOleString")) ;
}
if(S_OK == hr)
{
// Move the element to second DocFile
hr = pStgRoot1->MoveElementTo(
poszElementName,
pStgRoot2,
poszElementName,
STGMOVE_COPY);
DH_HRCHECK(hr, TEXT("IStorage::MoveElementTo")) ;
if(S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("IStorage::MoveElementTo passed as expected")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("IStorage::MoveElementTo unexpectedly failed hr=0x%lx"),
hr));
}
}
// Release resources
if ( NULL != statStg.pwcsName)
{
pMalloc->Free(statStg.pwcsName);
statStg.pwcsName = NULL;
}
if(NULL != ptszElementName)
{
delete ptszElementName;
ptszElementName = NULL;
}
if(NULL != poszElementName)
{
delete poszElementName;
poszElementName = NULL;
}
}
// Commit or Revert the second docfile as the case may be.
if((S_OK == hr) && (FALSE == g_fRevert))
{
hr = pStgRoot2->Commit(STGC_DEFAULT);
if(S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("IStorage::Commit completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("IStorage::Commit unsuccessful, hr=0x%lx."),
hr));
}
}
else
if((S_OK == hr) && (TRUE == g_fRevert))
{
hr = pStgRoot2->Revert();
if(S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("IStorage::Revert completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("IStorage::Revert unsuccessful, hr=0x%lx."),
hr));
}
}
// Close the second DocFile
if(NULL != pStgRoot2)
{
ulRef = pStgRoot2->Release();
DH_ASSERT(0 == ulRef);
pStgRoot2 = NULL;
}
// Open it again and do StgIsStorageFile to verify.
if(S_OK == hr)
{
hr = StgOpenStorage(
poszRootNewDocFile,
NULL,
dwRootMode,
NULL,
0,
&pStgRoot2);
DH_HRCHECK(hr, TEXT("StgOpenStorage")) ;
if (S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("StgOpenStorage completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("StgOpenStorage unsuccessful, hr=0x%lx."),
hr));
}
}
// Do StgIsStorageFile to verify
if(S_OK == hr)
{
hr = StgIsStorageFile(poszRootNewDocFile);
DH_HRCHECK(hr, TEXT("StgIsStorageFile")) ;
if (S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("StgIsStorageFile completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("StgIsStorageFile unsuccessful, hr=0x%lx."),
hr));
}
}
// Calculate CRC on this second Root DocFile.
if(S_OK == hr)
{
hr = CalculateCRCForDocFile(pStgRoot2, VERIFY_EXC_TOPSTG_NAME, &dwCRC3);
DH_HRCHECK(hr, TEXT("CalculateCRCForDocFile")) ;
}
// Compare CRC's
if((S_OK == hr) && ( FALSE == g_fRevert))
{
if (dwCRC3 == dwCRC1)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("CRC's for docfile1 & docfile2 after commit match.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("CRC for docfile1 & docfile2 aftr commit don't match")));
fPass = FALSE;
}
}
else
if((S_OK == hr) && ( TRUE == g_fRevert))
{
if (dwCRC3 == dwCRC2)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("CRC's for docfile2 before & after Revert match.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("CRC for docfile2 before & after Revert don't match")));
fPass = FALSE;
}
}
// Close the second DocFile
if(NULL != pStgRoot2)
{
ulRef = pStgRoot2->Release();
DH_ASSERT(0 == ulRef);
pStgRoot2 = NULL;
}
// Release penumWalk
if(NULL != penumWalk)
{
ulRef = penumWalk->Release();
DH_ASSERT(0 == ulRef);
penumWalk = NULL;
}
// Release the first root docfile
if (S_OK == hr)
{
hr = pVirtualDFRoot->Close();
if (S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Close completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Close unsuccessful, hr=0x%lx."),
hr));
}
}
// Open the Root DocFile again to verify the STGMOVE_MOVE flags specified
// while doing MoveElementTo
if (S_OK == hr)
{
hr = pVirtualDFRoot->OpenRoot(
NULL,
dwRootMode,
NULL,
0);
if (S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Open completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Open unsuccessful, hr=0x%lx."),
hr));
}
}
// Now get the CRC again on the original DocFile to verify that flag
// STGMOVE_COPY copied the elements and not moved them, so this CRC
// should match with CRC originally obtained on this DocFile.
if(S_OK == hr)
{
pStgRoot11 = pVirtualDFRoot->GetIStoragePointer();
DH_ASSERT(NULL != pStgRoot11);
hr = CalculateCRCForDocFile(pStgRoot11, VERIFY_EXC_TOPSTG_NAME,&dwCRC4);
DH_HRCHECK(hr, TEXT("CalculateCRCForDocFile")) ;
if(S_OK == hr)
{
if (dwCRC4 == dwCRC1)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("CRC for org docfile don't match as exp-move as move")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("CRC for org docfile match unexp -move as move")));
fPass = FALSE;
}
}
}
// Release the first root docfile
if (S_OK == hr)
{
hr = pVirtualDFRoot->Close();
if (S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Close completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Close unsuccessful, hr=0x%lx."),
hr));
}
}
// Release pMalloc
if(NULL != pMalloc)
{
pMalloc->Release();
pMalloc = NULL;
}
// if everything goes well, log test as passed else failed.
if ((S_OK == hr) && (TRUE == fPass))
{
DH_LOG((LOG_PASS, TEXT("Test variation STGTEST_107 passed.")) );
}
else
{
DH_LOG((LOG_FAIL,
TEXT("Test variation STGTEST_107 failed, hr=0x%lx."),
hr) );
// test failed. make sure it failed.
hr = FirstError (hr, E_FAIL);
}
// Cleanup
CleanupTestDocfile (&pVirtualDFRoot,
&pTestVirtualDF,
&pTestChanceDF,
S_OK == hr);
// Delete strings
if(NULL != poszRootNewDocFile)
{
delete poszRootNewDocFile;
poszRootNewDocFile = NULL;
}
// Delete the second docfile on disk
if((S_OK == hr) && (NULL != ptszRootNewDocFile))
{
if(FALSE == DeleteFile(ptszRootNewDocFile))
{
hr2 = HRESULT_FROM_WIN32(GetLastError()) ;
DH_HRCHECK(hr2, TEXT("DeleteFile")) ;
}
}
// Delete temp string
if(NULL != ptszRootNewDocFile)
{
delete ptszRootNewDocFile;
ptszRootNewDocFile = NULL;
}
// Stop logging the test
DH_TRACE((DH_LVL_TRACE1, TEXT("Test variation STGTEST_107 finished")) );
DH_TRACE((DH_LVL_TRACE1, TEXT("--------------------------------------------")) );
return hr;
}
//----------------------------------------------------------------------------
//
// Test: STGTEST_108
//
// Synopsis: A root docfile with a child storage is created, then check if
// Set/GetConvertStorage APIs work correctly as expected by passed
// in a storage pointer(here, we test both root storage and child
// storage pointer). Also have some illegitmate tests by passing
// invalid arguments to these APIs.
//
// Arguments:[argc]
// [argv]
//
// Returns: HRESULT
//
// Notes: This test runs in direct, transacted, and transacted deny write
// modes
//
// History: 14-Aug-1996 JiminLi Created.
//
// New Test Notes:
// 1. Old File: A part of STORAGE.CXX
// 2. Old name of test : A part of STORAGE_TEST Test
// New Name of test : STGTEST_108
// 3. To run the test, do the following at command prompt.
// a. stgbase /seed:0 /dfdepth:0-0 /dfstg:0-0 /dfstm:0-0 /t:STGTEST-108
// /dfRootMode:dirReadWriteShEx /dfStgMode:dirReadWriteShEx
// b. stgbase /seed:0 /dfdepth:0-0 /dfstg:0-0 /dfstm:0-0 /t:STGTEST-108
// /dfRootMode:xactReadWriteShEx /dfStgMode:xactReadWriteShEx
// c. stgbase /seed:0 /dfdepth:0-0 /dfstg:0-0 /dfstm:0-0 /t:STGTEST-108
// /dfRootMode:xactReadWriteShDenyW /dfStgMode:xactReadWriteShEx
// 4. To run for conversion, add /dfStgType:conversion to each of the above
// 5. To run for nssfile, add /dfStgType:nssfile to each of the above
//
// BUGNOTE: Conversion: STGTEST-108
//
//-----------------------------------------------------------------------------
HRESULT STGTEST_108(int argc, char *argv[])
{
HRESULT hr = S_OK;
ChanceDF *pTestChanceDF = NULL;
VirtualDF *pTestVirtualDF = NULL;
VirtualCtrNode *pVirtualDFRoot = NULL;
VirtualCtrNode *pvcnRootNewChildStg = NULL;
LPTSTR pRootNewChildStgName = NULL;
DG_STRING *pdgu = NULL;
DG_INTEGER *pdgi = NULL;
LPSTORAGE pRootStg = NULL;
LPSTORAGE pChildStg = NULL;
USHORT usErr = 0;
DWORD dwRootMode = 0;
DWORD dwStgMode = 0;
DH_FUNCENTRY(NULL, DH_LVL_DFLIB, _TEXT("STGTEST_108"));
DH_TRACE((DH_LVL_TRACE1, TEXT("--------------------------------------------")) );
DH_TRACE((DH_LVL_TRACE1, TEXT("Test variation STGTEST_108 started.")) );
DH_TRACE((
DH_LVL_TRACE1,
TEXT("Attempt legit and illegit tests on Set/GetConvertStg APIs")));
// Create our ChanceDF and VirtualDF
hr = CreateTestDocfile (argc,
argv,
&pVirtualDFRoot,
&pTestVirtualDF,
&pTestChanceDF);
// if creating the docfile - bail here
if (NULL != pTestChanceDF && DoingCreate ())
{
UINT ulSeed = pTestChanceDF->GetSeed ();
CleanupTestDocfile (&pVirtualDFRoot,
&pTestVirtualDF,
&pTestChanceDF,
FALSE);
return (HRESULT)ulSeed;
}
if (S_OK == hr)
{
dwRootMode = pTestChanceDF->GetRootMode();
dwStgMode = pTestChanceDF->GetStgMode();
DH_TRACE((
DH_LVL_TRACE1,
TEXT("Run Mode for STGTEST_108, Access mode: %lx"),
dwRootMode));
}
// Get root storage pointer
if (NULL != pVirtualDFRoot)
{
pRootStg = pVirtualDFRoot->GetIStoragePointer();
}
// Get DG_STRING object pointer
if (S_OK == hr)
{
pdgu = pTestVirtualDF->GetDataGenUnicode();
DH_ASSERT(NULL != pdgu) ;
}
// Get DG_INTEGER object pointer
if (S_OK == hr)
{
pdgi = pTestVirtualDF->GetDataGenInteger();
DH_ASSERT(NULL != pdgi) ;
}
// Adds a new storage to the root storage.
if(S_OK == hr)
{
// Generate random name for storage
hr = GenerateRandomName(pdgu,MINLENGTH,MAXLENGTH,&pRootNewChildStgName);
DH_HRCHECK(hr, TEXT("GenerateRandomName")) ;
}
if(S_OK == hr)
{
hr = AddStorage(
pTestVirtualDF,
pVirtualDFRoot,
pRootNewChildStgName,
dwStgMode,
&pvcnRootNewChildStg);
pChildStg = pvcnRootNewChildStg->GetIStoragePointer();
DH_HRCHECK(hr, TEXT("AddStorage")) ;
if(S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("AddStorage completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("AddStorage not successful, hr=0x%lx."),
hr));
}
}
// Legit tests of Set/GetConvertStg on the root storage
if (S_OK == hr)
{
hr = SetConvertStg(pRootStg, TRUE);
if (S_OK == hr)
{
hr = GetConvertStg(pRootStg);
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("SetConvertStg did not return S_OK as expected.")));
}
if (S_OK == hr)
{
hr = SetConvertStg(pRootStg, FALSE);
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("GetConvertStg did not return S_OK as expected.")));
}
if (S_OK == hr)
{
hr = GetConvertStg(pRootStg);
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("SetConvertStg did not return S_OK as expected.")));
}
if (S_FALSE == hr)
{
hr = S_OK;
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("GetConvertStg did not return S_FALSE as expected.")));
hr = E_FAIL;
}
}
// Legit tests of Set/GetConvertStg on the child storage
if (S_OK == hr)
{
hr = SetConvertStg(pChildStg, TRUE);
if (S_OK == hr)
{
hr = GetConvertStg(pChildStg);
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("SetConvertStg did not return S_OK as expected.")));
}
if (S_OK == hr)
{
hr = SetConvertStg(pChildStg, FALSE);
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("GetConvertStg did not return S_OK as expected.")));
}
if (S_OK == hr)
{
hr = GetConvertStg(pChildStg);
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("SetConvertStg did not return S_OK as expected.")));
}
if (S_FALSE == hr)
{
hr = S_OK;
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("GetConvertStg did not return S_FALSE as expected.")));
hr = E_FAIL;
}
}
// Illegit tests
#ifdef _MAC
DH_TRACE((DH_LVL_TRACE1, TEXT("!!!!!!!!!!!SetConvertStg with NULL IStorage skipped")) );
#else
// Pass NULL as IStorage pointer, it should fail
if (S_OK == hr)
{
hr = SetConvertStg(NULL, TRUE);
if (E_INVALIDARG == hr)
{
hr = S_OK;
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("SetConvertStg did not return E_INVALIDARG as expected")));
hr = E_FAIL;
}
if (S_OK == hr)
{
hr = GetConvertStg(NULL);
}
if (E_INVALIDARG == hr)
{
hr = S_OK;
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("GetConvertStg did not return E_INVALIDARG as expected")));
hr = E_FAIL;
}
}
#endif //_MAC
// Commit the root
if (S_OK == hr)
{
hr = pVirtualDFRoot->Commit(STGC_DEFAULT);
DH_HRCHECK(hr, TEXT("VirtualCtrNode::Commit"));
if (S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Commit completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Commit unsuccessful, hr=0x%lx."),
hr));
}
}
// Release child and root storages
if (S_OK == hr)
{
hr = pvcnRootNewChildStg->Close();
DH_HRCHECK(hr, TEXT("VirtualCtrNode::Close"));
}
if (S_OK == hr)
{
hr = pVirtualDFRoot->Close();
if (S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Close completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Close unsuccessful, hr=0x%lx."),
hr));
}
}
// if everything goes well, log test as passed else failed.
if (S_OK == hr)
{
DH_LOG((LOG_PASS, TEXT("Test variation STGTEST_108 passed.")) );
}
else
{
DH_LOG((LOG_FAIL,
TEXT("Test variation STGTEST_108 failed, hr = 0x%lx."),
hr) );
}
// Cleanup
CleanupTestDocfile (&pVirtualDFRoot,
&pTestVirtualDF,
&pTestChanceDF,
S_OK == hr);
// Delete temp strings
if (NULL != pRootNewChildStgName)
{
delete []pRootNewChildStgName;
pRootNewChildStgName = NULL;
}
// Stop logging the test
DH_TRACE((DH_LVL_TRACE1, TEXT("Test variation STGTEST_108 finished")) );
DH_TRACE((DH_LVL_TRACE1, TEXT("--------------------------------------------")) );
return hr;
}
//----------------------------------------------------------------------------
//
// Test: STGTEST_109
//
// Synopsis: A root docfile is created with a child storage. Check StgSetTimes
// API work as expected to set times on root Storage and IStorage::
// SetElementTimes on child storage. Verify by stat'ng on Storages
// and comparing stat'd times. Then attempt setting times with NULL
// time parameters. Verify that earlier time set on storage remain
// untouched. Attempt illegitmate ops on the API.
//
// Arguments:[argc]
// [argv]
//
// Returns: HRESULT
//
// Notes: This test runs in direct, transacted, and transacted deny write
// modes
//
// History: 15-Aug-1996 NarindK Created.
//
// New Test Notes:
// 1. Old File: A part of OLECMN.CXX
// 2. Old name of test : TestStgSetTime
// New Name of test : STGTEST_109
// 3. To run the test, do the following at command prompt.
// a. stgbase /seed:0 /dfdepth:0-0 /dfstg:0-0 /dfstm:0-0 /t:STGTEST-109
// /dfRootMode:dirReadWriteShEx /dfStgMode:dirReadWriteShEx
// b. stgbase /seed:0 /dfdepth:0-0 /dfstg:0-0 /dfstm:0-0 /t:STGTEST-109
// /dfRootMode:xactReadWriteShEx /dfStgMode:xactReadWriteShEx
// c. stgbase /seed:0 /dfdepth:0-0 /dfstg:0-0 /dfstm:0-0 /t:STGTEST-109
// /dfRootMode:xactReadWriteShDenyW /dfStgMode:xactReadWriteShEx
// 4. To run for conversion, NA (add /dfStgType:conversion to each of the above)
// 5. To run for nssfile, NA (add /dfStgType:nssfile to each of the above)
// BUGBUG: -scousens StgSetTimes not supported for nssfiles????
//
// BUGNOTE: Conversion: STGTEST-109
//
//-----------------------------------------------------------------------------
HRESULT STGTEST_109(int argc, char *argv[])
{
HRESULT hr = S_OK;
ChanceDF *pTestChanceDF = NULL;
VirtualDF *pTestVirtualDF = NULL;
VirtualCtrNode *pVirtualDFRoot = NULL;
VirtualCtrNode *pvcnRootNewChildStg = NULL;
LPTSTR pRootNewChildStgName = NULL;
LPOLESTR poszVirtualDFRootName = NULL;
DG_STRING *pdgu = NULL;
DWORD dwRootMode = 0;
DWORD dwStgMode = 0;
BOOL fRet = FALSE;
BOOL fPass = TRUE;
FILETIME cNewRootStgFileTime = {dwDefLowDateTime,
dwDefHighDateTime};
FILETIME cNewChildStgFileTime = {dwDefLowDateTime,
dwDefHighDateTime};
SYSTEMTIME cCurrentSystemTime;
STATSTG statStg;
STATSTG statStgChild;
DH_FUNCENTRY(NULL, DH_LVL_DFLIB, _TEXT("STGTEST_109"));
DH_TRACE((DH_LVL_TRACE1, TEXT("--------------------------------------------")) );
DH_TRACE((DH_LVL_TRACE1, TEXT("Test variation STGTEST_109 started.")) );
DH_TRACE((
DH_LVL_TRACE1,
TEXT("Attempt legit/illegit tests on StgSetTimes API")));
// Create our ChanceDF and VirtualDF
hr = CreateTestDocfile (argc,
argv,
&pVirtualDFRoot,
&pTestVirtualDF,
&pTestChanceDF);
// if creating the docfile - bail here
if (NULL != pTestChanceDF && DoingCreate ())
{
UINT ulSeed = pTestChanceDF->GetSeed ();
CleanupTestDocfile (&pVirtualDFRoot,
&pTestVirtualDF,
&pTestChanceDF,
FALSE);
return (HRESULT)ulSeed;
}
if (S_OK == hr)
{
dwRootMode = pTestChanceDF->GetRootMode();
dwStgMode = pTestChanceDF->GetStgMode();
DH_TRACE((
DH_LVL_TRACE1,
TEXT("Run Mode for STGTEST_109, Access mode: %lx"),
dwRootMode));
}
// Get DG_STRING object pointer
if (S_OK == hr)
{
pdgu = pTestVirtualDF->GetDataGenUnicode();
DH_ASSERT(NULL != pdgu) ;
}
// Adds a new storage to the root storage.
if(S_OK == hr)
{
// Generate random name for storage
hr = GenerateRandomName(pdgu,MINLENGTH,MAXLENGTH,&pRootNewChildStgName);
DH_HRCHECK(hr, TEXT("GenerateRandomName")) ;
}
if(S_OK == hr)
{
hr = AddStorage(
pTestVirtualDF,
pVirtualDFRoot,
pRootNewChildStgName,
dwStgMode,
&pvcnRootNewChildStg);
DH_HRCHECK(hr, TEXT("AddStorage")) ;
if(S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("AddStorage completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("AddStorage not successful, hr=0x%lx."),
hr));
}
}
// Commit the root
if (S_OK == hr)
{
hr = pVirtualDFRoot->Commit(STGC_DEFAULT);
DH_HRCHECK(hr, TEXT("VirtualCtrNode::Commit"));
if (S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Commit completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Commit unsuccessful, hr=0x%lx."),
hr));
}
}
// StgSetTimes on Root stg
if(S_OK == hr)
{
// Convert test name to OLECHAR
hr = TStringToOleString(
pVirtualDFRoot->GetVirtualCtrNodeName(),
&poszVirtualDFRootName);
DH_HRCHECK(hr, TEXT("TStringToOleString")) ;
}
if(S_OK == hr)
{
GetSystemTime(&cCurrentSystemTime);
fRet = SystemTimeToFileTime(&cCurrentSystemTime, &cNewRootStgFileTime);
DH_ASSERT(TRUE == fRet);
DH_ASSERT(dwDefLowDateTime != cNewRootStgFileTime.dwLowDateTime);
DH_ASSERT(dwDefHighDateTime != cNewRootStgFileTime.dwHighDateTime);
hr = StgSetTimes(
poszVirtualDFRootName,
&cNewRootStgFileTime,
&cNewRootStgFileTime,
&cNewRootStgFileTime);
DH_HRCHECK(hr, TEXT("StgSetTimes")) ;
if(S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("StgSetTimes API passed as exp.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("StgSetTimes API failed unexp, hr = 0x%lx."),
hr));
}
}
// Now stat on root storage to see times are set correctly.
if (S_OK == hr)
{
hr = pVirtualDFRoot->Stat(&statStg, STATFLAG_NONAME);
DH_HRCHECK(hr, TEXT("VirtualCtrNode::Stat")) ;
if (S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Stat completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Stat unsuccessful, hr=0x%lx."),
hr));
}
}
// Compare times from STATSTG structure. FAT doesn't have enough
// resolution, so we would retrict to comapring dwHighDateTime part only
// for mtime and ctime.
if(S_OK == hr)
{
if(cNewRootStgFileTime.dwHighDateTime == statStg.mtime.dwHighDateTime)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("Root DocFile mtime set as expected.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("Root DocFile mtime didn't set unexpectedly.")));
fPass = FALSE;
}
if(cNewRootStgFileTime.dwHighDateTime == statStg.ctime.dwHighDateTime)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("Root DocFile ctime set as expected.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("Root DocFile ctime didn't set unexpectedly.")));
fPass = FALSE;
}
}
// Release child storage
if (S_OK == hr)
{
hr = pvcnRootNewChildStg->Close();
if (S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Close completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Close unsuccessful, hr=0x%lx."),
hr));
}
}
// SetElementTimes on Child Storage
if(S_OK == hr)
{
GetSystemTime(&cCurrentSystemTime);
fRet = SystemTimeToFileTime(&cCurrentSystemTime, &cNewChildStgFileTime);
DH_ASSERT(TRUE == fRet);
DH_ASSERT(dwDefLowDateTime != cNewChildStgFileTime.dwLowDateTime);
DH_ASSERT(dwDefHighDateTime != cNewChildStgFileTime.dwHighDateTime);
hr = pvcnRootNewChildStg->SetElementTimes(
&cNewChildStgFileTime,
&cNewChildStgFileTime,
&cNewChildStgFileTime);
DH_HRCHECK(hr, TEXT("VirtualCtrNode::SetElementTimes")) ;
if(S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::SetElementTimes passed as exp.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::SetElementTimes failed unexp, hr = 0x%lx."),
hr));
}
}
// Now open and stat on child storage to see times are set correctly.
// Open child storage
if (S_OK == hr)
{
hr = pvcnRootNewChildStg->Open(NULL, dwStgMode, NULL, 0);
if (S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Open completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Open unsuccessful, hr=0x%lx."),
hr));
}
}
// Stat on child storage
if (S_OK == hr)
{
hr = pvcnRootNewChildStg->Stat(&statStgChild, STATFLAG_NONAME);
DH_HRCHECK(hr, TEXT("VirtualCtrNode::Stat")) ;
if (S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Stat completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Stat unsuccessful, hr=0x%lx."),
hr));
}
}
// Compare times from STATSTG structure. FAT doesn't have enough
// resolution, so we would retrict to comapring dwHighDateTime part only
// for mtime and ctime.
if(S_OK == hr)
{
if(cNewChildStgFileTime.dwHighDateTime ==
statStgChild.mtime.dwHighDateTime)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("Child Stg mtime set as expected.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("Child stg mtime didn't set unexpectedly.")));
fPass = FALSE;
}
if(cNewChildStgFileTime.dwHighDateTime ==
statStgChild.ctime.dwHighDateTime)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("Child stg ctime set as expected.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("Child Stg ctime didn't set unexpectedly.")));
fPass = FALSE;
}
}
// Release child storage
if (S_OK == hr)
{
hr = pvcnRootNewChildStg->Close();
}
if (S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Close completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Close unsuccessful, hr=0x%lx."),
hr));
}
// StgSetTimes on Root stg with all NULL time elements. Verify that the
// time doesn't change,
if(S_OK == hr)
{
hr = StgSetTimes(
poszVirtualDFRootName,
NULL,
NULL,
NULL);
DH_HRCHECK(hr, TEXT("StgSetTimes with NULL time parameters")) ;
if(S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("StgSetTimes API with NULL time param passed as exp.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("StgSetTimes API with NULL time param fail unexp, hr=0x%lx"),
hr));
}
}
// Now stat on root storage to seeearlier times have remain untouched.
if (S_OK == hr)
{
hr = pVirtualDFRoot->Stat(&statStg, STATFLAG_NONAME);
DH_HRCHECK(hr, TEXT("VirtualCtrNode::Stat")) ;
if (S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Stat completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Stat unsuccessful, hr=0x%lx."),
hr));
}
}
// Compare times from STATSTG structure. FAT doesn't have enough
// resolution, so we would retrict to comapring dwHighDateTime part only
// for mtime and ctime.
if(S_OK == hr)
{
if(cNewRootStgFileTime.dwHighDateTime == statStg.mtime.dwHighDateTime)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("Root DocFile mtime unchanged as expected.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("Root DocFile mtime changed unexpectedly.")));
fPass = FALSE;
}
if(cNewRootStgFileTime.dwHighDateTime == statStg.ctime.dwHighDateTime)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("Root DocFile ctime unchanged as expected.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("Root DocFile ctime changed unexpectedly.")));
fPass = FALSE;
}
}
// SetElementTimes on Child Storage with all NULL times. Verify that
// the times remain unchanged.
if(S_OK == hr)
{
hr = pvcnRootNewChildStg->SetElementTimes(NULL,NULL,NULL);
DH_HRCHECK(hr, TEXT("VirtualCtrNode::SetElementTimes")) ;
if(S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VCN::SetElementTimes with NULL times passed as exp.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VCN:SetElementTimes with NULL times failed unexp,hr=0x%lx"),
hr));
}
}
// Now open and stat on child storage to see times are set correctly.
// Open child storage
if (S_OK == hr)
{
hr = pvcnRootNewChildStg->Open(NULL, dwStgMode, NULL, 0);
if (S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Open completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Open unsuccessful, hr=0x%lx."),
hr));
}
}
// Stat on child storage
if (S_OK == hr)
{
hr = pvcnRootNewChildStg->Stat(&statStgChild, STATFLAG_NONAME);
DH_HRCHECK(hr, TEXT("VirtualCtrNode::Stat")) ;
if (S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Stat completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Stat unsuccessful, hr=0x%lx."),
hr));
}
}
// Compare times from STATSTG structure. FAT doesn't have enough
// resolution, so we would retrict to comapring dwHighDateTime part only
// for mtime and ctime.
if(S_OK == hr)
{
if(cNewChildStgFileTime.dwHighDateTime ==
statStgChild.mtime.dwHighDateTime)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("Child Stg mtime unchanged as expected.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("Child stg mtime changed unexpectedly.")));
fPass = FALSE;
}
if(cNewChildStgFileTime.dwHighDateTime ==
statStgChild.ctime.dwHighDateTime)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("Child stg ctime unchanged as expected.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("Child Stg ctime changed unexpectedly.")));
fPass = FALSE;
}
}
// Release child storage
if (S_OK == hr)
{
hr = pvcnRootNewChildStg->Close();
if (S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Close completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Close unsuccessful, hr=0x%lx."),
hr));
}
}
// Attempt calling StgSetTimes with NULL name.
if(S_OK == hr)
{
GetSystemTime(&cCurrentSystemTime);
fRet = SystemTimeToFileTime(&cCurrentSystemTime, &cNewRootStgFileTime);
DH_ASSERT(TRUE == fRet);
DH_ASSERT(dwDefLowDateTime != cNewRootStgFileTime.dwLowDateTime);
DH_ASSERT(dwDefHighDateTime != cNewRootStgFileTime.dwHighDateTime);
hr = StgSetTimes(
NULL,
&cNewRootStgFileTime,
&cNewRootStgFileTime,
&cNewRootStgFileTime);
DH_HRCHECK(hr, TEXT("StgSetTimes")) ;
if(STG_E_INVALIDNAME == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("StgSetTimes API with NULL name failed as exp, hr = 0x%lx."),
hr));
hr = S_OK;
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("StgSetTimes with NULL name didn't fail as exp, hr=0x%lx"),
hr));
}
}
// Release root
if (S_OK == hr)
{
hr = pVirtualDFRoot->Close();
if (S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Close completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Close unsuccessful, hr=0x%lx."),
hr));
}
}
// if everything goes well, log test as passed else failed.
if ((S_OK == hr) && (TRUE == fPass))
{
DH_LOG((LOG_PASS, TEXT("Test variation STGTEST_109 passed.")) );
}
else
{
DH_LOG((LOG_FAIL,
TEXT("Test variation STGTEST_109 failed, hr = 0x%lx."),
hr) );
// test failed. make sure it failed.
hr = FirstError (hr, E_FAIL);
}
// Cleanup
CleanupTestDocfile (&pVirtualDFRoot,
&pTestVirtualDF,
&pTestChanceDF,
S_OK == hr);
// Delete temp strings
if (NULL != poszVirtualDFRootName)
{
delete poszVirtualDFRootName;
poszVirtualDFRootName = NULL;
}
if (NULL != pRootNewChildStgName)
{
delete pRootNewChildStgName;
pRootNewChildStgName = NULL;
}
// Stop logging the test
DH_TRACE((DH_LVL_TRACE1, TEXT("Test variation STGTEST_109 finished")) );
DH_TRACE((DH_LVL_TRACE1, TEXT("--------------------------------------------")) );
return hr;
}
//----------------------------------------------------------------------------
//
// Test: STGTEST_110
//
// Synopsis: A root docfile is created, then add a random number of streams
// under the root storage, make sure the last stream's size is
// less than 4K(ministream), then commit and release the docfile.
//
// Arguments:[argc]
// [argv]
//
// Returns: HRESULT
//
// Notes: This test runs in direct, transacted, and transacted deny write
// modes
//
// History: 29-Oct-1996 JiminLi Created.
//
// Notes:
// To run the test, do the following at command prompt.
// a. stgbase /seed:0 /dfdepth:0-0 /dfstg:0-0 /dfstm:0-0 /t:STGTEST-110
// /dfRootMode:dirReadWriteShEx /dfStgMode:dirReadWriteShEx
// b. stgbase /seed:0 /dfdepth:0-0 /dfstg:0-0 /dfstm:0-0 /t:STGTEST-110
// /dfRootMode:xactReadWriteShEx /dfStgMode:xactReadWriteShEx
// c. stgbase /seed:0 /dfdepth:0-0 /dfstg:0-0 /dfstm:0-0 /t:STGTEST-110
// /dfRootMode:xactReadWriteShDenyW /dfStgMode:xactReadWriteShEx
// 4. To run for conversion, add /dfStgType:conversion to each of the above
// 5. To run for nssfile, add /dfStgType:nssfile to each of the above
//
// BUGNOTE: Conversion: STGTEST-110
//
//-----------------------------------------------------------------------------
HRESULT STGTEST_110(int argc, char *argv[])
{
HRESULT hr = S_OK;
ChanceDF *pTestChanceDF = NULL;
VirtualDF *pTestVirtualDF = NULL;
VirtualCtrNode *pVirtualDFRoot = NULL;
VirtualStmNode **pvsnRootNewChildStream = NULL;
LPTSTR *pRootNewChildStmName = NULL;
ULONG culBytesWrite = 0;
DG_INTEGER *pdgi = NULL;
LPTSTR ptcsBuffer = NULL;
DG_STRING *pdgu = NULL;
DWORD dwRootMode = 0;
ULONG ulIndex = 0;
ULONG ulStmNum = 0;
ULONG ulMinStm = 2;
ULONG ulMaxStm = 5;
ULONG culWritten = 0;
USHORT usErr = 0;
DH_FUNCENTRY(NULL, DH_LVL_DFLIB, _TEXT("STGTEST_110"));
DH_TRACE((DH_LVL_TRACE1, TEXT("--------------------------------------------")) );
DH_TRACE((DH_LVL_TRACE1, TEXT("Test variation STGTEST_110 started.")) );
DH_TRACE((
DH_LVL_TRACE1,
TEXT("Test on adding a ministream into the root storage")));
// Create our ChanceDF and VirtualDF
hr = CreateTestDocfile (argc,
argv,
&pVirtualDFRoot,
&pTestVirtualDF,
&pTestChanceDF);
// if creating the docfile - bail here
if (NULL != pTestChanceDF && DoingCreate ())
{
UINT ulSeed = pTestChanceDF->GetSeed ();
CleanupTestDocfile (&pVirtualDFRoot,
&pTestVirtualDF,
&pTestChanceDF,
FALSE);
return (HRESULT)ulSeed;
}
if (S_OK == hr)
{
dwRootMode = pTestChanceDF->GetRootMode();
DH_TRACE((
DH_LVL_TRACE1,
TEXT("Run Mode for STGTEST_110, Access mode: %lx"),
dwRootMode));
}
// Get DG_UNICODE object pointer
if (S_OK == hr)
{
pdgu = pTestVirtualDF->GetDataGenUnicode();
DH_ASSERT(NULL != pdgu) ;
}
// Get DG_INTEGER object pointer
if (S_OK == hr)
{
pdgi = pTestVirtualDF->GetDataGenInteger();
DH_ASSERT(NULL != pdgi) ;
}
// Generate the number of streams to create
if (S_OK == hr)
{
usErr = pdgi->Generate(&ulStmNum, ulMinStm, ulMaxStm);
if (DG_RC_SUCCESS != usErr)
{
hr = E_FAIL;
}
}
// Initialization
if (S_OK == hr)
{
pvsnRootNewChildStream = new VirtualStmNode*[ulStmNum];
pRootNewChildStmName = new LPTSTR[ulStmNum];
if ((NULL == pvsnRootNewChildStream) || (NULL == pRootNewChildStmName))
{
hr = E_OUTOFMEMORY;
}
}
if (S_OK == hr)
{
for (ulIndex = 0; ulIndex < ulStmNum; ulIndex++)
{
pvsnRootNewChildStream[ulIndex] = NULL;
pRootNewChildStmName[ulIndex] = NULL;
}
}
// Create ulStmNum streams under the root storage
for (ulIndex = 0; ulIndex < ulStmNum; ulIndex++)
{
if (S_OK == hr)
{
// Generate random name for stream
hr = GenerateRandomName(
pdgu,
MINLENGTH,
MAXLENGTH,
&pRootNewChildStmName[ulIndex]);
DH_HRCHECK(hr, TEXT("GenerateRandomName")) ;
}
if (S_OK == hr)
{
hr = AddStream(
pTestVirtualDF,
pVirtualDFRoot,
pRootNewChildStmName[ulIndex],
0,
STGM_READWRITE | STGM_SHARE_EXCLUSIVE,
&pvsnRootNewChildStream[ulIndex]);
DH_HRCHECK(hr, TEXT("AddStream")) ;
if(S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualStmNode::AddStream completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualStmNode::AddStream not successful, hr = 0x%lx"),
hr));
}
}
if (S_OK == hr)
{
// Generate random size for stream between MIN_STMSIZE and
// MAX_STMSIZE if it's not the last stream, otherwise generate a
// size between 0 and MAXSIZEOFMINISTM(4k).
if (ulStmNum-1 == ulIndex)
{
usErr = pdgi->Generate(&culBytesWrite,0L,MAXSIZEOFMINISTM);
}
else
{
usErr = pdgi->Generate(&culBytesWrite,MIN_STMSIZE,MAX_STMSIZE);
}
if (DG_RC_SUCCESS != usErr)
{
hr = E_FAIL;
}
}
if (S_OK == hr)
{
// Generate a random string of size culBytesWrite
hr = GenerateRandomString(
pdgu,
culBytesWrite,
culBytesWrite,
&ptcsBuffer);
DH_HRCHECK(hr, TEXT("GenerateRandomString")) ;
}
if (S_OK == hr)
{
hr = pvsnRootNewChildStream[ulIndex]->Write(
ptcsBuffer,
culBytesWrite,
&culWritten);
if (S_OK != hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualStmNode::Write not successful, hr=0x%lx."),
hr));
}
}
// Delete the temp buffer
if (NULL != ptcsBuffer)
{
delete ptcsBuffer;
ptcsBuffer = NULL;
}
}
// Commit the root
if (S_OK == hr)
{
hr = pVirtualDFRoot->Commit(STGC_DEFAULT);
DH_HRCHECK(hr, TEXT("VirtualCtrNode::Commit"));
if (S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Commit completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Commit unsuccessful, hr=0x%lx."),
hr));
}
}
// Release root
if (S_OK == hr)
{
hr = pVirtualDFRoot->Close();
if (S_OK == hr)
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Close completed successfully.")));
}
else
{
DH_TRACE((
DH_LVL_TRACE1,
TEXT("VirtualCtrNode::Close unsuccessful, hr=0x%lx."),
hr));
}
}
// if everything goes well, log test as passed else failed.
if (S_OK == hr)
{
DH_LOG((LOG_PASS, TEXT("Test variation STGTEST_110 passed.")) );
}
else
{
DH_LOG((LOG_FAIL,
TEXT("Test variation STGTEST_110 failed, hr = 0x%lx."),
hr) );
}
// Cleanup
CleanupTestDocfile (&pVirtualDFRoot,
&pTestVirtualDF,
&pTestChanceDF,
S_OK == hr);
// Delete temp strings
if (NULL != pvsnRootNewChildStream)
{
delete []pvsnRootNewChildStream;
pvsnRootNewChildStream = NULL;
}
for (ulIndex = 0; ulIndex < ulStmNum; ulIndex++)
{
if (NULL != pRootNewChildStmName[ulIndex])
{
delete pRootNewChildStmName[ulIndex];
pRootNewChildStmName[ulIndex] = NULL;
}
}
if (NULL != pRootNewChildStmName)
{
delete pRootNewChildStmName;
pRootNewChildStmName = NULL;
}
// Stop logging the test
DH_TRACE((DH_LVL_TRACE1, TEXT("Test variation STGTEST_110 finished")) );
DH_TRACE((DH_LVL_TRACE1, TEXT("--------------------------------------------")) );
return hr;
}