diff options
Diffstat (limited to 'private/ole32/stg/utils/fail/fail.cxx')
| -rw-r--r-- | private/ole32/stg/utils/fail/fail.cxx | 2666 |
1 files changed, 2666 insertions, 0 deletions
diff --git a/private/ole32/stg/utils/fail/fail.cxx b/private/ole32/stg/utils/fail/fail.cxx new file mode 100644 index 000000000..03505335d --- /dev/null +++ b/private/ole32/stg/utils/fail/fail.cxx @@ -0,0 +1,2666 @@ +//+------------------------------------------------------------------------- +// +// Microsoft Windows +// Copyright (C) Microsoft Corporation, 1992 - 1992. +// +// File: Fail.CXX +// +// Contents: Docfile Failure Test +// +// History: 21-Jan-93 AlexT Created +// +// Notes: This test cycles through all failure points for each call, +// verifying that we clean up correctly. +// +//-------------------------------------------------------------------------- + +#include <headers.cxx> + +#pragma hdrstop + +#include <sift.hxx> + +#if DBG != 1 +#error FAIL.EXE requires DBG == 1 +#endif + +// #define BREADTHTEST // Comment out for depth testing (just most recent tests) + +//+------------------------------------------------------------------------- +// +// Function: VerifyDisk +// +// Synopsis: verify that disk file does or does not exist +// +// Arguments: [fExist] -- TRUE if file should exist, else FALSE +// [iteration] -- iteration number +// +// History: 22-Jan-93 AlexT Created +// +//-------------------------------------------------------------------------- + +void VerifyDisk(BOOL fExist, LONG iteration) +{ + if (_access("c:\\testfail.dfl", 0) == 0) + { + if (!fExist) + { + printf("..Iteration %ld, file still exists\n", iteration); + } + } + else + { + if (fExist) + { + printf("..Iteration %ld, file doesn't exist\n", iteration); + } + } +} + +//+------------------------------------------------------------------------- +// +// Function: VerifyMemory +// +// Arguments: [iteration] -- iteration number +// +// Requires: Caller should expect 0 memory to be allocated +// +// History: 22-Jan-93 AlexT Created +// +//-------------------------------------------------------------------------- + +void VerifyMemory(LONG iteration) +{ + if (DfGetMemAlloced() > 0L) + { + printf("..Iteration %ld - memory allocated\n", iteration); + DfPrintAllocs(); + } +} + +//+------------------------------------------------------------------------- +// +// Function: VerifyClean +// +// Synopsis: checks disk, memory +// +// Arguments: [sc] -- status code +// [dwMode] -- Docfile mode +// [iteration] -- iteration +// +// History: 22-Jan-93 AlexT Created +// +//-------------------------------------------------------------------------- + +void VerifyClean(SCODE sc, DWORD dwMode, LONG iteration) +{ + VerifyDisk(SUCCEEDED(sc) && + !(dwMode & STGM_DELETEONRELEASE), iteration); + VerifyMemory(iteration); +} + +//+------------------------------------------------------------------------- +// +// Function: CreateWorkingDocfile +// +// Synopsis: create and verify the test Docfile +// +// Arguments: [dwMode] -- Docfile creation mode +// [ppstg] -- placeholder for IStorage +// [iteration] -- iteration number +// +// Returns: SCODE +// +// Modifies: ppstg +// +// History: 22-Jan-93 AlexT Created +// +//-------------------------------------------------------------------------- + +SCODE CreateWorkingDocfile(DWORD dwMode, IStorage **ppstg, LONG iteration) +{ + SCODE sc; + + // Make sample call + remove("c:\\testfail.dfl"); + sc = DfGetScode(StgCreateDocfile( + "c:\\testfail.dfl", + dwMode, + 0, + ppstg)); + + if (FAILED(sc)) + { + if (iteration == 0) + { + // This was a prep call. Prep calls aren't supposed to fail + if (sc == STG_E_INVALIDFLAG) + { + // Probably a bad combination of mode flags + printf("..Iteration %ld, sc = STG_E_INVALIDFLAG (OK)\n", + iteration); + } + else if (FAILED(sc)) + { + // Something unexpected + printf("..Iteration %ld failed - sc = 0x%lX\n", + iteration, sc); + } + } + else // iteration != 0 + { + if (sc == STG_E_INSUFFICIENTMEMORY || sc == STG_E_MEDIUMFULL) + { + // we expected these failures; do nothing + ; + } + else + { + printf("..Iteration %ld failed - sc = 0x%lX (??)\n", + iteration, sc); + } + } + } + + return(sc); +} + +//+------------------------------------------------------------------------- +// +// Class: CTestStgCreate +// +// Purpose: Test StgCreateDocfile +// +// Interface: CTestCase +// +// History: 26-Jan-93 AlexT Created +// +// Notes: +// +//-------------------------------------------------------------------------- + +class CTestStgCreate : public CTestCase +{ +private: + SCODE _sc; + CModeDf _mdf; + IStorage *_pstg; + +public: + virtual BOOL Init(void); + virtual SCODE Prep(LONG iteration); + virtual SCODE Call(LONG iteration); + virtual void EndCall(LONG iteration); + virtual void CallVerify(LONG iteration); + virtual void EndPrep(LONG iteration); + virtual void EndVerify(LONG iteration); + virtual BOOL Next(void); +}; + +BOOL CTestStgCreate::Init(void) +{ + printf("SIFT StgCreateDocfile\n"); + _mdf.Init(); + return(TRUE); +} + +SCODE CTestStgCreate::Prep(LONG iteration) +{ + // inherit this? + return(NOERROR); +} + +SCODE CTestStgCreate::Call(LONG iteration) +{ + if (iteration == 0) + printf("Docfile Mode 0x%lX\n", _mdf.GetMode()); + + _sc = CreateWorkingDocfile(_mdf.GetMode(), &_pstg, iteration); + + return(_sc); +} + +void CTestStgCreate::EndCall(LONG iteration) +{ + _pstg->Release(); +} + +void CTestStgCreate::CallVerify(LONG iteration) +{ + VerifyClean(_sc, _mdf.GetMode(), iteration); +} + +void CTestStgCreate::EndPrep(LONG iteration) +{ + // inherit this? +} + +void CTestStgCreate::EndVerify(LONG iteration) +{ + VerifyClean(_sc, _mdf.GetMode(), iteration); +} + +BOOL CTestStgCreate::Next(void) +{ + if (!_mdf.Next()) + return FALSE; + + return(TRUE); +} + +//+------------------------------------------------------------------------- +// +// Class: CTestCreateStorage +// +// Purpose: Test IStorage::CreateStorage +// +// Interface: CTestCase +// +// History: 26-Jan-93 AlexT Created +// +// Notes: +// +//-------------------------------------------------------------------------- + +class CTestCreateStorage : public CTestCase +{ +private: + SCODE _sc; + + CModeDf _mdf; + IStorage *_pstg; + + CModeStg _mstg; + IStorage *_pstgChild; + +public: + virtual BOOL Init(void); + virtual SCODE Prep(LONG iteration); + virtual SCODE Call(LONG iteration); + virtual void EndCall(LONG iteration); + virtual void CallVerify(LONG iteration); + virtual void EndPrep(LONG iteration); + virtual void EndVerify(LONG iteration); + virtual BOOL Next(void); +}; + +BOOL CTestCreateStorage::Init(void) +{ + printf("SIFT IStorage::CreateStorage\n"); + _mdf.Init(); + _mstg.Init(); + return(TRUE); +} + +SCODE CTestCreateStorage::Prep(LONG iteration) +{ + _sc = CreateWorkingDocfile(_mdf.GetMode(), &_pstg, 0); + return(_sc); +} + +SCODE CTestCreateStorage::Call(LONG iteration) +{ + SCODE sc; + + if (iteration == 0) + printf("Docfile Mode 0x%lX, Child Storage Mode 0x%lX\n", + _mdf.GetMode(), _mstg.GetMode()); + + sc = DfGetScode(_pstg->CreateStorage( + "TestFail Storage", + _mstg.GetMode(), + 0, + 0, + &_pstgChild)); + + return(sc); +} + +void CTestCreateStorage::EndCall(LONG iteration) +{ + _pstgChild->Release(); +} + +void CTestCreateStorage::CallVerify(LONG iteration) +{ +} + +void CTestCreateStorage::EndPrep(LONG iteration) +{ + _pstg->Release(); +} + +void CTestCreateStorage::EndVerify(LONG iteration) +{ + VerifyClean(_sc, _mdf.GetMode(), iteration); +} + +BOOL CTestCreateStorage::Next(void) +{ + if (!_mstg.Next()) + { + _mstg.Init(); + if (!_mdf.Next()) + return(FALSE); + } + + return(TRUE); +} + +//+------------------------------------------------------------------------- +// +// Class: CTestCreateStream +// +// Purpose: Test IStorage::CreateStream +// +// Interface: CTestCase +// +// History: 26-Jan-93 AlexT Created +// +// Notes: +// +//-------------------------------------------------------------------------- + +class CTestCreateStream : public CTestCase +{ +private: + SCODE _sc; + + CModeDf _mdf; + IStorage *_pstg; + + CModeStm _mstm; + IStream *_pstmChild; + +public: + virtual BOOL Init(void); + virtual SCODE Prep(LONG iteration); + virtual SCODE Call(LONG iteration); + virtual void EndCall(LONG iteration); + virtual void CallVerify(LONG iteration); + virtual void EndPrep(LONG iteration); + virtual void EndVerify(LONG iteration); + virtual BOOL Next(void); +}; + +BOOL CTestCreateStream::Init(void) +{ + printf("SIFT IStorage::CreateStream\n"); + _mdf.Init(); + _mstm.Init(); + return(TRUE); +} + +SCODE CTestCreateStream::Prep(LONG iteration) +{ + _sc = CreateWorkingDocfile(_mdf.GetMode(), &_pstg, 0); + return(_sc); +} + +SCODE CTestCreateStream::Call(LONG iteration) +{ + SCODE sc; + + if (iteration == 0) + printf("Docfile Mode 0x%lX, Child Stream Mode 0x%lX\n", + _mdf.GetMode(), _mstm.GetMode()); + + sc = DfGetScode(_pstg->CreateStream( + "TestFail Stream", + _mstm.GetMode(), + 0, + 0, + &_pstmChild)); + + return(sc); +} + +void CTestCreateStream::EndCall(LONG iteration) +{ + _pstmChild->Release(); +} + +void CTestCreateStream::CallVerify(LONG iteration) +{ +} + +void CTestCreateStream::EndPrep(LONG iteration) +{ + _pstg->Release(); +} + +void CTestCreateStream::EndVerify(LONG iteration) +{ + VerifyClean(_sc, _mdf.GetMode(), iteration); +} + +BOOL CTestCreateStream::Next(void) +{ + if (!_mstm.Next()) + { + _mstm.Init(); + if (!_mdf.Next()) + return(FALSE); + } + + return(TRUE); +} + +//+------------------------------------------------------------------------- +// +// Class: CTestWrite +// +// Purpose: Test IStream::Write +// +// Interface: CTestCase +// +// History: 26-Jan-93 AlexT Created +// +// Notes: +// +//-------------------------------------------------------------------------- + +class CTestWrite : public CTestCase +{ +private: + SCODE _sc; + + CModeDf _mdf; + IStorage *_pstg; + + CModeStm _mstm; + IStream *_pstmChild; + +public: + virtual BOOL Init(void); + virtual SCODE Prep(LONG iteration); + virtual SCODE Call(LONG iteration); + virtual void EndCall(LONG iteration); + virtual void CallVerify(LONG iteration); + virtual void EndPrep(LONG iteration); + virtual void EndVerify(LONG iteration); + virtual BOOL Next(void); +}; + +BOOL CTestWrite::Init(void) +{ + printf("SIFT IStream::Write\n"); + _mdf.Init(); + _mstm.Init(); + return(TRUE); +} + +SCODE CTestWrite::Prep(LONG iteration) +{ + _sc = CreateWorkingDocfile(_mdf.GetMode(), &_pstg, 0); + if (SUCCEEDED(_sc)) + { + _sc = DfGetScode(_pstg->CreateStream( + "TestFail Stream", + _mstm.GetMode(), + 0, + 0, + &_pstmChild)); + + if (FAILED(_sc)) + _pstg->Release(); + } + return(_sc); +} + +SCODE CTestWrite::Call(LONG iteration) +{ + SCODE sc; + ULONG cb = 1; + char c = 'X'; + ULONG cbWritten; + + if (iteration == 0) + printf("Docfile Mode 0x%lX, Stream Mode 0x%lX, Write %ld bytes\n", + _mdf.GetMode(), _mstm.GetMode(), cb); + + sc = DfGetScode(_pstmChild->Write(&c, cb, &cbWritten)); + + if (FAILED(sc)) + { + if (sc != STG_E_MEDIUMFULL) + printf("..Iteration %ld - failed - sc = 0x%lX\n", + iteration, sc); + } + return(sc); +} + +void CTestWrite::EndCall(LONG iteration) +{ +} + +void CTestWrite::CallVerify(LONG iteration) +{ +} + +void CTestWrite::EndPrep(LONG iteration) +{ + _pstmChild->Release(); + _pstg->Release(); +} + +void CTestWrite::EndVerify(LONG iteration) +{ + VerifyClean(_sc, _mdf.GetMode(), iteration); +} + +BOOL CTestWrite::Next(void) +{ + if (!_mstm.Next()) + { + _mstm.Init(); + if (!_mdf.Next()) + return(FALSE); + } + + return(TRUE); +} + +//+------------------------------------------------------------------------- +// +// Class: CTestOpenStream +// +// Purpose: Test IStorage::OpenStream +// +// Interface: CTestCase +// +// History: 26-Jan-93 AlexT Created +// +// Notes: +// +//-------------------------------------------------------------------------- + +class CTestOpenStream : public CTestCase +{ +private: + SCODE _sc; + + CModeDf _mdf; + IStorage *_pstg; + + CModeStm _mstm; + IStream *_pstm; + +public: + virtual BOOL Init(void); + virtual SCODE Prep(LONG iteration); + virtual SCODE Call(LONG iteration); + virtual void EndCall(LONG iteration); + virtual void CallVerify(LONG iteration); + virtual void EndPrep(LONG iteration); + virtual void EndVerify(LONG iteration); + virtual BOOL Next(void); +}; + +BOOL CTestOpenStream::Init(void) +{ + printf("SIFT IStorage::OpenStream\n"); + _mdf.Init(); + _mstm.Init(); + return(TRUE); +} + +SCODE CTestOpenStream::Prep(LONG iteration) +{ + _sc = CreateWorkingDocfile(_mdf.GetMode(), &_pstg, 0); + if (SUCCEEDED(_sc)) + { + _sc = DfGetScode(_pstg->CreateStream( + "TestFail Stream", + _mstm.GetMode(), + 0, + 0, + &_pstm)); + + if (FAILED(_sc)) + _pstg->Release(); + else + _pstm->Release(); + } + return(_sc); +} + +SCODE CTestOpenStream::Call(LONG iteration) +{ + SCODE sc; + + if (iteration == 0) + printf("Docfile Mode 0x%lX, Stream Mode 0x%lX\n", + _mdf.GetMode(), _mstm.GetMode()); + + sc = DfGetScode(_pstg->OpenStream( + "TestFail Stream", + 0, + _mstm.GetMode(), + 0, + &_pstm)); + + return(sc); +} + +void CTestOpenStream::EndCall(LONG iteration) +{ + _pstm->Release(); +} + +void CTestOpenStream::CallVerify(LONG iteration) +{ +} + +void CTestOpenStream::EndPrep(LONG iteration) +{ + _pstg->Release(); +} + +void CTestOpenStream::EndVerify(LONG iteration) +{ + VerifyClean(_sc, _mdf.GetMode(), iteration); +} + +BOOL CTestOpenStream::Next(void) +{ + if (!_mstm.Next()) + { + _mstm.Init(); + if (!_mdf.Next()) + return(FALSE); + } + + return(TRUE); +} + +//+------------------------------------------------------------------------- +// +// Class: CTestOpenStorage +// +// Purpose: Test IStorage::OpenStorage +// +// Interface: CTestCase +// +// History: 26-Jan-93 AlexT Created +// +// Notes: +// +//-------------------------------------------------------------------------- + +class CTestOpenStorage : public CTestCase +{ +private: + SCODE _sc; + + CModeDf _mdf; + IStorage *_pstg; + + CModeStg _mstg; + IStorage *_pstgChild; + +public: + virtual BOOL Init(void); + virtual SCODE Prep(LONG iteration); + virtual SCODE Call(LONG iteration); + virtual void EndCall(LONG iteration); + virtual void CallVerify(LONG iteration); + virtual void EndPrep(LONG iteration); + virtual void EndVerify(LONG iteration); + virtual BOOL Next(void); +}; + +BOOL CTestOpenStorage::Init(void) +{ + printf("SIFT IStorage::OpenStorage\n"); + _mdf.Init(); + _mstg.Init(); + return(TRUE); +} + +SCODE CTestOpenStorage::Prep(LONG iteration) +{ + _sc = CreateWorkingDocfile(_mdf.GetMode(), &_pstg, 0); + if (SUCCEEDED(_sc)) + { + _sc = DfGetScode(_pstg->CreateStorage( + "TestFail Storage", + _mstg.GetMode(), + 0, + 0, + &_pstgChild)); + + if (FAILED(_sc)) + _pstg->Release(); + else + _pstgChild->Release(); + } + return(_sc); +} + +SCODE CTestOpenStorage::Call(LONG iteration) +{ + SCODE sc; + + if (iteration == 0) + printf("Docfile Mode 0x%lX, Storage Mode 0x%lX\n", + _mdf.GetMode(), _mstg.GetMode()); + + sc = DfGetScode(_pstg->OpenStorage("TestFail Storage", 0, + _mstg.GetMode(), 0, 0, &_pstgChild)); + + return(sc); +} + +void CTestOpenStorage::EndCall(LONG iteration) +{ + _pstgChild->Release(); +} + +void CTestOpenStorage::CallVerify(LONG iteration) +{ +} + +void CTestOpenStorage::EndPrep(LONG iteration) +{ + _pstg->Release(); +} + +void CTestOpenStorage::EndVerify(LONG iteration) +{ + VerifyClean(_sc, _mdf.GetMode(), iteration); +} + +BOOL CTestOpenStorage::Next(void) +{ + if (!_mstg.Next()) + { + _mstg.Init(); + if (!_mdf.Next()) + return(FALSE); + } + + return(TRUE); +} + +//+------------------------------------------------------------------------- +// +// Class: CTestCommit +// +// Purpose: Test IStream::Write +// +// Interface: CTestCase +// +// History: 26-Jan-93 AlexT Created +// +// Notes: +// +//-------------------------------------------------------------------------- + +class CTestCommit : public CTestCase +{ +private: + CModeDf _mdf; + IStorage *_pstg; + + CModeStg _mstg; + IStorage *_pstgChild; + +public: + virtual BOOL Init(void); + virtual SCODE Prep(LONG iteration); + virtual SCODE Call(LONG iteration); + virtual void EndCall(LONG iteration); + virtual void CallVerify(LONG iteration); + virtual void EndPrep(LONG iteration); + virtual void EndVerify(LONG iteration); + virtual BOOL Next(void); +}; + +BOOL CTestCommit::Init(void) +{ + printf("SIFT IStorage::Commit\n"); + _mdf.Init(); + _mstg.Init(); + return(TRUE); +} + +SCODE CTestCommit::Prep(LONG iteration) +{ + SCODE sc; + + sc = CreateWorkingDocfile(_mdf.GetMode(), &_pstg, 0); + if (SUCCEEDED(sc)) + { + sc = DfGetScode(_pstg->CreateStorage( + "TestFail Storage", + _mstg.GetMode(), + 0, + 0, + &_pstgChild)); + + if (FAILED(sc)) + _pstg->Release(); + } + return(sc); +} + +SCODE CTestCommit::Call(LONG iteration) +{ + SCODE sc; + + if (iteration == 0) + printf("Docfile Mode 0x%lX, Storage Mode 0x%lX\n", + _mdf.GetMode(), _mstg.GetMode()); + + sc = DfGetScode(_pstgChild->Commit(0)); + + if (FAILED(sc)) + { + if (sc != STG_E_MEDIUMFULL) + printf("..Iteration %ld - STG_E_MEDIUMFULL\n", iteration); + else + printf("..Iteration %ld - failed - sc = 0x%lX\n", + iteration, sc); + } + return(sc); +} + +void CTestCommit::EndCall(LONG iteration) +{ +} + +void CTestCommit::CallVerify(LONG iteration) +{ +} + +void CTestCommit::EndPrep(LONG iteration) +{ + _pstgChild->Release(); + _pstg->Release(); +} + +void CTestCommit::EndVerify(LONG iteration) +{ + VerifyClean(S_OK, _mdf.GetMode(), iteration); +} + +BOOL CTestCommit::Next(void) +{ + if (!_mstg.Next()) + { + _mstg.Init(); + if (!_mdf.Next()) + return(FALSE); + } + + return(TRUE); +} + +//+------------------------------------------------------------------------- +// +// Class: CTestCommit2 +// +// Purpose: Test IStorage::Commit +// +// Interface: CTestCase +// +// History: 26-Jan-93 AlexT Created +// +// Notes: +// +//-------------------------------------------------------------------------- + +class CTestCommit2 : public CTestCase +{ +private: + CModeDf _mdf; + IStorage *_pstg; + + CModeStg _mstg; + IStorage *_pstgChild; + + IStream *_pstmChild; + +public: + virtual BOOL Init(void); + virtual SCODE Prep(LONG iteration); + virtual SCODE Call(LONG iteration); + virtual void EndCall(LONG iteration); + virtual void CallVerify(LONG iteration); + virtual void EndPrep(LONG iteration); + virtual void EndVerify(LONG iteration); + virtual BOOL Next(void); +}; + +BOOL CTestCommit2::Init(void) +{ + printf("SIFT IStorage::Commit\n"); + _mdf.Init(); + _mstg.Init(); + return(TRUE); +} + +SCODE CTestCommit2::Prep(LONG iteration) +{ + SCODE sc; + ULONG cb = 1; + char c = 'X'; + ULONG cbWritten; + + sc = CreateWorkingDocfile(_mdf.GetMode(), &_pstg, 0); + if (SUCCEEDED(sc)) + { + sc = DfGetScode(_pstg->CreateStorage( + "TestFail Storage", + _mstg.GetMode(), + 0, + 0, + &_pstgChild)); + + if (FAILED(sc)) + _pstg->Release(); + else + { + sc = DfGetScode(_pstgChild->CreateStream( + "TestFail Stream", + STGM_DIRECT | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, + 0, + 0, + &_pstmChild)); + + if (FAILED(sc)) + { + _pstgChild->Release(); + _pstg->Release(); + } + else + { + sc = DfGetScode(_pstmChild->Write(&c, cb, &cbWritten)); + if (FAILED(sc)) + { + _pstmChild->Release(); + _pstgChild->Release(); + _pstg->Release(); + } + } + } + } + return(sc); +} + +SCODE CTestCommit2::Call(LONG iteration) +{ + SCODE sc; + + if (iteration == 0) + printf("Docfile Mode 0x%lX, Storage Mode 0x%lX\n", + _mdf.GetMode(), _mstg.GetMode()); + + sc = DfGetScode(_pstgChild->Commit(0)); + + if (FAILED(sc)) + { + if (sc == STG_E_MEDIUMFULL) + printf("..Iteration %ld - STG_E_MEDIUMFULL\n", iteration); + else + printf("..Iteration %ld - failed - sc = 0x%lX\n", + iteration, sc); + } + return(sc); +} + +void CTestCommit2::EndCall(LONG iteration) +{ +} + +void CTestCommit2::CallVerify(LONG iteration) +{ +} + +void CTestCommit2::EndPrep(LONG iteration) +{ + _pstmChild->Release(); + _pstgChild->Release(); + _pstg->Release(); +} + +void CTestCommit2::EndVerify(LONG iteration) +{ + VerifyClean(S_OK, _mdf.GetMode(), iteration); +} + +BOOL CTestCommit2::Next(void) +{ + if (!_mstg.Next()) + { + _mstg.Init(); + if (!_mdf.Next()) + return(FALSE); + } + + return(TRUE); +} + +//+------------------------------------------------------------------------- +// +// Class: CTestCommit3 +// +// Purpose: Test IStorage::Commit +// +// Interface: CTestCase +// +// History: 26-Jan-93 AlexT Created +// +// Notes: +// +//-------------------------------------------------------------------------- + +class CTestCommit3 : public CTestCase +{ +private: + CModeDf _mdf; + IStorage *_pstg; + +public: + virtual BOOL Init(void); + virtual SCODE Prep(LONG iteration); + virtual SCODE Call(LONG iteration); + virtual void EndCall(LONG iteration); + virtual void CallVerify(LONG iteration); + virtual void EndPrep(LONG iteration); + virtual void EndVerify(LONG iteration); + virtual BOOL Next(void); +}; + +BOOL CTestCommit3::Init(void) +{ + printf("SIFT IStorage::Commit\n"); + _mdf.Init(); + return(TRUE); +} + +SCODE CTestCommit3::Prep(LONG iteration) +{ + SCODE sc; + ULONG cb = 1; + char c = 'X'; + + sc = CreateWorkingDocfile(_mdf.GetMode(), &_pstg, 0); + + if (FAILED(sc)) + return(sc); + + IStream *pstm; + sc = DfGetScode(_pstg->CreateStream( + "PP40", + STGM_DIRECT | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, + 0, + 0, + &pstm)); + pstm->Release(); + + IStorage *pstgChild; + sc = DfGetScode(_pstg->CreateStorage( + "TestFail Storage", + STGM_TRANSACTED | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, + 0, + 0, + &pstgChild)); + + sc = DfGetScode(pstgChild->CreateStream( + "One", + STGM_DIRECT | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, + 0, + 0, + &pstm)); + pstm->Release(); + sc = DfGetScode(pstgChild->CreateStream( + "Two", + STGM_DIRECT | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, + 0, + 0, + &pstm)); + pstm->Release(); + sc = DfGetScode(pstgChild->CreateStream( + "Three", + STGM_DIRECT | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, + 0, + 0, + &pstm)); + pstm->Release(); + + sc = DfGetScode(pstgChild->Commit(0)); + pstgChild->Release(); + + return(sc); +} + +SCODE CTestCommit3::Call(LONG iteration) +{ + SCODE sc; + + if (iteration == 0) + printf("Docfile Mode 0x%lX\n", + _mdf.GetMode()); + + sc = DfGetScode(_pstg->Commit(0)); + + if (FAILED(sc)) + { + if (sc == STG_E_MEDIUMFULL) + printf("..Iteration %ld - STG_E_MEDIUMFULL\n", iteration); + else + printf("..Iteration %ld - failed - sc = 0x%lX\n", + iteration, sc); + } + return(sc); +} + +void CTestCommit3::EndCall(LONG iteration) +{ +} + +void CTestCommit3::CallVerify(LONG iteration) +{ +} + +void CTestCommit3::EndPrep(LONG iteration) +{ + _pstg->Release(); +} + +void CTestCommit3::EndVerify(LONG iteration) +{ + VerifyClean(S_OK, _mdf.GetMode(), iteration); +} + +BOOL CTestCommit3::Next(void) +{ + if (!_mdf.Next()) + return(FALSE); + + return(TRUE); +} + +//+------------------------------------------------------------------------- +// +// Class: CTestCommit4 +// +// Purpose: Test IStorage::Commit with resized streams +// +// Interface: CTestCase +// +// History: 08-Sep-93 DrewB Created +// +//-------------------------------------------------------------------------- + +class CTestCommit4 : public CTestCase +{ +private: + CModeDf _mdf; + IStorage *_pstg; + +public: + virtual BOOL Init(void); + virtual SCODE Prep(LONG iteration); + virtual SCODE Call(LONG iteration); + virtual void EndCall(LONG iteration); + virtual void CallVerify(LONG iteration); + virtual void EndPrep(LONG iteration); + virtual void EndVerify(LONG iteration); + virtual BOOL Next(void); +}; + +BOOL CTestCommit4::Init(void) +{ + printf("SIFT IStorage::Commit\n"); + _mdf.Init(); + return(TRUE); +} + +#define LARGE_SIZE 4097 +#define SMALL_SIZE 4095 + +SCODE CTestCommit4::Prep(LONG iteration) +{ + SCODE sc; + IStream *pstm; + ULARGE_INTEGER uli; + + sc = CreateWorkingDocfile(_mdf.GetMode(), &_pstg, 0); + if (FAILED(sc)) + goto EH_Err; + sc = DfGetScode(_pstg->CreateStream("Test", + STGM_DIRECT | STGM_SHARE_EXCLUSIVE | + STGM_READWRITE, 0, 0, &pstm)); + if (FAILED(sc)) + goto EH_pstg; + uli.HighPart = 0; + uli.LowPart = LARGE_SIZE; + sc = DfGetScode(pstm->SetSize(uli)); + if (FAILED(sc)) + goto EH_pstm; + sc = DfGetScode(_pstg->Commit(0)); + if (FAILED(sc)) + goto EH_pstm; + uli.LowPart = SMALL_SIZE; + sc = DfGetScode(pstm->SetSize(uli)); + if (FAILED(sc)) + goto EH_pstm; + pstm->Release(); + return sc; + + EH_pstm: + pstm->Release(); + EH_pstg: + _pstg->Release(); + EH_Err: + return sc; +} + +SCODE CTestCommit4::Call(LONG iteration) +{ + SCODE sc; + + if (iteration == 0) + printf("Docfile Mode 0x%lX\n", + _mdf.GetMode()); + + sc = DfGetScode(_pstg->Commit(0)); + + if (FAILED(sc)) + { + if (sc == STG_E_MEDIUMFULL) + printf("..Iteration %ld - STG_E_MEDIUMFULL\n", iteration); + else + printf("..Iteration %ld - failed - sc = 0x%lX\n", + iteration, sc); + } + return(sc); +} + +void CTestCommit4::EndCall(LONG iteration) +{ +} + +void CTestCommit4::CallVerify(LONG iteration) +{ + IStream *pstm; + SCODE sc; + STATSTG stat; + + sc = DfGetScode(_pstg->OpenStream("Test", NULL, STGM_DIRECT | + STGM_SHARE_EXCLUSIVE, 0, &pstm)); + if (FAILED(sc)) + { + printf("Can't open stream - %lX\n", sc); + return; + } + sc = DfGetScode(pstm->Stat(&stat, STATFLAG_NONAME)); + pstm->Release(); + if (FAILED(sc)) + { + printf("Can't stat stream - %lX\n", sc); + return; + } + if (stat.cbSize.LowPart != SMALL_SIZE) + { + printf("Stream length is %lu rather than %d\n", + stat.cbSize.LowPart, SMALL_SIZE); + return; + } +} + +void CTestCommit4::EndPrep(LONG iteration) +{ + _pstg->Release(); +} + +void CTestCommit4::EndVerify(LONG iteration) +{ + VerifyClean(S_OK, _mdf.GetMode(), iteration); +} + +BOOL CTestCommit4::Next(void) +{ + if (!_mdf.Next()) + return(FALSE); + + return(TRUE); +} + +//+------------------------------------------------------------------------- +// +// Class: CTestStgOpen +// +// Purpose: Test StgOpenStorage +// +// Interface: CTestCase +// +// History: 28-Jan-93 AlexT Created +// +// Notes: +// +//-------------------------------------------------------------------------- + +class CTestStgOpen : public CTestCase +{ +private: + SCODE _sc; + + CModeDf _mdf; + IStorage *_pstg; + +public: + virtual BOOL Init(void); + virtual SCODE Prep(LONG iteration); + virtual SCODE Call(LONG iteration); + virtual void EndCall(LONG iteration); + virtual void CallVerify(LONG iteration); + virtual void EndPrep(LONG iteration); + virtual void EndVerify(LONG iteration); + virtual BOOL Next(void); +}; + +BOOL CTestStgOpen::Init(void) +{ + printf("SIFT StgOpenStorage\n"); + _mdf.Init(); + return(TRUE); +} + +SCODE CTestStgOpen::Prep(LONG iteration) +{ + SCODE sc; + DWORD dwMode = STGM_DIRECT | + STGM_READWRITE | + STGM_SHARE_EXCLUSIVE | + STGM_FAILIFTHERE; + IStorage *pstg, *pstgChild; + IStream *pstmChild; + + sc = CreateWorkingDocfile(dwMode, &pstg, 0); + if (SUCCEEDED(sc)) + { + sc = DfGetScode(pstg->CreateStorage( + "TestFail Storage", + dwMode, + 0, + 0, + &pstgChild)); + + if (SUCCEEDED(sc)) + { + sc = DfGetScode(pstgChild->CreateStream( + "TestFail Stream", + dwMode, + 0, + 0, + &pstmChild)); + + if (SUCCEEDED(sc)) + pstmChild->Release(); + + pstgChild->Release(); + } + + pstg->Release(); + } + return(sc); +} + +SCODE CTestStgOpen::Call(LONG iteration) +{ + if (iteration == 0) + printf("Docfile Mode 0x%lX\n", _mdf.GetMode()); + + _sc = DfGetScode(StgOpenStorage("c:\\testfail.dfl", + NULL, + _mdf.GetMode(), + NULL, + 0, + &_pstg)); + + if (FAILED(_sc)) + { + if (iteration == 0 && _sc == STG_E_INVALIDFLAG) + { + printf("..STG_E_INVALIDFLAG\n"); + // Must have been a bad combination of flags - we + // ignore these for now. + } + else if (iteration > 0 && _sc == STG_E_INSUFFICIENTMEMORY) + { + // Do nothing (expected failure) + } + else if (iteration > 0 && _sc == STG_E_MEDIUMFULL) + { + // Do nothing (expected failure) + } + else + printf("..Iteration %ld, call failed - sc = 0x%lX\n", + iteration, _sc); + } + return(_sc); +} + +void CTestStgOpen::EndCall(LONG iteration) +{ + _pstg->Release(); +} + +void CTestStgOpen::CallVerify(LONG iteration) +{ +} + +void CTestStgOpen::EndPrep(LONG iteration) +{ +} + +void CTestStgOpen::EndVerify(LONG iteration) +{ + // If the call failed, the file should still exist. + // If the call succeeded + // If mode was delete on release, + // file should not exist + // else file should exist + + VerifyDisk((SUCCEEDED(_sc) && (!(_mdf.GetMode() & STGM_DELETEONRELEASE))) || + FAILED(_sc), iteration); + VerifyMemory(iteration); +} + +BOOL CTestStgOpen::Next(void) +{ + if (!_mdf.Next()) + return(FALSE); + + return(TRUE); +} + + +//+------------------------------------------------------------------------- +// +// Class: CTestWrite2 +// +// Purpose: Test IStream::Write for largish writes +// +// Interface: CTestCase +// +// History: 16-Feb-93 PhilipLa Created. +// +// Notes: +// +//-------------------------------------------------------------------------- + +class CTestWrite2 : public CTestCase +{ +private: + SCODE _sc; + + BYTE *_pb; + + CModeDf _mdf; + IStorage *_pstg; + + CModeStm _mstm; + IStream *_pstmChild; + + ULONG _cb; + ULONG _cBlock; + + ULONG _cbSize; +public: + virtual BOOL Init(void); + virtual SCODE Prep(LONG iteration); + virtual SCODE Call(LONG iteration); + virtual void EndCall(LONG iteration); + virtual void CallVerify(LONG iteration); + virtual void EndPrep(LONG iteration); + virtual void EndVerify(LONG iteration); + virtual BOOL Next(void); +}; + +BOOL CTestWrite2::Init(void) +{ + printf("SIFT IStream::Write2 - large writes without Setsize\n"); + _mdf.Init(); + _mstm.Init(); + + _cb = 8192; + _cBlock = 8; + + _pb = NULL; + return(TRUE); +} + +SCODE CTestWrite2::Prep(LONG iteration) +{ + + _pb = new BYTE[8192]; + memset(_pb, 'X', 8192); + + _sc = CreateWorkingDocfile(_mdf.GetMode(), &_pstg, 0); + if (SUCCEEDED(_sc)) + { + _sc = DfGetScode(_pstg->CreateStream( + "TestFail Stream", + _mstm.GetMode(), + 0, + 0, + &_pstmChild)); + + _cbSize = 0; + if (FAILED(_sc)) + _pstg->Release(); + + } + return(_sc); +} + +SCODE CTestWrite2::Call(LONG iteration) +{ + SCODE sc; + ULONG cbWritten; + + if (iteration == 0) + printf("Docfile Mode 0x%lX, Stream Mode 0x%lX, Write %ld bytes\n", + _mdf.GetMode(), _mstm.GetMode(), _cb * _cBlock); + + for (ULONG i = 0; i < _cBlock; i++) + { + sc = DfGetScode(_pstmChild->Write(_pb, _cb, &cbWritten)); + _cbSize += cbWritten; + + if (FAILED(sc)) + { + if (sc != STG_E_MEDIUMFULL) + printf("..Iteration %ld, block %lu - failed - sc = 0x%lX\n", + iteration, i + 1, sc); + break; + } + } + return(sc); +} + +void CTestWrite2::EndCall(LONG iteration) +{ + STATSTG stat; + + _pstmChild->Stat(&stat, STATFLAG_NONAME); + + if (ULIGetLow(stat.cbSize) != _cbSize) + { + printf("..Iteration %lu - Size of stream is %lu. Expected %lu\n", + iteration, ULIGetLow(stat.cbSize), _cbSize); + } +} + +void CTestWrite2::CallVerify(LONG iteration) +{ + STATSTG stat; + + _pstmChild->Stat(&stat, STATFLAG_NONAME); + + if (ULIGetLow(stat.cbSize) != _cbSize) + { + printf("..Iteration %lu - Size of stream is %lu. Expected %lu\n", + iteration, ULIGetLow(stat.cbSize), _cbSize); + } + +} + +void CTestWrite2::EndPrep(LONG iteration) +{ + delete _pb; + _pb = NULL; + + _pstmChild->Release(); + _pstg->Release(); +} + +void CTestWrite2::EndVerify(LONG iteration) +{ + VerifyClean(_sc, _mdf.GetMode(), iteration); +} + +BOOL CTestWrite2::Next(void) +{ + if (!_mstm.Next()) + { + _mstm.Init(); + if (!_mdf.Next()) + return(FALSE); + } + + return(TRUE); +} + + +//+------------------------------------------------------------------------- +// +// Class: CTestWrite3 +// +// Purpose: Test IStream::Write for largish writes +// +// Interface: CTestCase +// +// History: 16-Feb-93 PhilipLa Created. +// +// Notes: +// +//-------------------------------------------------------------------------- + +class CTestWrite3 : public CTestCase +{ +private: + SCODE _sc; + + BYTE *_pb; + + CModeDf _mdf; + IStorage *_pstg; + + CModeStm _mstm; + IStream *_pstmChild; + + ULONG _cb; + ULONG _cBlock; +public: + virtual BOOL Init(void); + virtual SCODE Prep(LONG iteration); + virtual SCODE Call(LONG iteration); + virtual void EndCall(LONG iteration); + virtual void CallVerify(LONG iteration); + virtual void EndPrep(LONG iteration); + virtual void EndVerify(LONG iteration); + virtual BOOL Next(void); +}; + +BOOL CTestWrite3::Init(void) +{ + printf("SIFT IStream::Write3 - large writes with prior Setsize\n"); + _mdf.Init(); + _mstm.Init(); + + _cb = 8192; + _cBlock = 8; + + _pb = NULL; + return(TRUE); +} + +SCODE CTestWrite3::Prep(LONG iteration) +{ + + _pb = new BYTE[8192]; + memset(_pb, 'X', 8192); + + _sc = CreateWorkingDocfile(_mdf.GetMode(), &_pstg, 0); + if (SUCCEEDED(_sc)) + { + _sc = DfGetScode(_pstg->CreateStream( + "TestFail Stream", + _mstm.GetMode(), + 0, + 0, + &_pstmChild)); + + if (FAILED(_sc)) + _pstg->Release(); + else + { + ULARGE_INTEGER cbSize; + + ULISet32(cbSize, _cb * _cBlock); + + _sc = DfGetScode(_pstmChild->SetSize(cbSize)); + + if (FAILED(_sc)) + { + _pstmChild->Release(); + _pstg->Release(); + } + } + } + return(_sc); +} + +SCODE CTestWrite3::Call(LONG iteration) +{ + SCODE sc; + ULONG cbWritten; + + if (iteration == 0) + printf("Docfile Mode 0x%lX, Stream Mode 0x%lX, Write %ld bytes\n", + _mdf.GetMode(), _mstm.GetMode(), _cb * _cBlock); + else + printf("ERROR - shouldn't hit iteration %lu\n", iteration); + + for (ULONG i = 0; i < _cBlock; i++) + { + sc = DfGetScode(_pstmChild->Write(_pb, _cb, &cbWritten)); + if (FAILED(sc)) + { + if (sc != STG_E_MEDIUMFULL) + printf("..Iteration %ld, block %lu - failed - sc = 0x%lX\n", + iteration, i + 1, sc); + break; + } + } + return(sc); +} + +void CTestWrite3::EndCall(LONG iteration) +{ +} + +void CTestWrite3::CallVerify(LONG iteration) +{ +} + +void CTestWrite3::EndPrep(LONG iteration) +{ + delete _pb; + _pb = NULL; + + _pstmChild->Release(); + _pstg->Release(); +} + +void CTestWrite3::EndVerify(LONG iteration) +{ + VerifyClean(_sc, _mdf.GetMode(), iteration); +} + +BOOL CTestWrite3::Next(void) +{ + if (!_mstm.Next()) + { + _mstm.Init(); + if (!_mdf.Next()) + return(FALSE); + } + + return(TRUE); +} + + +//+------------------------------------------------------------------------- +// +// Class: CTestSetsize +// +// Purpose: Test IStream::Write for largish writes +// +// Interface: CTestCase +// +// History: 16-Feb-93 PhilipLa Created. +// +// Notes: +// +//-------------------------------------------------------------------------- + +class CTestSetsize : public CTestCase +{ +private: + SCODE _sc; + + BYTE *_pb; + + CModeDf _mdf; + IStorage *_pstg; + + CModeStm _mstm; + IStream *_pstmChild; + + ULONG _cb; + ULONG _cBlock; +public: + virtual BOOL Init(void); + virtual SCODE Prep(LONG iteration); + virtual SCODE Call(LONG iteration); + virtual void EndCall(LONG iteration); + virtual void CallVerify(LONG iteration); + virtual void EndPrep(LONG iteration); + virtual void EndVerify(LONG iteration); + virtual BOOL Next(void); +}; + +BOOL CTestSetsize::Init(void) +{ + printf("SIFT IStream::Setsize\n"); + _mdf.Init(); + _mstm.Init(); + + _cb = 8192; + _cBlock = 9; + + _pb = NULL; + return(TRUE); +} + +SCODE CTestSetsize::Prep(LONG iteration) +{ + + _pb = new BYTE[8192]; + memset(_pb, 'X', 8192); + + _sc = CreateWorkingDocfile(_mdf.GetMode(), &_pstg, 0); + if (SUCCEEDED(_sc)) + { + _sc = DfGetScode(_pstg->CreateStream( + "TestFail Stream", + _mstm.GetMode(), + 0, + 0, + &_pstmChild)); + + if (FAILED(_sc)) + _pstg->Release(); + } + return(_sc); +} + +SCODE CTestSetsize::Call(LONG iteration) +{ + SCODE sc; + ULONG cbWritten; + + if (iteration == 0) + printf("Docfile Mode 0x%lX, Stream Mode 0x%lX, Write %ld bytes\n", + _mdf.GetMode(), _mstm.GetMode(), _cb * _cBlock); + + ULARGE_INTEGER cbSize; + + ULISet32(cbSize, _cb * _cBlock); + + sc = DfGetScode(_pstmChild->SetSize(cbSize)); + + + if (FAILED(sc)) + { + if (sc != STG_E_MEDIUMFULL) + printf("..Iteration %ld - failed - sc = 0x%lX\n", iteration, sc); + } + else + { + for (ULONG i = 0; i < _cBlock; i++) + { + sc = DfGetScode(_pstmChild->Write(_pb, _cb, &cbWritten)); + if (FAILED(sc)) + { + printf("..Iteration %ld, Write %lu failed - sc == 0x%lX\n", + iteration, i + 1, sc); + break; + } + } + } + return(sc); +} + +void CTestSetsize::EndCall(LONG iteration) +{ + STATSTG stat; + + _pstmChild->Stat(&stat, STATFLAG_NONAME); + + if (ULIGetLow(stat.cbSize) != _cb * _cBlock) + { + printf("..Iteration %lu - Size of stream is %lu, expected %lu\n", + iteration, ULIGetLow(stat.cbSize), _cb * _cBlock); + } + +} + +void CTestSetsize::CallVerify(LONG iteration) +{ + STATSTG stat; + + _pstmChild->Stat(&stat, STATFLAG_NONAME); + + if (ULIGetLow(stat.cbSize) != 0) + { + printf("..Iteration %lu - Size of stream is %lu, expected 0\n", + iteration, ULIGetLow(stat.cbSize)); + } +} + +void CTestSetsize::EndPrep(LONG iteration) +{ + delete _pb; + _pb = NULL; + + _pstmChild->Release(); + _pstg->Release(); +} + +void CTestSetsize::EndVerify(LONG iteration) +{ + VerifyClean(_sc, _mdf.GetMode(), iteration); +} + +BOOL CTestSetsize::Next(void) +{ + if (!_mstm.Next()) + { + _mstm.Init(); + if (!_mdf.Next()) + return(FALSE); + } + + return(TRUE); +} + + +//+------------------------------------------------------------------------- +// +// Class: CTestCreateStream2 +// +// Purpose: Test IStorage::CreateStream2 +// +// Interface: CTestCase +// +// History: 26-Jan-93 AlexT Created +// +// Notes: +// +//-------------------------------------------------------------------------- + +class CTestCreateStream2 : public CTestCase +{ +private: + SCODE _sc; + + CModeDf _mdf; + IStorage *_pstg; + + CModeStm _mstm; + IStream *_pstmChild; + +public: + virtual BOOL Init(void); + virtual SCODE Prep(LONG iteration); + virtual SCODE Call(LONG iteration); + virtual void EndCall(LONG iteration); + virtual void CallVerify(LONG iteration); + virtual void EndPrep(LONG iteration); + virtual void EndVerify(LONG iteration); + virtual BOOL Next(void); +}; + +BOOL CTestCreateStream2::Init(void) +{ + printf("SIFT IStorage::CreateStream2\n"); + _mdf.Init(); + _mstm.Init(); + return(TRUE); +} + +SCODE CTestCreateStream2::Prep(LONG iteration) +{ + _sc = CreateWorkingDocfile(_mdf.GetMode(), &_pstg, 0); + return(_sc); +} + +SCODE CTestCreateStream2::Call(LONG iteration) +{ + SCODE sc; + ULONG cStream = 8; + + char * pszName = "XTestFail Stream"; + if (iteration == 0) + printf("Docfile Mode 0x%lX, Child Stream Mode 0x%lX\n", + _mdf.GetMode(), _mstm.GetMode()); + + for (ULONG i = 0; i < cStream; i++) + { + pszName[0] = ((char)i) + '0'; + + sc = DfGetScode(_pstg->CreateStream( + pszName, + _mstm.GetMode(), + 0, + 0, + &_pstmChild)); + + if (FAILED(sc)) + { + if ((sc == STG_E_MEDIUMFULL) || (sc == STG_E_INSUFFICIENTMEMORY)) + { + //Do nothing. We expected these. + } + else printf("..Iteration %ld, stream %lu - failed - sc = 0x%lX\n", + iteration, i + 1, sc); + break; + } + _pstmChild->Release(); + } + + return(sc); +} + +void CTestCreateStream2::EndCall(LONG iteration) +{ +} + +void CTestCreateStream2::CallVerify(LONG iteration) +{ +} + +void CTestCreateStream2::EndPrep(LONG iteration) +{ + _pstg->Release(); +} + +void CTestCreateStream2::EndVerify(LONG iteration) +{ + VerifyClean(_sc, _mdf.GetMode(), iteration); +} + +BOOL CTestCreateStream2::Next(void) +{ + if (!_mstm.Next()) + { + _mstm.Init(); + if (!_mdf.Next()) + return(FALSE); + } + + return(TRUE); +} + +//+------------------------------------------------------------------------- +// +// Class: CTestDestroyElement +// +// Purpose: Test IStorage::DestroyElement +// +// Interface: CTestCase +// +// History: 26-Jan-93 AlexT Created +// +// Notes: +// +//-------------------------------------------------------------------------- + +class CTestDestroyElement : public CTestCase +{ +private: + SCODE _sc; + + CModeDf _mdf; + IStorage *_pstg; + + CModeStg _mstg; + IStorage *_pstgChild; + +public: + virtual BOOL Init(void); + virtual SCODE Prep(LONG iteration); + virtual SCODE Call(LONG iteration); + virtual void EndCall(LONG iteration); + virtual void CallVerify(LONG iteration); + virtual void EndPrep(LONG iteration); + virtual void EndVerify(LONG iteration); + virtual BOOL Next(void); +}; + +BOOL CTestDestroyElement::Init(void) +{ + printf("SIFT IStorage::DestroyElement\n"); + _mdf.Init(); + _mstg.Init(); + return(TRUE); +} + +SCODE CTestDestroyElement::Prep(LONG iteration) +{ + _sc = CreateWorkingDocfile(_mdf.GetMode(), &_pstg, 0); + if (SUCCEEDED(_sc)) + { + _sc = DfGetScode(_pstg->CreateStorage( + "TestFail Storage", + _mstg.GetMode(), + 0, + 0, + &_pstgChild)); + + _pstgChild->Release(); + } + + + return(_sc); +} + +SCODE CTestDestroyElement::Call(LONG iteration) +{ + SCODE sc; + + if (iteration == 0) + printf("Docfile Mode 0x%lX, Child Storage Mode 0x%lX\n", + _mdf.GetMode(), _mstg.GetMode()); + + sc = DfGetScode(_pstg->DestroyElement("TestFail Storage")); + + if (FAILED(sc)) + { + if ((sc == STG_E_MEDIUMFULL) || (sc == STG_E_INSUFFICIENTMEMORY)) + { + //We expected these - do nothing. + } + else + printf("..Iteration %ld - failed - sc = 0x%lX\n", + iteration, sc); + } + + return(sc); +} + +void CTestDestroyElement::EndCall(LONG iteration) +{ + SCODE sc; + + sc = DfGetScode(_pstg->OpenStorage( + "TestFail Storage", + 0, + _mstg.GetMode(), + 0, + 0, + &_pstgChild)); + + if (sc != STG_E_FILENOTFOUND) + { + printf("..Iteration %ld - open failed with 0x%lX, expected STG_E_FILENOTFOUND\n", + iteration, + sc); + } + + if (SUCCEEDED(sc)) + { + _pstgChild->Release(); + } +} + +void CTestDestroyElement::CallVerify(LONG iteration) +{ + SCODE sc; + + sc = DfGetScode(_pstg->OpenStorage( + "TestFail Storage", + 0, + _mstg.GetMode(), + 0, + 0, + &_pstgChild)); + + if (FAILED(sc)) + { + printf("..Iteration %ld - open failed with 0x%lX, expected success.\n", + iteration, + sc); + } + else + { + _pstgChild->Release(); + } + +} + +void CTestDestroyElement::EndPrep(LONG iteration) +{ + _pstg->Release(); +} + +void CTestDestroyElement::EndVerify(LONG iteration) +{ + VerifyClean(_sc, _mdf.GetMode(), iteration); +} + +BOOL CTestDestroyElement::Next(void) +{ + if (!_mstg.Next()) + { + _mstg.Init(); + if (!_mdf.Next()) + return(FALSE); + } + + return(TRUE); +} + + +//+------------------------------------------------------------------------- +// +// Class: CTestSetsize2 +// +// Purpose: Test IStream::Write for largish writes +// +// Interface: CTestCase +// +// History: 16-Feb-93 PhilipLa Created. +// +// Notes: +// +//-------------------------------------------------------------------------- + +class CTestSetsize2 : public CTestCase +{ +private: + SCODE _sc; + + BYTE *_pb; + + CModeDf _mdf; + IStorage *_pstg; + + CModeStm _mstm; + IStream *_pstmChild; + + ULONG _cb; + ULONG _cBlock; +public: + virtual BOOL Init(void); + virtual SCODE Prep(LONG iteration); + virtual SCODE Call(LONG iteration); + virtual void EndCall(LONG iteration); + virtual void CallVerify(LONG iteration); + virtual void EndPrep(LONG iteration); + virtual void EndVerify(LONG iteration); + virtual BOOL Next(void); +}; + +BOOL CTestSetsize2::Init(void) +{ + printf("SIFT IStream::Setsize2\n"); + _mdf.Init(); + _mstm.Init(); + + _cb = 8192; + _cBlock = 9; + + _pb = NULL; + return(TRUE); +} + +SCODE CTestSetsize2::Prep(LONG iteration) +{ + + _pb = new BYTE[8192]; + memset(_pb, 'X', 8192); + + _sc = CreateWorkingDocfile(_mdf.GetMode(), &_pstg, 0); + if (SUCCEEDED(_sc)) + { + _sc = DfGetScode(_pstg->CreateStream( + "TestFail Stream", + _mstm.GetMode(), + 0, + 0, + &_pstmChild)); + + if (FAILED(_sc)) + _pstg->Release(); + else + { + ULARGE_INTEGER ulSize; + ULISet32(ulSize, _cb * _cBlock); + + _sc = DfGetScode(_pstmChild->SetSize(ulSize)); + if (FAILED(_sc)) + printf("Setsize failed in Prep()\n"); + else + { + for (ULONG i = 0; i < _cBlock; i++) + { + ULONG cbWritten; + + _sc = DfGetScode(_pstmChild->Write(_pb, _cb, &cbWritten)); + if (FAILED(_sc)) + break; + } + } + } + } + return(_sc); +} + +SCODE CTestSetsize2::Call(LONG iteration) +{ + SCODE sc; + + ULARGE_INTEGER ulSize; + ULISet32(ulSize, 2048L); + + sc = DfGetScode(_pstmChild->SetSize(ulSize)); + + return(sc); +} + +void CTestSetsize2::EndCall(LONG iteration) +{ + + STATSTG stat; + + _pstmChild->Stat(&stat, STATFLAG_NONAME); + + if (ULIGetLow(stat.cbSize) != 2048L) + { + printf("..Iteration %lu - Size of stream is %lu, expected %lu\n", + iteration, ULIGetLow(stat.cbSize), 2048L); + } + + LARGE_INTEGER newPos; + ULISet32(newPos, 0); + ULARGE_INTEGER dummy; + + _pstmChild->Seek(newPos, STREAM_SEEK_SET, &dummy); + ULONG cbRead; + + _pstmChild->Read(_pb, 2048, &cbRead); + if (cbRead != 2048) + { + printf("Unknown error - read %lu bytes, expected 2048\n"); + } + else + { + for (ULONG i = 0; i < 2048; i ++) + { + if (_pb[i] != 'X') + { + printf("Error in buffer data.\n"); + break; + } + } + } + +} + + +void CTestSetsize2::CallVerify(LONG iteration) +{ + + STATSTG stat; + + _pstmChild->Stat(&stat, STATFLAG_NONAME); + + if (ULIGetLow(stat.cbSize) != _cb * _cBlock) + { + printf("..Iteration %lu - Size of stream is %lu, expected %lu\n", + iteration, ULIGetLow(stat.cbSize), _cb * _cBlock); + } + else + { + LARGE_INTEGER newPos; + ULISet32(newPos, 0); + ULARGE_INTEGER dummy; + + _pstmChild->Seek(newPos, STREAM_SEEK_SET, &dummy); + + for (ULONG i = 0; i < _cBlock; i++) + { + ULONG cbRead; + + _sc = DfGetScode(_pstmChild->Read(_pb, _cb, &cbRead)); + if (FAILED(_sc)) + { + printf("Read failed with %lX\n", _sc); + break; + } + if (cbRead != _cb) + { + printf("Read %lu bytes, expected %lu\n",cbRead,_cb); + break; + } + for (ULONG j = 0; j < _cb; j++) + { + if (_pb[j] != 'X') + { + printf("Data mismatch at byte %lu, block %lu\n",j,i); + break; + } + } + } + } +} + +void CTestSetsize2::EndPrep(LONG iteration) +{ + delete _pb; + _pb = NULL; + + _pstmChild->Release(); + _pstg->Release(); +} + +void CTestSetsize2::EndVerify(LONG iteration) +{ + VerifyClean(_sc, _mdf.GetMode(), iteration); +} + +BOOL CTestSetsize2::Next(void) +{ + if (!_mstm.Next()) + { + _mstm.Init(); + if (!_mdf.Next()) + return(FALSE); + } + + return(TRUE); +} + + +//+------------------------------------------------------------------------- +// +// Class: CTestSwitchToFile +// +// Purpose: Test SwitchToFile +// +// Interface: CTestCase +// +// History: 18-Jun-93 PhilipLa Created. +// +// Notes: +// +//-------------------------------------------------------------------------- + +class CTestSwitchToFile : public CTestCase +{ +private: + SCODE _sc; + + CModeDf _mdf; + IStorage *_pstg; + +public: + virtual BOOL Init(void); + virtual SCODE Prep(LONG iteration); + virtual SCODE Call(LONG iteration); + virtual void EndCall(LONG iteration); + virtual void CallVerify(LONG iteration); + virtual void EndPrep(LONG iteration); + virtual void EndVerify(LONG iteration); + virtual BOOL Next(void); +}; + +BOOL CTestSwitchToFile::Init(void) +{ + printf("SIFT IStream::SwitchToFile\n"); + _mdf.Init(); + return(TRUE); +} + +SCODE CTestSwitchToFile::Prep(LONG iteration) +{ + IStream *pstm; + _unlink("c:\\tmp\\stf.dfl"); + + _sc = CreateWorkingDocfile(_mdf.GetMode(), &_pstg, 0); + if (SUCCEEDED(_sc)) + { + _sc = DfGetScode(_pstg->CreateStream( + "TestFail Stream", + STGM_DIRECT|STGM_READWRITE|STGM_SHARE_EXCLUSIVE, + 0, + 0, + &pstm)); + + if (FAILED(_sc)) + _pstg->Release(); + else + { + ULARGE_INTEGER ul; + + ULISet32(ul, 80000); + + _sc = DfGetScode(pstm->SetSize(ul)); + pstm->Release(); + + if (FAILED(_sc)) + { + _pstg->Release(); + } + } + } + return(_sc); +} + +SCODE CTestSwitchToFile::Call(LONG iteration) +{ + SCODE sc; + IRootStorage *pstgRoot; + + sc = DfGetScode(_pstg->QueryInterface( + IID_IRootStorage, + (void **)&pstgRoot)); + + if (FAILED(sc)) + return sc; + + sc = DfGetScode(pstgRoot->SwitchToFile("c:\\tmp\\stf.dfl")); + + pstgRoot->Release(); + + if (FAILED(sc)) + return sc; + + + sc = DfGetScode(_pstg->Commit(STGC_OVERWRITE)); + + if (FAILED(sc)) + { + printf("... Commit with overwrite failed.\n"); + } + else + { + printf("... Commit succeeded.\n"); + } + + return(sc); +} + +void CTestSwitchToFile::EndCall(LONG iteration) +{ +} + + +void CTestSwitchToFile::CallVerify(LONG iteration) +{ +} + +void CTestSwitchToFile::EndPrep(LONG iteration) +{ + _pstg->Release(); + _unlink("c:\\tmp\\stf.dfl"); +} + +void CTestSwitchToFile::EndVerify(LONG iteration) +{ + VerifyClean(_sc, _mdf.GetMode(), iteration); +} + +BOOL CTestSwitchToFile::Next(void) +{ + do + { + if (!_mdf.Next()) + return FALSE; + } + while (((_mdf.GetMode() & 0x70) == STGM_SHARE_DENY_READ) || + (_mdf.GetMode() & 0x70) == STGM_SHARE_DENY_NONE); + + return(TRUE); +} + + +//+------------------------------------------------------------------------- +// +// Function: TestCount, TestItem +// +// Synopsis: +// +// Effects: +// +// Arguments: +// +// Returns: +// +// History: 26-Jan-93 AlexT Created +// +// Notes: +// +//-------------------------------------------------------------------------- + +CTestStgCreate tstStgCreate; +CTestCreateStorage tstCreateStorage; +CTestCreateStream tstCreateStream; +CTestWrite tstWrite; +CTestOpenStorage tstOpenStorage; +CTestOpenStream tstOpenStream; +CTestCommit tstCommit; +CTestCommit2 tstCommit2; +CTestStgOpen tstStgOpen; +CTestWrite2 tstWrite2; +CTestWrite3 tstWrite3; +CTestSetsize tstSetsize; +CTestSetsize2 tstSetsize2; +CTestCreateStream2 tstCreateStream2; +CTestDestroyElement tstDestroyElement; +CTestSwitchToFile tstSwitchToFile; +CTestCommit3 tstCommit3; +CTestCommit4 tstCommit4; + +CTestCase *atst[] = +{ +#if defined(BREADTHTEST) + &tstStgCreate, + &tstStgOpen, + &tstCreateStorage, + &tstCreateStream, + &tstWrite, + &tstCommit, + &tstCommit2, + &tstOpenStream, + &tstOpenStorage, + &tstWrite2, + &tstWrite3, + &tstSetsize, + &tstCreateStream2, + &tstDestroyElement, + &tstSetsize2, + &tstSwitchToFile, + &tstCommit3, +#endif + &tstCommit4 +}; + +int TestCount(void) +{ + return(sizeof(atst)/sizeof(CTestCase *)); +} + +CTestCase *TestItem(int iTest) +{ + return(atst[iTest]); +} |