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.
535 lines
17 KiB
535 lines
17 KiB
//-------------------------------------------------------------------------
|
|
//
|
|
// Microsoft OLE
|
|
// Copyright (C) Microsoft Corporation, 1994 - 1995.
|
|
//
|
|
// File: init.cxx
|
|
//
|
|
// Contents: OLE storage base tests
|
|
//
|
|
// Functions: main
|
|
//
|
|
// History: 26-Feb-1997 SCousens Created.
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
#include <dfheader.hxx>
|
|
#pragma hdrstop
|
|
|
|
#include <init.hxx>
|
|
|
|
HRESULT MakeVirtualDF (UINT uOp, ChanceDF *pTestChanceDF, VirtualCtrNode **ppvcnRoot, VirtualDF **ppTestVirtualDF);
|
|
|
|
// Global:
|
|
// For stress debug purposes. So we can get to the seed from
|
|
// within the debugger
|
|
// do not use gulSeed for anything else!
|
|
ULONG gulSeed=0;
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
// FUNCTION: CreateTestDocfile [multiple]
|
|
//
|
|
// PARAMS: argc - # params on commandline
|
|
// argv - array of pointers to commandline
|
|
// ppVirtualDFRoot - bucket for RootCtrNode
|
|
// ppTestVirtualDF - bucket for pVirtualDF
|
|
// ppTestChanceDF - bucket for pChanceDF
|
|
//
|
|
// SYNOPSIS: Determine whether we are creating a DF, or
|
|
// opening and existing one.
|
|
// Creating
|
|
// Create a ChanceDF of random nodes,
|
|
// Create the VirtualDF from this (GenerateVirtualDF)
|
|
// Commit and close the resulting docfile
|
|
// Opening
|
|
// Figure the name, open it (GenerateVirtualDFFromDiskDF)
|
|
// Also need to set _pgdu, _pgdi
|
|
//
|
|
// RETURN: hr. S_OK or whatever failure was encountered.
|
|
//
|
|
// NOTES: All stms and Stgs of the docfile will have been commited
|
|
// and and saved, but all will be open before returning
|
|
// The name of the file will be the first string generated
|
|
// after creating the DataGen for strings. Its the way it
|
|
// works, we can use this knowledge to our advantage (until
|
|
// someone changes that behaviour and breaks us)
|
|
//
|
|
// HISTORY: 28-Feb-1997 SCousens Created.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
HRESULT CreateTestDocfile (
|
|
int argc,
|
|
char **argv,
|
|
VirtualCtrNode **ppvcnRoot,
|
|
VirtualDF **ppTestVirtualDF,
|
|
ChanceDF **ppTestChanceDF)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
ChanceDF *pChanceDF = NULL;
|
|
|
|
DH_FUNCENTRY(&hr, DH_LVL_DFLIB, _TEXT("CreateTestDocfile"));
|
|
DH_VDATEPTROUT (ppvcnRoot, VirtualCtrNode *);
|
|
DH_VDATEPTROUT (ppTestVirtualDF, VirtualDF *);
|
|
|
|
*ppvcnRoot = NULL;
|
|
*ppTestVirtualDF = NULL;
|
|
if (NULL != ppTestChanceDF)
|
|
{
|
|
DH_VDATEPTROUT (ppTestChanceDF, ChanceDF *);
|
|
*ppTestChanceDF = NULL;
|
|
}
|
|
|
|
// Always create this. There is lots of juicy info that
|
|
// we will need either way.
|
|
// Create the new ChanceDocFile tree that would consist of chance nodes.
|
|
if (S_OK == hr)
|
|
{
|
|
pChanceDF = new ChanceDF();
|
|
if(NULL == pChanceDF)
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
}
|
|
|
|
if (S_OK == hr)
|
|
{
|
|
hr = pChanceDF->CreateFromParams (argc, argv);
|
|
DH_HRCHECK(hr, TEXT("pChanceDF->CreateFromParams")) ;
|
|
}
|
|
|
|
// Make VirtualDF
|
|
if (S_OK == hr)
|
|
{
|
|
hr = MakeVirtualDF (pChanceDF->GetOpenCreateDF (),
|
|
pChanceDF,
|
|
ppvcnRoot,
|
|
ppTestVirtualDF);
|
|
}
|
|
|
|
// If the caller wants ChanceDF give it to them, otherwise delete it
|
|
if (NULL == ppTestChanceDF)
|
|
{
|
|
delete pChanceDF;
|
|
}
|
|
else
|
|
{
|
|
*ppTestChanceDF = pChanceDF;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
//
|
|
// FUNCTION: CreateTestDocfile [multiple]
|
|
//
|
|
// PARAMS: pcdfd - CDFD for chancedf
|
|
// pFileName - name of docfile
|
|
// ulSeed - seed (to get name)
|
|
// ppVirtualDFRoot - bucket for RootCtrNode
|
|
// ppTestVirtualDF - bucket for pVirtualDF
|
|
// ppTestChanceDF - bucket for pChanceDF
|
|
//
|
|
// SYNOPSIS: See above
|
|
//
|
|
// RETURN: hr. S_OK or whatever failure was encountered.
|
|
//
|
|
// NOTES: See description above
|
|
//
|
|
// HISTORY: 19-Mar-1997 SCousens Created.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
HRESULT CreateTestDocfile (
|
|
CDFD *pcdfd,
|
|
LPTSTR pFileName,
|
|
VirtualCtrNode **ppvcnRoot,
|
|
VirtualDF **ppTestVirtualDF,
|
|
ChanceDF **ppTestChanceDF)
|
|
{
|
|
|
|
HRESULT hr = S_OK;
|
|
ChanceDF *pChanceDF = NULL;
|
|
LPTSTR pDocFileName = NULL;
|
|
|
|
DH_FUNCENTRY(&hr, DH_LVL_DFLIB, _TEXT("CreateTestDocfile"));
|
|
DH_VDATEPTRIN (pcdfd, CDFD);
|
|
DH_VDATEPTROUT (ppvcnRoot, VirtualCtrNode *);
|
|
DH_VDATEPTROUT (ppTestVirtualDF, VirtualDF *);
|
|
|
|
*ppvcnRoot = NULL;
|
|
*ppTestVirtualDF = NULL;
|
|
if (NULL != ppTestChanceDF)
|
|
{
|
|
DH_VDATEPTROUT (ppTestChanceDF, ChanceDF *);
|
|
*ppTestChanceDF = NULL;
|
|
}
|
|
|
|
// If dont have a filename, make one
|
|
if (NULL == pFileName)
|
|
{
|
|
DG_STRING *pdgu = NULL;
|
|
if (S_OK == hr)
|
|
{
|
|
// Create a new DataGen object to create random UNICODE strings.
|
|
pdgu = new DG_STRING (pcdfd->ulSeed);
|
|
if (NULL == pdgu)
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
}
|
|
|
|
if (S_OK == hr)
|
|
{
|
|
// Generate random name for root
|
|
hr = GenerateRandomName(
|
|
pdgu,
|
|
MINLENGTH,
|
|
MAXLENGTH,
|
|
&pDocFileName);
|
|
DH_HRCHECK(hr, TEXT("GenerateRandomName")) ;
|
|
}
|
|
delete pdgu;
|
|
}
|
|
|
|
// Always create this.
|
|
// Create the new ChanceDocFile tree that would consist of chance nodes.
|
|
if (S_OK == hr)
|
|
{
|
|
pChanceDF = new ChanceDF();
|
|
if(NULL == pChanceDF)
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
}
|
|
|
|
if (S_OK == hr)
|
|
{
|
|
hr = pChanceDF->Create (
|
|
pcdfd,
|
|
NULL == pFileName ? pFileName : pDocFileName);
|
|
DH_HRCHECK(hr, TEXT("pChanceDF->Create")) ;
|
|
}
|
|
|
|
// Make VirtualDF
|
|
if (S_OK == hr)
|
|
{
|
|
hr = MakeVirtualDF (g_uOpenCreateDF, //Global set in ProcessCmdLine()
|
|
pChanceDF,
|
|
ppvcnRoot,
|
|
ppTestVirtualDF);
|
|
}
|
|
|
|
// cleanup
|
|
if (NULL != pDocFileName)
|
|
{
|
|
delete []pDocFileName;
|
|
}
|
|
|
|
// If the caller wants ChanceDF give it to them, otherwise delete it
|
|
if (NULL == ppTestChanceDF)
|
|
{
|
|
delete pChanceDF;
|
|
}
|
|
else
|
|
{
|
|
*ppTestChanceDF = pChanceDF;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
// FUNCTION: MakeVirtualDF
|
|
//
|
|
// PARAMS: uOp - Create|Open flag (FL_DISTRIB_xxx)
|
|
// pTestChanceDF - ptr to pChanceDF
|
|
// ppVirtualDFRoot - bucket for RootCtrNode
|
|
// ppTestVirtualDF - bucket for pVirtualDF
|
|
//
|
|
// SYNOPSIS: This function should be called by
|
|
// CreateTestDocfile
|
|
// If FL_OPEN is set, and cannot open docfile,
|
|
// return ERROR.
|
|
// Otherwise we need to create a storage file
|
|
// as we are either as 1st phase, or single phase.
|
|
//
|
|
// RETURN: hr. S_OK or whatever failure was encountered.
|
|
//
|
|
// HISTORY: 28-Feb-1997 SCousens Created.
|
|
// BUGBUG: GenerateVirtualDFFromDiskDF does not fill in the CRC for vsn.
|
|
// we need to write a rtn that will do this for enumtest 100.
|
|
//----------------------------------------------------------------------------
|
|
HRESULT MakeVirtualDF (
|
|
UINT uOp,
|
|
ChanceDF *pTestChanceDF,
|
|
VirtualCtrNode **ppvcnRoot,
|
|
VirtualDF **ppTestVirtualDF)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
// This is internal func. Shouldnt have to do this.
|
|
DH_ASSERT (NULL != pTestChanceDF);
|
|
DH_ASSERT (NULL != ppvcnRoot);
|
|
DH_ASSERT (NULL != ppTestVirtualDF);
|
|
|
|
DH_FUNCENTRY(&hr, DH_LVL_DFLIB, _TEXT("MakeVirtualDF"));
|
|
|
|
//for stress debug purposes. So we can get to the seed.
|
|
//do not use gulSeed for anything!
|
|
gulSeed = pTestChanceDF->GetSeed ();
|
|
|
|
// If its OPEN, try to open existing.
|
|
if (FL_DISTRIB_OPEN == uOp)
|
|
{
|
|
ULONG ulSeed = 0;
|
|
DG_STRING *pgdu = NULL;
|
|
LPTSTR tszDocfileName = NULL;
|
|
|
|
// Get the seed. We need this to generate the filename.
|
|
ulSeed = pTestChanceDF->GetSeed();
|
|
|
|
// Create a new DataGen object to create the filename
|
|
pgdu = new DG_STRING(ulSeed);
|
|
if (NULL == pgdu)
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
|
|
// if filename was specified, get it from chanceDF
|
|
if (hr == S_OK)
|
|
{
|
|
tszDocfileName = pTestChanceDF->GetDocFileName();
|
|
if (NULL != tszDocfileName)
|
|
{
|
|
LPTSTR pTmpName = tszDocfileName;
|
|
tszDocfileName = new TCHAR[_tcslen (pTmpName)+1];
|
|
if (NULL == tszDocfileName)
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
else
|
|
{
|
|
_tcscpy(tszDocfileName, pTmpName);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// this will generate the name of the file that was created
|
|
hr = GenerateRandomName (pgdu, MINLENGTH, MAXLENGTH, &tszDocfileName);
|
|
DH_HRCHECK (hr, TEXT("GenerateRandomName"));
|
|
}
|
|
}
|
|
|
|
if (S_OK == hr)
|
|
{
|
|
*ppTestVirtualDF = new VirtualDF();
|
|
if (NULL == *ppTestVirtualDF)
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
}
|
|
|
|
if (hr == S_OK)
|
|
{
|
|
// Remove create bit - open does not like it.
|
|
hr = GenerateVirtualDFFromDiskDF(
|
|
*ppTestVirtualDF,
|
|
tszDocfileName,
|
|
pTestChanceDF->GetRootMode() & ~STGM_CREATE,
|
|
ppvcnRoot,
|
|
ulSeed);
|
|
DH_HRCHECK (hr, TEXT("GenerateVirtualDFFromDiskDF"));
|
|
}
|
|
|
|
// make sure ALL sub stg/stm are open and have valid _pstg
|
|
if (hr == S_OK)
|
|
{
|
|
hr = ParseVirtualDFAndOpenAllSubStgsStms (
|
|
*ppvcnRoot,
|
|
pTestChanceDF->GetStgMode (),
|
|
pTestChanceDF->GetStmMode ());
|
|
DH_HRCHECK (hr, TEXT("ParseVirtualDFAndOpenAllSubStgsStms"));
|
|
}
|
|
|
|
if (NULL != tszDocfileName)
|
|
{
|
|
delete tszDocfileName;
|
|
}
|
|
|
|
if (NULL != pgdu)
|
|
{
|
|
delete pgdu;
|
|
}
|
|
}
|
|
// else !open, so create one.
|
|
else
|
|
{
|
|
// Create the VirtualDocFile tree from the ChanceDocFile tree created in
|
|
// the previous step. The VirtualDocFile tree consists of VirtualCtrNodes
|
|
// and VirtualStmNodes.
|
|
if (S_OK == hr)
|
|
{
|
|
*ppTestVirtualDF = new VirtualDF();
|
|
if (NULL == *ppTestVirtualDF)
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
}
|
|
|
|
if (S_OK == hr)
|
|
{
|
|
hr = (*ppTestVirtualDF)->GenerateVirtualDF (pTestChanceDF, ppvcnRoot);
|
|
DH_HRCHECK(hr, TEXT("pTestVirtualDF->GenerateVirtualDF")) ;
|
|
}
|
|
|
|
// Commit all stms and stgs in newly created storage file
|
|
if (S_OK == hr)
|
|
{
|
|
hr = ParseVirtualDFAndCommitAllOpenStgs (*ppvcnRoot, STGC_DEFAULT, NODE_INC_TOPSTG);
|
|
DH_HRCHECK(hr, TEXT("ParseVirtualDFAndCommitAllOpenStgs")) ;
|
|
}
|
|
|
|
// If we are testing conversion, close and reopen the file.
|
|
// BUGBUG: If we are distributed and happen to have the
|
|
// cmdline for conversion, you will do an extra open and
|
|
// close. DIF files may get an unacceptible time penalty.
|
|
if (DoingConversion())
|
|
{
|
|
// close the file
|
|
if (S_OK == hr)
|
|
{
|
|
hr = ParseVirtualDFAndCloseOpenStgsStms (*ppvcnRoot, NODE_INC_TOPSTG);
|
|
DH_HRCHECK(hr, TEXT("ParseVirtualDFAndCloseOpenStgsStms")) ;
|
|
}
|
|
// just for fun, verify that we indeed have an nssfile
|
|
// Assume there is a file name, else we failed somewhere
|
|
// creating it and hr should != S_OK
|
|
if (S_OK == hr)
|
|
{
|
|
hr = VerifyNssfile ((*ppTestVirtualDF)->GetDocFileName());
|
|
DH_HRCHECK(hr, TEXT("VerifyNssfile")) ;
|
|
}
|
|
// open root storage
|
|
if (S_OK == hr)
|
|
{
|
|
// if in SIMPLEMODE, get rid of Create.
|
|
ULONG mode = pTestChanceDF->GetRootMode ();
|
|
if (mode & STGM_SIMPLE)
|
|
{
|
|
mode &= ~STGM_CREATE;
|
|
}
|
|
|
|
hr = (*ppvcnRoot)->OpenRoot (NULL,
|
|
mode,
|
|
NULL,
|
|
0);
|
|
DH_HRCHECK(hr, TEXT("StgOpenStorage"));
|
|
}
|
|
// open up the rest of storages and streams
|
|
if (S_OK == hr)
|
|
{
|
|
hr = ParseVirtualDFAndOpenAllSubStgsStms (*ppvcnRoot,
|
|
pTestChanceDF->GetStgMode (),
|
|
pTestChanceDF->GetStmMode ());
|
|
DH_HRCHECK(hr, TEXT("ParseVirtualDFAndOpenAllSubStgsStms")) ;
|
|
}
|
|
DH_TRACE ((DH_LVL_TRACE2, TEXT("Docfile closed and reopened for conversion")));
|
|
}
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
//
|
|
// FUNCTION: CleanupTestDocfile
|
|
//
|
|
// PARAMS: ppVirtualDFRoot - bucket for RootCtrNode
|
|
// ppTestVirtualDF - bucket for pVirtualDF
|
|
// ppTestChanceDF - bucket for pChanceDF
|
|
// fDeleteFile - If was an error, dont delete docfile
|
|
//
|
|
// SYNOPSIS: Cleanup all items that were setup in CreateTestDocfile
|
|
// - chancedf
|
|
// - virtualdf
|
|
// - delete docfile on disk (if there were no errors)
|
|
//
|
|
// RETURN: hr. S_OK or whatever failure was encountered.
|
|
//
|
|
// HISTORY: 28-Feb-1997 SCousens Created.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
HRESULT CleanupTestDocfile (
|
|
VirtualCtrNode **ppVirtualDFRoot,
|
|
VirtualDF **ppTestVirtualDF,
|
|
ChanceDF **ppTestChanceDF,
|
|
BOOL fDeleteFile)
|
|
{
|
|
LPTSTR pFileName = NULL;
|
|
HRESULT hr = S_OK;
|
|
VirtualCtrNode *pvcnRootNode= *ppVirtualDFRoot;
|
|
VirtualDF *pVirtualDF = *ppTestVirtualDF;
|
|
ChanceDF *pChanceDF = *ppTestChanceDF;
|
|
|
|
DH_FUNCENTRY (NULL, DH_LVL_DFLIB, TEXT("CleanupTestDocfile"));
|
|
|
|
// Make sure everything in the docfile is closed
|
|
if (NULL != pvcnRootNode)
|
|
{
|
|
hr = ParseVirtualDFAndCloseOpenStgsStms (pvcnRootNode, NODE_INC_TOPSTG);
|
|
DH_HRCHECK (hr, TEXT("ParseVirtualDFAndCloseOpenStgsStms")) ;
|
|
}
|
|
|
|
// Get file name
|
|
if (TRUE == fDeleteFile && DeleteTestDF ())
|
|
{
|
|
if (NULL != pvcnRootNode)
|
|
{
|
|
pFileName= new TCHAR[_tcslen (pVirtualDF->GetDocFileName ())+1];
|
|
if (pFileName != NULL)
|
|
{
|
|
_tcscpy (pFileName, pVirtualDF->GetDocFileName ());
|
|
}
|
|
}
|
|
}
|
|
|
|
// Delete Virtual docfile tree
|
|
if (NULL != pVirtualDF)
|
|
{
|
|
hr = pVirtualDF->DeleteVirtualDocFileTree (pvcnRootNode);
|
|
DH_HRCHECK (hr, TEXT("pVirtualDF->DeleteVirtualFileDocTree")) ;
|
|
|
|
delete pVirtualDF;
|
|
pVirtualDF = NULL;
|
|
}
|
|
|
|
// Delete Chance docfile tree
|
|
if (NULL != pChanceDF)
|
|
{
|
|
hr = pChanceDF->DeleteChanceDocFileTree (pChanceDF->GetChanceDFRoot());
|
|
DH_HRCHECK (hr, TEXT("pChanceDF->DeleteChanceFileDocTree")) ;
|
|
|
|
delete pChanceDF;
|
|
pChanceDF = NULL;
|
|
}
|
|
|
|
// Delete the docfile on disk
|
|
if ((S_OK == hr) && (NULL != pFileName))
|
|
{
|
|
if (FALSE == DeleteFile(pFileName))
|
|
{
|
|
hr = HRESULT_FROM_WIN32 (GetLastError()) ;
|
|
DH_HRCHECK (hr, TEXT("DeleteFile")) ;
|
|
}
|
|
}
|
|
|
|
// Delete the docfile name
|
|
if (NULL != pFileName)
|
|
{
|
|
delete pFileName;
|
|
pFileName = NULL;
|
|
}
|
|
|
|
return hr;
|
|
}
|