//------------------------------------------------------------------------- // // Microsoft OLE // Copyright (C) Microsoft Corporation, 1994 - 1995. // // File: comtests.cxx // // Contents: storage base tests common to IStorage and IStream methoods // // Functions: // // History: 29-May-1996 NarindK Created. // 27-Mar-97 SCousens Conversionified // //-------------------------------------------------------------------------- #include #pragma hdrstop #include "init.hxx" //---------------------------------------------------------------------------- // // Test: COMTEST_100 // // Synopsis:Create a root docfile with a child IStorage and a child IStream. // Commit the root docfile. // // Add a random number of refcounts to IStorage via AddRef() method. // loop to release the refs, each release is followed by a Stat. After // the last ref (that we added) is released, release the ref created // during the Create... call. This frees the real object. Repeat for // the child IStream. // // Arguments: [argc] // [argv] // // Returns: HRESULT // // History: 29-May-1996 NarindK Created. // // Notes: This test runs in direct, transacted, and transacted deny write // modes // // New Test Notes: // 1. Old File: ADDREF.CXX // 2. Old name of test : MiscAddRef // New Name of test : COMTEST_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:COMTEST-100 // /dfRootMode:dirReadWriteShEx /dfStgMode:dirReadWriteShEx // b. stgbase /seed:2 /dfdepth:0-0 /dfstg:0-0 /dfstm:0-0 /t:COMTEST-100 // /dfRootMode:xactReadWriteShEx /dfStgMode:xactReadWriteShEx // c. stgbase /seed:2 /dfdepth:0-0 /dfstg:0-0 /dfstm:0-0 /t:COMTEST-100 // /dfRootMode:xactReadWriteShDenyW /dfStgMode:xactReadWriteShEx // // Conversion: COMTEST_100 // //----------------------------------------------------------------------------- HRESULT COMTEST_100(int argc, char *argv[]) { HRESULT hr = S_OK; ChanceDF *pTestChanceDF = NULL; VirtualDF *pTestVirtualDF = NULL; VirtualCtrNode *pVirtualDFRoot = NULL; DG_STRING *pdgu = NULL; DG_INTEGER *pdgi = NULL; USHORT usErr = 0; VirtualStmNode *pvsnRootNewChildStream = NULL; LPTSTR pRootNewChildStmName = NULL; VirtualCtrNode *pvcnRootNewChildStorage= NULL; LPTSTR pRootNewChildStgName = NULL; ULONG cb = 0; ULONG cusIStorageRefs = 0; ULONG cusIStreamRefs = 0; ULONG i = 0; ULONG cRandomMinSize = 10; ULONG cRandomMaxSize = 100; ULONG cRandomMinVar = 2; ULONG cRandomMaxVar = 16; STATSTG statStg; DH_FUNCENTRY(NULL, DH_LVL_DFLIB, _TEXT("COMTEST_100")); DH_TRACE((DH_LVL_TRACE1, TEXT("--------------------------------------------")) ); DH_TRACE((DH_LVL_TRACE1, TEXT("Test variation COMTEST_100 started.")) ); DH_TRACE((DH_LVL_TRACE1, TEXT("AddRef/Release tests on IStorage/IStream")) ); // 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) { DH_TRACE(( DH_LVL_TRACE1, TEXT("Run Mode for COMTEST_100, Access mode: %lx"), pTestChanceDF->GetRootMode())); } // 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 a random name for child IStorage if(S_OK == hr) { hr = GenerateRandomName(pdgu,MINLENGTH,MAXLENGTH,&pRootNewChildStgName); DH_HRCHECK(hr, TEXT("GenerateRandomName")) ; } // Adds a new storage to the root storage. // ----------- flatfile change --------------- if(!StorageIsFlat()) { // ----------- flatfile change --------------- if(S_OK == hr) { hr = AddStorage( pTestVirtualDF, pVirtualDFRoot, pRootNewChildStgName, pTestChanceDF->GetStgMode()| STGM_CREATE | STGM_FAILIFTHERE, &pvcnRootNewChildStorage); DH_HRCHECK(hr, TEXT("AddStorage")) ; } if(S_OK == hr) { DH_TRACE(( DH_LVL_TRACE1, TEXT("VirtualCtrNode::AddStorage completed successfully."))); } else { DH_TRACE(( DH_LVL_ERROR, TEXT("VirtualCtrNode::AddStorage not successful, hr = 0x%lx."), hr)); } // ----------- flatfile change --------------- } // ----------- flatfile change --------------- // Adds a new stream to the root storage. if(S_OK == hr) { // Generate random name for stream hr = GenerateRandomName(pdgu,MINLENGTH,MAXLENGTH,&pRootNewChildStmName); DH_HRCHECK(hr, TEXT("GenerateRandomName")) ; } if (S_OK == hr) { // Generate random size for stream. usErr = pdgi->Generate(&cb, cRandomMinSize, cRandomMaxSize); if (DG_RC_SUCCESS != usErr) { hr = E_FAIL; } } if(S_OK == hr) { hr = AddStream( pTestVirtualDF, pVirtualDFRoot, pRootNewChildStmName, cb, STGM_READWRITE | STGM_SHARE_EXCLUSIVE | STGM_FAILIFTHERE, &pvsnRootNewChildStream); DH_HRCHECK(hr, TEXT("AddStream")) ; } if(S_OK == hr) { DH_TRACE(( DH_LVL_TRACE1, TEXT("VirtualStmNode::AddStream completed successfully."))); } else { DH_TRACE(( DH_LVL_ERROR, TEXT("VirtualStmNode::AddStream not successful, hr = 0x%lx."), hr)); } // Commit the root storage. 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_ERROR, TEXT("VirtualCtrNode::Commit unsuccessful, hr = 0x%lx."), hr)); } // ----------- flatfile change --------------- if(!StorageIsFlat()) { // ----------- flatfile change --------------- // add from 2 to 16 ref counts to child IStorage object and then // release each one followed by a Stat() call. The ref count should // be decremented after each release. There will already be one // ref count from the IStorage create call, so all Stat() calls in // the loop should be on a valid object. Finally, release remaining // IStorage (this is the ref from the creation) if (S_OK == hr) { // Generate random number for ref counts to be done. usErr = pdgi->Generate(&cusIStorageRefs, cRandomMinVar, cRandomMaxVar); if (DG_RC_SUCCESS != usErr) { hr = E_FAIL; } } for (i=0; i < cusIStorageRefs; i++) { // AddRef the storage hr = pvcnRootNewChildStorage->AddRefCount(); if (S_OK == hr) { DH_TRACE(( DH_LVL_TRACE1, TEXT("VirtualCtrNode::AddRefCount completed successfully."))); } else { DH_TRACE(( DH_LVL_ERROR, TEXT("VirtualCtrNode::AddRefCount unsuccessful, hr = 0x%lx."), hr)); break; } } while ((cusIStorageRefs--) && (S_OK == hr)) { // Close the storage hr = pvcnRootNewChildStorage->Close(); if (S_OK == hr) { DH_TRACE(( DH_LVL_TRACE1, TEXT("VirtualCtrNode::Close completed successfully."))); } else { DH_TRACE(( DH_LVL_ERROR, TEXT("VirtualCtrNode::Close unsuccessful, hr = 0x%lx."), hr)); } if (S_OK == hr) { // Stat the storage hr = pvcnRootNewChildStorage->Stat(&statStg, STATFLAG_NONAME); if (S_OK == hr) { DH_TRACE(( DH_LVL_TRACE1, TEXT("VirtualCtrNode::Stat completed successfully."))); } else { DH_TRACE(( DH_LVL_ERROR, TEXT("VirtualCtrNode::Stat unsuccessful, hr = 0x%lx."), hr)); } } } // Close the root storage if (S_OK == hr) { hr = pvcnRootNewChildStorage->Close(); } if (S_OK == hr) { DH_TRACE(( DH_LVL_TRACE1, TEXT("VirtualCtrNode::Close completed successfully."))); } else { DH_TRACE(( DH_LVL_ERROR, TEXT("VirtualCtrNode::Close unsuccessful, hr = 0x%lx."), hr)); } // ----------- flatfile change --------------- } // ----------- flatfile change --------------- // add from 2 to 16 ref counts to child IStream object and then // release each one followed by a Stat() call. The ref count should // be decremented after each release. There will already be one // ref count from the IStream create call, so all Stat() calls in // the loop should be on a valid object. Finally, release remaining // IStream (this is the ref from the creation) if (S_OK == hr) { // Generate random number for ref counts to be done. usErr = pdgi->Generate(&cusIStreamRefs, cRandomMinVar, cRandomMaxVar); if (DG_RC_SUCCESS != usErr) { hr = E_FAIL; } } for (i=0; i < cusIStreamRefs; i++) { // Addref the stream hr = pvsnRootNewChildStream->AddRefCount(); if (S_OK == hr) { DH_TRACE(( DH_LVL_TRACE1, TEXT("VirtualStmNode::AddRefCount completed successfully."))); } else { DH_TRACE(( DH_LVL_ERROR, TEXT("VirtualStmNode::AddRefCount unsuccessful, hr = 0x%lx."), hr)); break; } } while ((cusIStreamRefs--) && (S_OK == hr)) { // Clsoe the stream hr = pvsnRootNewChildStream->Close(); if (S_OK == hr) { DH_TRACE(( DH_LVL_TRACE1, TEXT("VirtualStmNode::Close completed successfully."))); } else { DH_TRACE(( DH_LVL_ERROR, TEXT("VirtualStmNode::Close unsuccessful, hr = 0x%lx."), hr)); } if (S_OK == hr) { // Stat the stream hr = pvsnRootNewChildStream->Stat(&statStg, STATFLAG_NONAME); if (S_OK == hr) { DH_TRACE(( DH_LVL_TRACE1, TEXT("VirtualStmNode::Stat completed successfully."))); } else { DH_TRACE(( DH_LVL_ERROR, TEXT("VirtualStmNode::Stat unsuccessful, hr = 0x%lx."), hr)); } } } // Close the stream if (S_OK == hr) { hr = pvsnRootNewChildStream->Close(); } if (S_OK == hr) { DH_TRACE(( DH_LVL_TRACE1, TEXT("VirtualStmNode::Close completed successfully."))); } else { DH_TRACE(( DH_LVL_ERROR, TEXT("VirtualStmNode::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 COMTEST_100 passed.")) ); } else { DH_LOG(( LOG_FAIL, TEXT("Test variation COMTEST_100 failed, hr = 0x%lx."), hr) ); } // Cleanup CleanupTestDocfile (&pVirtualDFRoot, &pTestVirtualDF, &pTestChanceDF, S_OK == hr); // Delete strings if(NULL != pRootNewChildStgName) { delete pRootNewChildStgName; pRootNewChildStgName = NULL; } if(NULL != pRootNewChildStmName) { delete pRootNewChildStmName; pRootNewChildStmName = NULL; } // Stop logging the test DH_TRACE((DH_LVL_TRACE1, TEXT("Test variation COMTEST_100 finished")) ); DH_TRACE((DH_LVL_TRACE1, TEXT("--------------------------------------------")) ); return hr; } //---------------------------------------------------------------------------- // // Test: COMTEST_101 // // Synopsis: Regression test for root docfile creation, IStorage creation, // embedded stream creation/read/write, and IStorage commit // operations. // // Arguments: [argc] // [argv] // // Returns: HRESULT // // History: 29-May-1996 NarindK Created. // // Notes: This test runs in direct, transacted, and transacted deny write // modes // // New Test Notes: // 1. Old File: DFTEST.CXX // 2. Old name of test : // New Name of test : COMTEST_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:COMTEST-101 // /dfRootMode:dirReadWriteShEx /dfStgMode:dirReadWriteShEx // b. stgbase /seed:2 /dfdepth:0-0 /dfstg:0-0 /dfstm:0-0 /t:COMTEST-101 // /dfRootMode:xactReadWriteShEx /dfStgMode:xactReadWriteShEx // c. stgbase /seed:2 /dfdepth:0-0 /dfstg:0-0 /dfstm:0-0 /t:COMTEST-101 // /dfRootMode:xactReadWriteShDenyW /dfStgMode:xactReadWriteShEx // // Conversion: COMTEST_101 // //----------------------------------------------------------------------------- HRESULT COMTEST_101(int argc, char *argv[]) { HRESULT hr = S_OK; ChanceDF *pTestChanceDF = NULL; VirtualDF *pTestVirtualDF = NULL; VirtualCtrNode *pVirtualDFRoot = NULL; DG_INTEGER *pdgi = NULL; DG_STRING *pdgu = NULL; USHORT usErr = 0; VirtualStmNode *pvsnRootNewChildStream = NULL; LPTSTR pRootNewChildStmName = NULL; VirtualCtrNode *pvcnRootNewChildStorage= NULL; LPTSTR pRootNewChildStgName = NULL; LPTSTR pwcsBuffer = NULL; LPTSTR pReadBuffer = NULL; ULONG cb = 0; ULONG culWritten = 0; ULONG culRead = 0; ULONG cRandomMinSize = 10; ULONG cRandomMaxSize = 100; DH_FUNCENTRY(NULL, DH_LVL_DFLIB, _TEXT("COMTEST_101")); DH_TRACE((DH_LVL_TRACE1, TEXT("--------------------------------------------")) ); DH_TRACE((DH_LVL_TRACE1, TEXT("Test variation COMTEST_101 started.")) ); DH_TRACE((DH_LVL_TRACE1, TEXT("Regression test for Docfile/IStorage/IStream creation.")) ); DH_TRACE((DH_LVL_TRACE1, TEXT("IStream Read/Write, IStorage Commit opertaions.")) ); // 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) { DH_TRACE(( DH_LVL_TRACE1, TEXT("Run Mode for COMTEST_101, Access mode: %lx"), pTestChanceDF->GetRootMode())); } // 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); } // Generate a random name for child IStorage if(S_OK == hr) { hr = GenerateRandomName(pdgu,MINLENGTH,MAXLENGTH,&pRootNewChildStgName); DH_HRCHECK(hr, TEXT("GenerateRandomName")) ; } // ----------- flatfile change --------------- if(!StorageIsFlat()) { // ----------- flatfile change --------------- // Adds a new storage to the root storage. if(S_OK == hr) { hr = AddStorage( pTestVirtualDF, pVirtualDFRoot, pRootNewChildStgName, pTestChanceDF->GetStgMode()| STGM_CREATE, &pvcnRootNewChildStorage); DH_HRCHECK(hr, TEXT("AddStorage")) ; } if(S_OK == hr) { DH_TRACE(( DH_LVL_TRACE1, TEXT("VirtualCtrNode::AddStorage completed successfully."))); } else { DH_TRACE(( DH_LVL_ERROR, TEXT("VirtualCtrNode::AddStorage not successful, hr = 0x%lx."), hr )); } // ----------- flatfile change --------------- } // ----------- flatfile change --------------- // Generate a random name for child IStream if(S_OK == hr) { hr = GenerateRandomName(pdgu,MINLENGTH,MAXLENGTH,&pRootNewChildStmName); DH_HRCHECK(hr, TEXT("GenerateRandomName")) ; } if (S_OK == hr) { // Generate random size for stream. usErr = pdgi->Generate(&cb, cRandomMinSize, cRandomMaxSize); if (DG_RC_SUCCESS != usErr) { hr = E_FAIL; } } // Adds a new stream to the root storage. if(S_OK == hr) { hr = AddStream( pTestVirtualDF, pVirtualDFRoot, pRootNewChildStmName, cb, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, &pvsnRootNewChildStream); DH_HRCHECK(hr, TEXT("AddStream")) ; } if(S_OK == hr) { DH_TRACE(( DH_LVL_TRACE1, TEXT("VirtualStmNode::AddStream completed successfully."))); } else { DH_TRACE(( DH_LVL_ERROR, TEXT("VirtualStmNode::AddStream not successful, hr = 0x%lx."), hr)); } // Call VirtualStmNode::Write to create random bytes in the stream. For // our test purposes, we generate a random string of size cb using // GenerateRandomString function. if(S_OK == hr) { hr = GenerateRandomString(pdgu, cb, cb, &pwcsBuffer); DH_HRCHECK(hr, TEXT("GenerateRandomString")) ; } if (S_OK == hr) { hr = pvsnRootNewChildStream->Write( pwcsBuffer, cb, &culWritten); } if (S_OK == hr) { DH_TRACE(( DH_LVL_TRACE1, TEXT("IStream::Write function completed successfully."))); } else { DH_TRACE(( DH_LVL_ERROR, TEXT("IStream::Write function wasn't successful, hr = 0x%lx."), hr)); } // Close the IStream if (S_OK == hr) { hr = pvsnRootNewChildStream->Close(); } if (S_OK == hr) { DH_TRACE(( DH_LVL_TRACE1, TEXT("VirtualStmNode::Close completed successfully."))); } else { DH_TRACE(( DH_LVL_ERROR, TEXT("VirtualStmNode::Close unsuccessful, hr = 0x%lx."), hr)); } // ----------- flatfile change --------------- if(!StorageIsFlat()) { // ----------- flatfile change --------------- // Close the IStorage if (S_OK == hr) { hr = pvcnRootNewChildStorage->Close(); } if (S_OK == hr) { DH_TRACE(( DH_LVL_TRACE1, TEXT("VirtualCtrNode::Close completed successfully."))); } else { DH_TRACE(( DH_LVL_ERROR, TEXT("VirtualCtrNode::Close unsuccessful, hr = 0x%lx."), hr)); } // ----------- flatfile change --------------- } // ----------- flatfile change --------------- // Commit the DocFile 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_ERROR, TEXT("VirtualCtrNode::Commit unsuccessful, hr = 0x%lx."), hr)); } // Close the 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_ERROR, TEXT("VirtualCtrNode::Close unsuccessful, hr = 0x%lx."), hr)); } // Open the Root DocFile if (S_OK == hr) { hr = pVirtualDFRoot->OpenRoot( NULL, STGM_READWRITE | 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_ERROR, TEXT("VirtualCtrNode::Open unsuccessful, hr = 0x%lx."), hr)); } // ----------- flatfile change --------------- if(!StorageIsFlat()) { // ----------- flatfile change --------------- // Open the embedded IStorage if (S_OK == hr) { hr = pvcnRootNewChildStorage->Open( NULL, STGM_READWRITE | 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_ERROR, TEXT("VirtualCtrNode::Open unsuccessful, hr = 0x%lx."), hr)); } // ----------- flatfile change --------------- } // ----------- flatfile change --------------- // Open the IStream if (S_OK == hr) { hr = pvsnRootNewChildStream->Open( NULL, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 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_ERROR, TEXT("VirtualStmNode::Open unsuccessful, hr = 0x%lx."), hr)); } // Read the IStream. if (S_OK == hr) { pReadBuffer = new TCHAR [cb]; if(NULL == pReadBuffer) { hr = E_OUTOFMEMORY; } } if(S_OK == hr) { memset(pReadBuffer, '\0', cb); hr = pvsnRootNewChildStream->Read( pReadBuffer, cb, &culRead); } if (S_OK == hr) { DH_TRACE(( DH_LVL_TRACE1, TEXT("IStream::Read function completed successfully."))); } else { DH_TRACE(( DH_LVL_ERROR, TEXT("IStream::Read function wasn't successful, hr = 0x%lx."), hr)); } // Close the IStream if (S_OK == hr) { hr = pvsnRootNewChildStream->Close(); } if (S_OK == hr) { DH_TRACE(( DH_LVL_TRACE1, TEXT("VirtualStmNode::Close completed successfully."))); } else { DH_TRACE(( DH_LVL_ERROR, TEXT("VirtualStmNode::Close unsuccessful, hr = 0x%lx."), hr)); } // ----------- flatfile change --------------- if(!StorageIsFlat()) { // ----------- flatfile change --------------- // Close the IStorage if (S_OK == hr) { hr = pvcnRootNewChildStorage->Close(); } if (S_OK == hr) { DH_TRACE(( DH_LVL_TRACE1, TEXT("VirtualCtrNode::Close completed successfully."))); } else { DH_TRACE(( DH_LVL_ERROR, TEXT("VirtualCtrNode::Close unsuccessful."))); } // ----------- flatfile change --------------- } // ----------- flatfile change --------------- // Close the 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_ERROR, 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 COMTEST_101 passed.")) ); } else { DH_LOG(( LOG_FAIL, TEXT("Test variation COMTEST_101 failed, hr = 0x%lx."), hr) ); } // Cleanup CleanupTestDocfile (&pVirtualDFRoot, &pTestVirtualDF, &pTestChanceDF, S_OK == hr); // Delete strings if(NULL != pRootNewChildStgName) { delete pRootNewChildStgName; pRootNewChildStgName = NULL; } if(NULL != pRootNewChildStmName) { delete pRootNewChildStmName; pRootNewChildStmName = NULL; } if(NULL != pwcsBuffer) { delete []pwcsBuffer; pwcsBuffer = NULL; } if(NULL != pReadBuffer) { delete []pReadBuffer; pReadBuffer = NULL; } if(NULL != pRootNewChildStmName) { delete pRootNewChildStmName; pRootNewChildStmName = NULL; } // Stop logging the test DH_TRACE((DH_LVL_TRACE1, TEXT("Test variation COMTEST_101 finished")) ); DH_TRACE((DH_LVL_TRACE1, TEXT("--------------------------------------------")) ); return hr; } //---------------------------------------------------------------------------- // // Test: COMTEST_102 // // Synopsis: Create a root docfile with random name. Create a child IStorage // and a child IStream in this docfile. Attempt to do iilegal op // erations on this docfile - creating/instantiating storages/streams // /root docfiles with existing names with STGM_FAILIFTHERE flag. Also // attempts various illegal grfmodes. // // Arguments: [argc] // [argv] // // Returns: HRESULT // // History: 29-May-1996 NarindK Created. // // Notes: This test runs in direct, transacted, and transacted deny write // modes // // New Test Notes: // 1. Old File: IINORM.CXX // 2. Old name of test : IllegitInstEnumNormal Test // New Name of test : COMTEST_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:COMTEST-102 // /dfRootMode:dirReadWriteShEx /dfStgMode:dirReadWriteShEx // b. stgbase /seed:2 /dfdepth:0-0 /dfstg:0-0 /dfstm:0-0 /t:COMTEST-102 // /dfRootMode:xactReadWriteShEx /dfStgMode:xactReadWriteShEx // c. stgbase /seed:2 /dfdepth:0-0 /dfstg:0-0 /dfstm:0-0 /t:COMTEST-102 // /dfRootMode:xactReadWriteShDenyW /dfStgMode:xactReadWriteShEx // // Conversion: COMTEST_102 // // BUGBUG: Use Random Commit modes //----------------------------------------------------------------------------- HRESULT COMTEST_102(int argc, char *argv[]) { HRESULT hr = S_OK; ChanceDF *pTestChanceDF = NULL; VirtualDF *pTestVirtualDF = NULL; VirtualCtrNode *pVirtualDFRoot = NULL; DG_INTEGER *pdgi = NULL; DG_STRING *pdgu = NULL; USHORT usErr = 0; VirtualStmNode *pvsnRootNewChildStream = NULL; LPTSTR pRootNewChildStmName = NULL; VirtualCtrNode *pvcnRootNewChildStorage = NULL; LPTSTR pRootNewChildStgName = NULL; ULONG cb = 0; VirtualCtrNode *pvcnRootSecondChildStorage = NULL; VirtualCtrNode *pvcnRootThirdChildStorage = NULL; VirtualStmNode *pvcnRootSecondChildStream = NULL; VirtualStmNode *pvcnRootThirdChildStream = NULL; LPSTORAGE pRootStg = NULL; LPSTORAGE pNonExistingStg = NULL; LPSTREAM pNonExistingStm = NULL; ULONG cRandomMinSize = 10; ULONG cRandomMaxSize = 100; DH_FUNCENTRY(NULL, DH_LVL_DFLIB, _TEXT("COMTEST_102")); DH_TRACE((DH_LVL_TRACE1, TEXT("--------------------------------------------")) ); DH_TRACE((DH_LVL_TRACE1, TEXT("Test variation COMTEST_102 started.")) ); DH_TRACE((DH_LVL_TRACE1, TEXT("Illegal operations on Docfile/IStorage/IStream.")) ); DH_TRACE((DH_LVL_TRACE1, TEXT("Instantiating with existing names, invalid grfmodes.")) ); // 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) { DH_TRACE(( DH_LVL_TRACE1, TEXT("Run Mode for COMTEST_102, Access mode: %lx"), pTestChanceDF->GetRootMode())); } // 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); } // ----------- flatfile change --------------- if(!StorageIsFlat()) { // ----------- flatfile change --------------- // Generate a random name for child IStorage if(S_OK == hr) { hr = GenerateRandomName(pdgu,MINLENGTH,MAXLENGTH,&pRootNewChildStgName); DH_HRCHECK(hr, TEXT("GenerateRandomName")) ; } // Adds a new storage to the root storage. if(S_OK == hr) { hr = AddStorage( pTestVirtualDF, pVirtualDFRoot, pRootNewChildStgName, pTestChanceDF->GetStgMode()| STGM_CREATE, &pvcnRootNewChildStorage); DH_HRCHECK(hr, TEXT("AddStorage")) ; } if(S_OK == hr) { DH_TRACE(( DH_LVL_TRACE1, TEXT("VirtualCtrNode::AddStorage completed successfully."))); } else { DH_TRACE(( DH_LVL_ERROR, TEXT("VirtualCtrNode::AddStorage not successful, hr = 0x%lx."), hr)); } // Commit the Storage if(S_OK == hr) { hr = pvcnRootNewChildStorage->Commit(STGC_DEFAULT); } if (S_OK == hr) { DH_TRACE(( DH_LVL_TRACE1, TEXT("VirtualCtrNode::Commit completed successfully."))); } else { DH_TRACE(( DH_LVL_ERROR, TEXT("VirtualCtrNode::Commit unsuccessful, hr = 0x%lx."), hr)); } // Close the IStorage if (S_OK == hr) { hr = pvcnRootNewChildStorage->Close(); } if (S_OK == hr) { DH_TRACE(( DH_LVL_TRACE1, TEXT("VirtualCtrNode::Close completed successfully."))); } else { DH_TRACE(( DH_LVL_ERROR, TEXT("VirtualCtrNode::Close unsuccessful, hr = 0x%lx."), hr)); } // ----------- flatfile change --------------- } // ----------- flatfile change --------------- // Generate a random name for child IStream if(S_OK == hr) { hr = GenerateRandomName(pdgu,MINLENGTH,MAXLENGTH,&pRootNewChildStmName); DH_HRCHECK(hr, TEXT("GenerateRandomName")) ; } if (S_OK == hr) { // Generate random size for stream. usErr = pdgi->Generate(&cb, cRandomMinSize, cRandomMaxSize); if (DG_RC_SUCCESS != usErr) { hr = E_FAIL; } } // Adds a new stream to the root storage. if(S_OK == hr) { hr = AddStream( pTestVirtualDF, pVirtualDFRoot, pRootNewChildStmName, cb, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, &pvsnRootNewChildStream); DH_HRCHECK(hr, TEXT("AddStream")) ; } if(S_OK == hr) { DH_TRACE(( DH_LVL_TRACE1, TEXT("VirtualStmNode::AddStream completed successfully."))); } else { DH_TRACE(( DH_LVL_ERROR, TEXT("VirtualStmNode::AddStream not successful, hr = 0x%lx."), hr)); } // Close the IStream if (S_OK == hr) { hr = pvsnRootNewChildStream->Close(); } if (S_OK == hr) { DH_TRACE(( DH_LVL_TRACE1, TEXT("VirtualStmNode::Close completed successfully."))); } else { DH_TRACE(( DH_LVL_ERROR, TEXT("VirtualStmNode::Close unsuccessful, hr = 0x%lx."), hr)); } // Commit the Root DocFile 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_ERROR, TEXT("VirtualCtrNode::Commit unsuccessful, hr = 0x%lx."), hr)); } // ----------- flatfile change --------------- if(!StorageIsFlat()) { // ----------- flatfile change --------------- // Attempt to create another Child IStorage with same name as existing // IStorage above and STGM_FAILIFTHERE flag. if(S_OK == hr) { // This call should fail with STG_E_FILEALREADYEXISTS error. hr = AddStorage( pTestVirtualDF, pVirtualDFRoot, pRootNewChildStgName, pTestChanceDF->GetStgMode()| STGM_FAILIFTHERE, &pvcnRootSecondChildStorage); if(STG_E_FILEALREADYEXISTS == hr) { DH_TRACE((DH_LVL_TRACE1, TEXT("hr = 0x%lx received as expected."), hr)); hr = S_OK; } else { DH_TRACE((DH_LVL_ERROR, TEXT("Got unexpected hr = 0x%lx "), hr)); if(S_OK == hr) { hr = S_FALSE; } } } // Attempt to create another Child IStorage with same name as existing // IStream above and STGM_FAILIFTHERE flag. if(S_OK == hr) { // This call should fail with STG_E_FILEALREADYEXISTS error. hr = AddStorage( pTestVirtualDF, pVirtualDFRoot, pRootNewChildStmName, pTestChanceDF->GetStgMode()| STGM_FAILIFTHERE, &pvcnRootSecondChildStorage); if(STG_E_FILEALREADYEXISTS == hr) { DH_TRACE((DH_LVL_TRACE1, TEXT("hr = 0x%lx received as expected."), hr)); hr = S_OK; } else { DH_TRACE((DH_LVL_ERROR, TEXT("Got unexpected hr = 0x%lx "), hr)); if(S_OK == hr) { hr = S_FALSE; } } } // Attempt to create another Child IStorage with same name as existing // IStorage above and STGM_CREATE flag. if(S_OK == hr) { // This call should pass. hr = AddStorage( pTestVirtualDF, pVirtualDFRoot, pRootNewChildStgName, pTestChanceDF->GetStgMode()| STGM_CREATE, &pvcnRootSecondChildStorage); if(S_OK == hr) { DH_TRACE((DH_LVL_TRACE1, TEXT("hr = 0x%lx received as expected."), hr)); } else { DH_TRACE((DH_LVL_ERROR, TEXT("Got unexpected hr = 0x%lx "), hr)); } } // Commit the above Storage if(S_OK == hr) { hr = pvcnRootSecondChildStorage->Commit(STGC_DEFAULT); if (S_OK == hr) { DH_TRACE(( DH_LVL_TRACE1, TEXT("VirtualCtrNode::Commit completed successfully."))); } else { DH_TRACE(( DH_LVL_ERROR, TEXT("VirtualCtrNode::Commit unsuccessful, hr = 0x%lx."), hr)); } } // Now with the above IStorage created and instantiated, attempt to create // another Child IStorage with same name as above which is both existing // and instantiated. Should give STG_E_ACCESSDENIED error. if(S_OK == hr) { // This call should give STG_E_ACCESSDENIED error. hr = AddStorage( pTestVirtualDF, pVirtualDFRoot, pRootNewChildStgName, pTestChanceDF->GetStgMode()| STGM_FAILIFTHERE, &pvcnRootThirdChildStorage); if(STG_E_ACCESSDENIED == hr) { DH_TRACE((DH_LVL_ERROR, TEXT("hr = 0x%lx received as expected."), hr)); hr = S_OK; } else { DH_TRACE((DH_LVL_ERROR, TEXT("Got unexpected hr = 0x%lx "), hr)); if(S_OK == hr) { hr = S_FALSE; } } } // Close the pvcnRootSecondChildStorage which is instantiated. if (S_OK == hr) { hr = pvcnRootSecondChildStorage->Close(); if (S_OK == hr) { DH_TRACE(( DH_LVL_TRACE1, TEXT("VirtualCtrNode::Close completed successfully."))); } else { DH_TRACE(( DH_LVL_ERROR, TEXT("VirtualCtrNode::Close unsuccessful, hr =0x%lx."), hr)); } } // ----------- flatfile change --------------- } // ----------- flatfile change --------------- // Repeat the above with streams // Attempt to create another Child IStream with same name as existing // IStream above and STGM_FAILIFTHERE flag. if(S_OK == hr) { // This call should fail with STG_E_FILEALREADYEXISTS error. hr = AddStream( pTestVirtualDF, pVirtualDFRoot, pRootNewChildStmName, cb, STGM_READWRITE | STGM_SHARE_EXCLUSIVE| STGM_FAILIFTHERE, &pvcnRootSecondChildStream); if(STG_E_FILEALREADYEXISTS == hr) { DH_TRACE((DH_LVL_TRACE1, TEXT("hr = 0x%lx received as expected."), hr)); hr = S_OK; } else { DH_TRACE((DH_LVL_ERROR, TEXT("Got unexpected hr = 0x%lx "), hr)); if(S_OK == hr) { hr = S_FALSE; } } } // ----------- flatfile change --------------- if(!StorageIsFlat()) { // ----------- flatfile change --------------- // Attempt to create another Child IStorage with same name as existing // IStream above and STGM_FAILIFTHERE flag. if(S_OK == hr) { // This call should fail with STG_E_FILEALREADYEXISTS error. hr = AddStream( pTestVirtualDF, pVirtualDFRoot, pRootNewChildStgName, cb, STGM_READWRITE | STGM_SHARE_EXCLUSIVE| STGM_FAILIFTHERE, &pvcnRootSecondChildStream); if(STG_E_FILEALREADYEXISTS == hr) { DH_TRACE((DH_LVL_TRACE1, TEXT("hr = 0x%lx received as expected."), hr)); hr = S_OK; } else { DH_TRACE((DH_LVL_ERROR, TEXT("Got unexpected hr = 0x%lx "), hr)); if(S_OK == hr) { hr = S_FALSE; } } } // ----------- flatfile change --------------- } // ----------- flatfile change --------------- // Attempt to create another Child IStorage with same name as existing // IStorage above and STGM_CREATE flag. if(S_OK == hr) { // This call should pass. hr = AddStream( pTestVirtualDF, pVirtualDFRoot, pRootNewChildStmName, cb, STGM_READWRITE | STGM_SHARE_EXCLUSIVE | STGM_CREATE, &pvcnRootSecondChildStream); if(S_OK == hr) { DH_TRACE((DH_LVL_TRACE1, TEXT("hr = 0x%lx received as expected."), hr)); } else { DH_TRACE((DH_LVL_ERROR, TEXT("Got unexpected hr = 0x%lx "), hr)); } } // Now with the above IStream created and instantiated, attempt to create // another Child IStream with same name as above which is both existing // and instantiated. Should give STG_E_ACCESSDENIED error. if(S_OK == hr) { // This call should give STG_E_ACCESSDENIED error. hr = AddStream( pTestVirtualDF, pVirtualDFRoot, pRootNewChildStmName, cb, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, &pvcnRootThirdChildStream); if(STG_E_ACCESSDENIED == hr) { DH_TRACE((DH_LVL_TRACE1, TEXT("hr = 0x%lx received as expected."), hr)); hr = S_OK; } else { DH_TRACE((DH_LVL_ERROR, TEXT("Got unexpected hr = 0x%lx "), hr)); if(S_OK == hr) { hr = S_FALSE; } } } // Close the pvcnRootSecondChildStream which is instantiated. if (S_OK == hr) { hr = pvcnRootSecondChildStream->Close(); if (S_OK == hr) { DH_TRACE(( DH_LVL_TRACE1, TEXT("VirtualStmNode::Close completed successfully."))); } else { DH_TRACE(( DH_LVL_ERROR, TEXT("VirtualStmNode::Close unsuccessful, hr =0x%lx."), hr)); } } // Attempt to open a non existing IStorage/IStreams // Close the 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_ERROR, TEXT("VirtualCtrNode::Close unsuccessful, hr =0x%lx."), hr)); } } // Open the Root DocFile if (S_OK == hr) { hr = pVirtualDFRoot->OpenRoot( NULL, pTestChanceDF->GetRootMode(), 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_ERROR, TEXT("VirtualCtrNode::Open unsuccessful, hr =0x%lx."), hr)); } } if (S_OK == hr) { pRootStg = pVirtualDFRoot->GetIStoragePointer(); DH_ASSERT(NULL != pRootStg); } // Attempt to open a non existing IStorage. This should give an error // STG_E_FILENOTFOUND if (S_OK == hr) { hr = pRootStg->OpenStorage( OLESTR("Non-Existing"), NULL, pTestChanceDF->GetStgMode(), NULL, 0, &pNonExistingStg); // ----------- flatfile change --------------- if(!StorageIsFlat()) { // ----------- flatfile change --------------- if(STG_E_FILENOTFOUND == hr) { DH_TRACE(( DH_LVL_TRACE1, TEXT("hr = 0x%lx received as expected."), hr)); hr = S_OK; } else { DH_TRACE((DH_LVL_ERROR, TEXT("Got unexpected hr = 0x%lx "), hr)); if(S_OK == hr) { hr = S_FALSE; } } // ----------- flatfile change --------------- } else { if(E_NOTIMPL == hr) { DH_TRACE(( DH_LVL_TRACE1, TEXT("hr = 0x%lx received as expected."), hr)); hr = S_OK; } else { DH_TRACE((DH_LVL_ERROR, TEXT("Got unexpected hr = 0x%lx "), hr)); if(S_OK == hr) { hr = S_FALSE; } } } // ----------- flatfile change --------------- } // Attempt to open a non existing IStream. This should give an error // STG_E_FILENOTFOUND if (S_OK == hr) { hr = pRootStg->OpenStream( OLESTR("Non-Existing"), NULL, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &pNonExistingStm); if(STG_E_FILENOTFOUND == hr) { DH_TRACE(( DH_LVL_TRACE1, TEXT("hr = 0x%lx received as expected."), hr)); hr = S_OK; } else { DH_TRACE((DH_LVL_ERROR, TEXT("Got unexpected hr = 0x%lx "), hr)); if(S_OK == hr) { hr = S_FALSE; } } } // Close the Root DocFile Storage 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_ERROR, 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 COMTEST_102 passed.")) ); } else { DH_LOG(( LOG_FAIL, TEXT("Test variation COMTEST_102 failed, hr =0x%lx."), hr) ); } // Cleanup CleanupTestDocfile (&pVirtualDFRoot, &pTestVirtualDF, &pTestChanceDF, S_OK == hr); // Delete strings if(NULL != pRootNewChildStgName) { delete pRootNewChildStgName; pRootNewChildStgName = NULL; } if(NULL != pRootNewChildStmName) { delete pRootNewChildStmName; pRootNewChildStmName = NULL; } // Stop logging the test DH_TRACE((DH_LVL_TRACE1, TEXT("Test variation COMTEST_102 finished")) ); DH_TRACE((DH_LVL_TRACE1, TEXT("--------------------------------------------")) ); return hr; } //---------------------------------------------------------------------------- // // Test: COMTEST_103 // // Synopsis: Creates an IStream in the root docfile and writes a random number // of bytes then releases the IStream. Creates an IStorage in the root // docfile and an IStream inside of the IStorage. A random number of // bytes are written to the IStream, the IStream is released, and the // IStorage and root docfile are committed. The IStream in the IStorage // is instantiated and the data is read and verified. The IStorage and // contained IStream are released. The IStream in the root docfile is // instantiated and the data is read and verified. The IStream and // root docfile are then released. // // Arguments: [argc] // [argv] // // Returns: HRESULT // // History: 29-May-1996 NarindK Created. // // Notes: This test runs in direct, transacted, and transacted deny write // modes // // New Test Notes: // 1. Old File: LINORM.CXX // 2. Old name of test : LegitInstEnumNormal Test // New Name of test : COMTEST_103 // 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:COMTEST-103 // /dfRootMode:dirReadWriteShEx /dfStgMode:dirReadWriteShEx // b. stgbase /seed:2 /dfdepth:0-0 /dfstg:0-0 /dfstm:0-0 /t:COMTEST-103 // /dfRootMode:xactReadWriteShEx /dfStgMode:xactReadWriteShEx // c. stgbase /seed:2 /dfdepth:0-0 /dfstg:0-0 /dfstm:0-0 /t:COMTEST-103 // /dfRootMode:xactReadWriteShDenyW /dfStgMode:xactReadWriteShEx // // Conversion: COMTEST_103 // // BUGBUG: Use Random Commit modes //----------------------------------------------------------------------------- HRESULT COMTEST_103(int argc, char *argv[]) { HRESULT hr = S_OK; ChanceDF *pTestChanceDF = NULL; VirtualDF *pTestVirtualDF = NULL; VirtualCtrNode *pVirtualDFRoot = NULL; DG_INTEGER *pdgi = NULL; DG_STRING *pdgu = NULL; USHORT usErr = 0; VirtualStmNode *pvsnRootNewChildStream = NULL; LPTSTR pNewRootStmName = NULL; VirtualCtrNode *pvcnRootNewChildStorage= NULL; LPTSTR pRootNewChildStgName = NULL; VirtualStmNode *pvsnNewChildStream = NULL; LPTSTR pNewChildStmName = NULL; LPTSTR pwcsBuffer = NULL; ULONG culWritten = 0; ULONG cb = 0; ULONG cRandomMinSize = 10; ULONG cRandomMaxSize = 100; BOOL fPass = TRUE; DWCRCSTM dwCRC1; DWCRCSTM dwMemCRC1; DWCRCSTM dwCRC2; DWCRCSTM dwMemCRC2; DH_FUNCENTRY(NULL, DH_LVL_DFLIB, _TEXT("LINORM_1")); DH_TRACE((DH_LVL_TRACE1, TEXT("--------------------------------------------")) ); DH_TRACE((DH_LVL_TRACE1, TEXT("Test variation COMTEST_103 started.")) ); // Initialize CRC values to zero dwCRC1.dwCRCSum=dwCRC2.dwCRCSum=dwMemCRC1.dwCRCSum=dwMemCRC2.dwCRCSum=0; // 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) { DH_TRACE(( DH_LVL_TRACE1, TEXT("Run Mode for COMTEST_103, Access mode: %lx"), pTestChanceDF->GetRootMode())); } // 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 stream to a root storage. if (S_OK == hr) { // Generate random size for stream. usErr = pdgi->Generate(&cb, cRandomMinSize, cRandomMaxSize); if (DG_RC_SUCCESS != usErr) { hr = E_FAIL; } } // Generate a random name for Root's child IStream if(S_OK == hr) { hr = GenerateRandomName(pdgu,MINLENGTH,MAXLENGTH, &pNewRootStmName); DH_HRCHECK(hr, TEXT("GenerateRandomName")) ; } if(S_OK == hr) { hr = AddStream( pTestVirtualDF, pVirtualDFRoot, pNewRootStmName, cb, STGM_READWRITE | STGM_SHARE_EXCLUSIVE | STGM_FAILIFTHERE, &pvsnRootNewChildStream); DH_HRCHECK(hr, TEXT("AddStream")) ; } if(S_OK == hr) { DH_TRACE(( DH_LVL_TRACE1, TEXT("VirtualStmNode::AddStream completed successfully."))); } else { DH_TRACE(( DH_LVL_ERROR, TEXT("VirtualStmNode::AddStream not successful, hr = 0x%lx."), hr)); } // Call VirtualStmNode::Write to create random bytes in the stream. For // our test purposes, we generate a random string of size cb using // GenerateRandomString function. if(S_OK == hr) { hr = GenerateRandomString(pdgu, cb, cb, &pwcsBuffer); DH_HRCHECK(hr, TEXT("GenerateRandomString")) ; } if (S_OK == hr) { hr = pvsnRootNewChildStream->Write( pwcsBuffer, cb, &culWritten); } if (S_OK == hr) { DH_TRACE(( DH_LVL_TRACE1, TEXT("IStream::Write function completed successfully."))); } else { DH_TRACE(( DH_LVL_ERROR, TEXT("IStream::Write function wasn't successful, hr =0x%lx."), hr)); } // Calculate the CRC for stream name and data if(S_OK == hr) { hr = CalculateInMemoryCRCForStm( pvsnRootNewChildStream, pwcsBuffer, cb, &dwMemCRC1); DH_HRCHECK(hr, TEXT("CalculateInMemoryCRCForStm")) ; } // Close the stream if (S_OK == hr) { hr = pvsnRootNewChildStream->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_ERROR, TEXT("VirtualStmNode::Close unsuccessful, hr =0x%lx."), hr)); } if(NULL != pwcsBuffer) { delete pwcsBuffer; pwcsBuffer = NULL; } // ----------- flatfile change --------------- if(!StorageIsFlat()) { // ----------- flatfile change --------------- // Generate a random name for Root's child IStorage if(S_OK == hr) { hr = GenerateRandomName(pdgu,MINLENGTH,MAXLENGTH,&pRootNewChildStgName); DH_HRCHECK(hr, TEXT("GenerateRandomName")) ; } // Adds a new storage to the root. if(S_OK == hr) { hr = AddStorage( pTestVirtualDF, pVirtualDFRoot, pRootNewChildStgName, pTestChanceDF->GetStgMode() | STGM_CREATE | STGM_FAILIFTHERE, &pvcnRootNewChildStorage); DH_HRCHECK(hr, TEXT("AddStorage")) ; } if(S_OK == hr) { DH_TRACE(( DH_LVL_TRACE1, TEXT("VirtualCtrNode::AddStorage completed successfully."))); } else { DH_TRACE(( DH_LVL_ERROR, TEXT("VirtualCtrNode::AddStorage not successful, hr =0x%lx."), hr)); } // Adds a new stream to the new storage. We would add a stream to // newly created substorage "NewTestStg" of our root storage for test. if (S_OK == hr) { // Generate random size for stream. usErr = pdgi->Generate(&cb, cRandomMinSize, cRandomMaxSize); if (DG_RC_SUCCESS != usErr) { hr = E_FAIL; } } // Generate a random name for Root's child IStorage's new child IStream if(S_OK == hr) { hr = GenerateRandomName(pdgu,MINLENGTH,MAXLENGTH, &pNewChildStmName); DH_HRCHECK(hr, TEXT("GenerateRandomName")) ; } if(S_OK == hr) { hr = AddStream( pTestVirtualDF, pvcnRootNewChildStorage, pNewChildStmName, 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_ERROR, TEXT("VirtualStmNode::AddStream not successful, hr =0x%lx."), hr)); } if(S_OK == hr) { hr = GenerateRandomString(pdgu, cb, cb, &pwcsBuffer); DH_HRCHECK(hr, TEXT("GenerateRandomString")) ; } // Write into new stream if (S_OK == hr) { hr = pvsnNewChildStream->Write( pwcsBuffer, cb, &culWritten); } if (S_OK == hr) { DH_TRACE(( DH_LVL_TRACE1, TEXT("IStream::Write function completed successfully."))); } else { DH_TRACE(( DH_LVL_ERROR, TEXT("IStream::Write function wasn't successful, hr =0x%lx."), hr)); } // Calculate the CRC for stream name and data if(S_OK == hr) { hr = CalculateInMemoryCRCForStm( pvsnNewChildStream, pwcsBuffer, cb, &dwMemCRC2); DH_HRCHECK(hr, TEXT("CalculateInMemoryCRCForStm")) ; } // Close the stream 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_ERROR, TEXT("VirtualStmNode::Close unsuccessful, hr =0x%lx."), hr)); } if (S_OK == hr) { hr = pvcnRootNewChildStorage->Commit(STGC_DEFAULT); } if (S_OK == hr) { DH_TRACE(( DH_LVL_TRACE1, TEXT("VirtualCtrNode::Commit completed successfully."))); } else { DH_TRACE(( DH_LVL_ERROR, TEXT("VirtualCtrNode::Commit unsuccessful, hr =0x%lx."), hr)); } 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_ERROR, TEXT("VirtualCtrNode::Commit unsuccessful, hr =0x%lx."), hr)); } if (S_OK == hr) { hr = pvcnRootNewChildStorage->Close(); } if (S_OK == hr) { DH_TRACE(( DH_LVL_TRACE1, TEXT("VirtualCtrNode::Close completed successfully."))); } else { DH_TRACE(( DH_LVL_ERROR, TEXT("VirtualCtrNode::Close unsuccessful, hr =0x%lx."), hr)); } if (S_OK == hr) { hr = pvcnRootNewChildStorage->Open( NULL, pTestChanceDF->GetStgMode(), 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_ERROR, TEXT("VirtualCtrNode::Open unsuccessful, hr =0x%lx."), hr)); } if (S_OK == hr) { hr = pvsnNewChildStream->Open( NULL, STGM_READWRITE | STGM_SHARE_EXCLUSIVE , 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_ERROR, TEXT("VirtualStmNode::Open unsuccessful, hr =0x%lx."), hr)); } if(S_OK == hr) { hr = ReadAndCalculateDiskCRCForStm(pvsnNewChildStream,&dwCRC2); } if (S_OK == hr) { DH_TRACE(( DH_LVL_TRACE1, TEXT("ReadAndCalculateDiskCRCForStm function successful."))); if(dwCRC2.dwCRCSum == dwMemCRC2.dwCRCSum) { DH_TRACE((DH_LVL_TRACE1, TEXT("CRC's for pvsnNewChildStream match."))); } else { DH_TRACE(( DH_LVL_ERROR, TEXT("CRC's for pvsnNewChildStream don't match."))); fPass = FALSE; } } else { DH_TRACE(( DH_LVL_ERROR, TEXT("ReadAndCalculateDiskCRCForStm unsuccessful, hr =0x%lx."), hr)); } // Close the stream 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_ERROR, TEXT("VirtualStmNode::Close unsuccessful, hr =0x%lx."), hr)); } // Close the storage if (S_OK == hr) { hr = pvcnRootNewChildStorage->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_ERROR, TEXT("VirtualCtrNode::Close unsuccessful, hr =0x%lx."), hr)); } // ----------- flatfile change --------------- } // ----------- flatfile change --------------- if (S_OK == hr) { hr = pvsnRootNewChildStream->Open( NULL, STGM_READWRITE | STGM_SHARE_EXCLUSIVE , 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_ERROR, TEXT("VirtualStmNode::Open unsuccessful, hr =0x%lx."), hr)); } // Read and verify if(S_OK == hr) { hr = ReadAndCalculateDiskCRCForStm(pvsnRootNewChildStream,&dwCRC1); } // Compare this CRC with in memory CRC if(S_OK == hr) { DH_TRACE(( DH_LVL_TRACE1, TEXT("ReadAndCalculateDiskCRCForStm function successful."))); if(dwCRC1.dwCRCSum == dwMemCRC1.dwCRCSum) { DH_TRACE(( DH_LVL_TRACE1, TEXT("CRC's for pvsnRootNewChildStream match."))); } else { fPass = FALSE; DH_TRACE(( DH_LVL_ERROR, TEXT("CRC's for pvsnRootNewChildStream do not match."))); } } else { DH_TRACE(( DH_LVL_ERROR, TEXT("ReadAndCalculateDiskCRCForStm unsuccessful, hr =0x%lx."), hr)); } // Close the stream if (S_OK == hr) { hr = pvsnRootNewChildStream->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_ERROR, TEXT("VirtualStmNode::Close unsuccessful, hr =0x%lx."), hr)); } // Close the storage 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_ERROR, TEXT("VirtualCtrNode::Close unsuccessful, hr =0x%lx."), hr)); } // if all goes well till here, the test variation has passed successfully, // if not, then report failure. if ((S_OK == hr) && (TRUE == fPass)) { DH_LOG((LOG_PASS, TEXT("Test variation COMTEST_103 passed.")) ); } else { DH_LOG(( LOG_FAIL, TEXT("Test variation COMTEST_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); //Free buffer if(NULL != pwcsBuffer) { delete pwcsBuffer; pwcsBuffer = NULL; } // Delete strings if(NULL != pRootNewChildStgName) { delete pRootNewChildStgName; pRootNewChildStgName = NULL; } if(NULL != pNewRootStmName) { delete pNewRootStmName; pNewRootStmName = NULL; } if(NULL != pNewChildStmName) { delete pNewChildStmName; pNewChildStmName = NULL; } // Stop logging the test DH_TRACE((DH_LVL_TRACE1, TEXT("Test variation COMTEST-103 finished")) ); DH_TRACE((DH_LVL_TRACE1, TEXT("--------------------------------------------")) ); return hr; } //---------------------------------------------------------------------------- // // Test: COMTEST_104 // // Synopsis:Create a root docfile with a child IStorage and a child IStream. // Commit the root docfile. // // Call QueryInterface on IID_IStorage created for IStorage and see if // succeeded to verify OLE COM Reflexive behaviour. Then through // the interface obtained, query for IID_Imarshal from which query // for IUnknown and from that query for IID_IStorage. This should // pass verifying the Transitive behaiour of IStorage COM interface. // Repeat for the child IStream. // // Arguments: [argc] // [argv] // // Returns: HRESULT // // History: 8-Aug-1996 NarindK Created. // // Notes: This test runs in direct, transacted, and transacted deny write // modes // // New Test Notes: // 1. Old File: STORAGE.CXX very briefly // 2. Old name of test : ISTORAGE_TEST very briefly // New Name of test : COMTEST_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:COMTEST-104 // /dfRootMode:dirReadWriteShEx /dfStgMode:dirReadWriteShEx // b. stgbase /seed:2 /dfdepth:0-0 /dfstg:0-0 /dfstm:0-0 /t:COMTEST-104 // /dfRootMode:xactReadWriteShEx /dfStgMode:xactReadWriteShEx // c. stgbase /seed:2 /dfdepth:0-0 /dfstg:0-0 /dfstm:0-0 /t:COMTEST-104 // /dfRootMode:xactReadWriteShDenyW /dfStgMode:xactReadWriteShEx // // Conversion: COMTEST_104 NO. BUGBUG:IRootStg not supported by NSS yet. maybe later? // //----------------------------------------------------------------------------- HRESULT COMTEST_104(int argc, char *argv[]) { HRESULT hr = S_OK; ChanceDF *pTestChanceDF = NULL; VirtualDF *pTestVirtualDF = NULL; VirtualCtrNode *pVirtualDFRoot = NULL; DG_STRING *pdgu = NULL; DG_INTEGER *pdgi = NULL; USHORT usErr = 0; VirtualStmNode *pvsnRootNewChildStream = NULL; LPTSTR pRootNewChildStmName = NULL; VirtualCtrNode *pvcnRootNewChildStorage= NULL; LPTSTR pRootNewChildStgName = NULL; ULONG cb = 0; ULONG cRandomMinSize = 10; ULONG cRandomMaxSize = 100; ULONG ulRef = 0; LPSTORAGE pQueryChildStorage = NULL; LPSTORAGE pQueryMarshalStorage = NULL; LPSTORAGE pQueryUnknownStorage = NULL; LPSTORAGE pQueryRetChildStorage = NULL; LPSTREAM pQueryChildStream = NULL; LPSTREAM pQueryRetChildStream = NULL; LPSTREAM pQueryMarshalStream = NULL; LPSTREAM pQueryUnknownStream = NULL; // Not for 2phase. Bail. if (DoingDistrib ()) { return S_OK; } DH_FUNCENTRY(NULL, DH_LVL_DFLIB, _TEXT("COMTEST_104")); DH_TRACE((DH_LVL_TRACE1, TEXT("--------------------------------------------")) ); DH_TRACE((DH_LVL_TRACE1, TEXT("Test variation COMTEST_104 started.")) ); DH_TRACE((DH_LVL_TRACE1, TEXT("QueryInterface tests on IStorage/IStream")) ); // 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) { DH_TRACE(( DH_LVL_TRACE1, TEXT("Run Mode for COMTEST_104, Access mode: %lx"), pTestChanceDF->GetRootMode())); } // 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); } // ----------- flatfile change --------------- if(!StorageIsFlat()) { // ----------- flatfile change --------------- // Generate a random name for child IStorage if(S_OK == hr) { hr = GenerateRandomName(pdgu,MINLENGTH,MAXLENGTH,&pRootNewChildStgName); DH_HRCHECK(hr, TEXT("GenerateRandomName")) ; } // Adds a new storage to the root storage. if(S_OK == hr) { hr = AddStorage( pTestVirtualDF, pVirtualDFRoot, pRootNewChildStgName, pTestChanceDF->GetStgMode()| STGM_CREATE | STGM_FAILIFTHERE, &pvcnRootNewChildStorage); DH_HRCHECK(hr, TEXT("AddStorage")) ; } if(S_OK == hr) { DH_TRACE(( DH_LVL_TRACE1, TEXT("VirtualCtrNode::AddStorage completed successfully."))); } else { DH_TRACE(( DH_LVL_ERROR, TEXT("VirtualCtrNode::AddStorage not successful, hr = 0x%lx."), hr)); } // ----------- flatfile change --------------- } // ----------- flatfile change --------------- // Adds a new stream to the root storage. if(S_OK == hr) { // Generate random name for stream hr = GenerateRandomName(pdgu,MINLENGTH,MAXLENGTH,&pRootNewChildStmName); DH_HRCHECK(hr, TEXT("GenerateRandomName")) ; } if (S_OK == hr) { // Generate random size for stream. usErr = pdgi->Generate(&cb, cRandomMinSize, cRandomMaxSize); if (DG_RC_SUCCESS != usErr) { hr = E_FAIL; } } if(S_OK == hr) { hr = AddStream( pTestVirtualDF, pVirtualDFRoot, pRootNewChildStmName, cb, STGM_READWRITE | STGM_SHARE_EXCLUSIVE | STGM_FAILIFTHERE, &pvsnRootNewChildStream); DH_HRCHECK(hr, TEXT("AddStream")) ; } if(S_OK == hr) { DH_TRACE(( DH_LVL_TRACE1, TEXT("VirtualStmNode::AddStream completed successfully."))); } else { DH_TRACE(( DH_LVL_ERROR, TEXT("VirtualStmNode::AddStream not successful, hr = 0x%lx."), hr)); } // Commit the root storage. 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_ERROR, TEXT("VirtualCtrNode::Commit unsuccessful, hr = 0x%lx."), hr)); } // ----------- flatfile change --------------- if(!StorageIsFlat()) { // ----------- flatfile change --------------- // Check Reflexive/Transitive behaviour for IStorage Interface // Do QueryInterface on child storage if(S_OK == hr) { hr = pvcnRootNewChildStorage->QueryInterface( IID_IStorage, (LPVOID *) &pQueryChildStorage); DH_HRCHECK(hr, TEXT("VirtualCtrNode::QueryInterface")) ; } if (S_OK == hr) { DH_ASSERT(NULL != pQueryChildStorage); DH_TRACE(( DH_LVL_TRACE1, TEXT("VirtualCtrNode::QueryInterface completed successfully."))); } else { DH_TRACE(( DH_LVL_ERROR, TEXT("VirtualCtrNode::QueryInterface unsuccessful, hr = 0x%lx."), hr)); } // Query for IRootStorage from the above returned storage pointer, then // query through IRootStorage for IID_IUnknown. From IUnknown, query for // IID_IStorage if(S_OK == hr) { hr = pQueryChildStorage->QueryInterface( IID_IMarshal, (LPVOID *) &pQueryMarshalStorage ); } if (S_OK == hr) { DH_ASSERT(NULL != pQueryMarshalStorage); DH_TRACE(( DH_LVL_TRACE1, TEXT("IStorage::QueryInterface completed successfully."))); } else { DH_TRACE(( DH_LVL_ERROR, TEXT("IStorage::QueryInterface unsuccessful, hr = 0x%lx."), hr)); } // Use the IMarshal interface to QueryInterface an IUnknown // interface. if(S_OK == hr) { hr = pQueryMarshalStorage->QueryInterface( IID_IUnknown, (LPVOID *) &pQueryUnknownStorage ); } // Use the IUnknown interface to QueryInterface an IStorage interface. if(S_OK == hr) { DH_ASSERT(NULL != pQueryUnknownStorage); hr = pQueryUnknownStorage->QueryInterface( IID_IStorage, (LPVOID *) &pQueryRetChildStorage ); } if (S_OK == hr) { DH_TRACE(( DH_LVL_TRACE1, TEXT("IStorage:Reflexive/Transitive OLE COM behaviour passed."))); } else { DH_TRACE(( DH_LVL_ERROR, TEXT("IStorage:Reflexive/Transitive COM behaviour fail,hr=0x%lx"), hr)); } // ----------- flatfile change --------------- } // ----------- flatfile change --------------- // Check Reflexive/Transitive behaviour for IStream Interface // Do QueryInterface on child stream if(S_OK == hr) { hr = pvsnRootNewChildStream->QueryInterface( IID_IStream, (LPVOID *) &pQueryChildStream); DH_HRCHECK(hr, TEXT("VirtualStmNode::QueryInterface")) ; } if (S_OK == hr) { DH_TRACE(( DH_LVL_TRACE1, TEXT("VirtualStmNode::QueryInterface completed successfully."))); } else { DH_TRACE(( DH_LVL_ERROR, TEXT("VirtualStmNode::QueryInterface unsuccessful, hr = 0x%lx."), hr)); } // Query for IMarshal from the above returned storage pointer, then // query through IRootStream for IID_IUnknown. From IUnknown, query for // IID_IStream // --------- flatfile change --------------- if(!StorageIsFlat()) { // --------- flatfile change --------------- if(S_OK == hr) { hr = pQueryChildStream->QueryInterface( IID_IMarshal, (LPVOID *) &pQueryMarshalStream ); } if (S_OK == hr) { DH_ASSERT(NULL != pQueryMarshalStream); DH_TRACE(( DH_LVL_TRACE1, TEXT("IStream::QueryInterface completed successfully."))); } else { DH_TRACE(( DH_LVL_ERROR, TEXT("IStream::QueryInterface unsuccessful, hr = 0x%lx."), hr)); } // --------- flatfile change --------------- } else if(S_OK == hr) { hr = pQueryChildStream->QueryInterface( IID_IStream, (LPVOID *) &pQueryMarshalStream ); } if (S_OK == hr) { DH_ASSERT(NULL != pQueryMarshalStream); DH_TRACE(( DH_LVL_TRACE1, TEXT("IStream::QueryInterface completed successfully."))); } else { DH_TRACE(( DH_LVL_ERROR, TEXT("IStream::QueryInterface unsuccessful, hr = 0x%lx."), hr)); } // --------- flatfile change --------------- // Use the IRootStream interface to QueryInterface an IUnknown // interface. if(S_OK == hr) { hr = pQueryMarshalStream->QueryInterface( IID_IUnknown, (LPVOID *) &pQueryUnknownStream ); } // Use the IUnknown interface to QueryInterface an IStream interface. if(S_OK == hr) { DH_ASSERT(NULL != pQueryUnknownStream); hr = pQueryUnknownStream->QueryInterface( IID_IStream, (LPVOID *) &pQueryRetChildStream ); } if (S_OK == hr) { DH_TRACE(( DH_LVL_TRACE1, TEXT("IStream:Reflexive/Transitive OLE COM behaviour passed."))); } else { DH_TRACE(( DH_LVL_ERROR, TEXT("IStream:Reflexive/Transitive COM behaviour fail, hr=0x%lx"), hr)); } // Clean up if(NULL != pQueryChildStorage) { ulRef = pQueryChildStorage->Release(); DH_ASSERT(4 == ulRef); pQueryChildStorage = NULL; } if(NULL != pQueryMarshalStorage) { ulRef = pQueryMarshalStorage->Release(); DH_ASSERT(3 == ulRef); pQueryMarshalStorage = NULL; } if(NULL != pQueryUnknownStorage) { ulRef = pQueryUnknownStorage->Release(); DH_ASSERT(2 == ulRef); pQueryUnknownStorage = NULL; } if(NULL != pQueryRetChildStorage) { ulRef = pQueryRetChildStorage->Release(); DH_ASSERT(1 == ulRef); pQueryRetChildStorage = NULL; } if(NULL != pQueryChildStream) { ulRef = pQueryChildStream->Release(); DH_ASSERT(4 == ulRef); pQueryChildStream = NULL; } if(NULL != pQueryMarshalStream) { ulRef = pQueryMarshalStream->Release(); DH_ASSERT(3 == ulRef); pQueryMarshalStream = NULL; } if(NULL != pQueryUnknownStream) { ulRef = pQueryUnknownStream->Release(); DH_ASSERT(2 == ulRef); pQueryUnknownStream = NULL; } if(NULL != pQueryRetChildStream) { ulRef = pQueryRetChildStream->Release(); DH_ASSERT(1 == ulRef); pQueryRetChildStream = NULL; } // --------- flatfile change --------------- if(!StorageIsFlat()) { // --------- flatfile change --------------- // Close the child storage if (S_OK == hr) { hr = pvcnRootNewChildStorage->Close(); } if (S_OK == hr) { DH_TRACE(( DH_LVL_TRACE1, TEXT("VirtualCtrNode::Close completed successfully."))); } else { DH_TRACE(( DH_LVL_ERROR, TEXT("VirtualCtrNode::Close unsuccessful, hr = 0x%lx."), hr)); } // --------- flatfile change --------------- } // --------- flatfile change --------------- // Close the child stream if (S_OK == hr) { hr = pvsnRootNewChildStream->Close(); } if (S_OK == hr) { DH_TRACE(( DH_LVL_TRACE1, TEXT("VirtualStmNode::Close completed successfully."))); } else { DH_TRACE(( DH_LVL_ERROR, TEXT("VirtualStmNode::Close unsuccessful, hr = 0x%lx."), hr)); } // Close the 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_ERROR, 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 COMTEST_104 passed.")) ); } else { DH_LOG(( LOG_FAIL, TEXT("Test variation COMTEST_104 failed, hr = 0x%lx."), hr) ); } // Cleanup CleanupTestDocfile (&pVirtualDFRoot, &pTestVirtualDF, &pTestChanceDF, S_OK == hr); // Delete strings if(NULL != pRootNewChildStgName) { delete pRootNewChildStgName; pRootNewChildStgName = NULL; } if(NULL != pRootNewChildStmName) { delete pRootNewChildStmName; pRootNewChildStmName = NULL; } // Stop logging the test DH_TRACE((DH_LVL_TRACE1, TEXT("Test variation COMTEST_104 finished")) ); DH_TRACE((DH_LVL_TRACE1, TEXT("--------------------------------------------")) ); return hr; } //---------------------------------------------------------------------------- // // Test: COMTEST-105 // // Synopsis: A root docfile with a child storage and a child stream is created, // then check if Read/WriteClassStg and Read/WriteClassStm APIs work // correctly as expected. 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: 15-Aug-1996 JiminLi Created. // // To run the test, do the following at command prompt. // a. stgbase /seed:0 /dfdepth:0-0 /dfstg:0-0 /dfstm:0-0 /t:COMTEST-105 // /dfRootMode:dirReadWriteShEx /dfStgMode:dirReadWriteShEx // b. stgbase /seed:0 /dfdepth:0-0 /dfstg:0-0 /dfstm:0-0 /t:COMTEST-105 // /dfRootMode:xactReadWriteShEx /dfStgMode:xactReadWriteShEx // c. stgbase /seed:0 /dfdepth:0-0 /dfstg:0-0 /dfstm:0-0 /t:COMTEST-105 // /dfRootMode:xactReadWriteShDenyW /dfStgMode:xactReadWriteShEx // // Conversion: COMTEST_105 // //----------------------------------------------------------------------------- HRESULT COMTEST_105(int argc, char *argv[]) { HRESULT hr = S_OK; ChanceDF *pTestChanceDF = NULL; VirtualDF *pTestVirtualDF = NULL; VirtualCtrNode *pVirtualDFRoot = NULL; VirtualCtrNode *pvcnRootNewChildStg = NULL; VirtualStmNode *pvsnRootNewChildStm = NULL; LPTSTR pRootNewChildStgName = NULL; DG_STRING *pdgu = NULL; DG_INTEGER *pdgi = NULL; LPSTORAGE pRootStg = NULL; LPSTORAGE pChildStg = NULL; LPSTREAM pChildStm = NULL; USHORT usErr = 0; LPTSTR ptszStreamName = NULL; DWORD dwRootMode = 0; DWORD dwStgMode = 0; BOOL fPass = TRUE; ULONG culWritten = 0; ULONG ulPosition = 0; STATSTG statStg; STATSTG statStm; LARGE_INTEGER liZero; LARGE_INTEGER liStreamPos; ULARGE_INTEGER uli; GUID TEST_CLSID = { 0x9c6e9ed0, 0xf701, 0x11cf, { 0x98, 0x44, 0x00, 0xa0, 0xc9, 0x08, 0xe4, 0x6d }}; CLSID pclsid; DH_FUNCENTRY(NULL, DH_LVL_DFLIB, _TEXT("COMTEST_105")); DH_TRACE((DH_LVL_TRACE1, TEXT("--------------------------------------------")) ); DH_TRACE((DH_LVL_TRACE1, TEXT("Test variation COMTEST_105 started.")) ); DH_TRACE(( DH_LVL_TRACE1, TEXT("Attempt legit and illegit tests on Read/WriteClassStg/Stm "))); pclsid = TEST_CLSID; // 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) { pRootStg = pVirtualDFRoot->GetIStoragePointer(); dwRootMode = pTestChanceDF->GetRootMode(); dwStgMode = pTestChanceDF->GetStgMode(); DH_TRACE(( DH_LVL_TRACE1, TEXT("Run Mode for COMTEST_105, Access mode: %lx"), dwRootMode)); } // 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")) ; } // --------- flatfile change --------------- if(!StorageIsFlat()) { // --------- flatfile change --------------- 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_ERROR, TEXT("AddStorage not successful, hr=0x%lx."), hr)); } // --------- flatfile change --------------- } // --------- flatfile change --------------- // Add a child stream under root storage if(S_OK == hr) { // Generate random name for stream hr = GenerateRandomName(pdgu,MINLENGTH,MAXLENGTH,&ptszStreamName); DH_HRCHECK(hr, TEXT("GenerateRandomName")) ; } if(S_OK == hr) { hr = AddStream( pTestVirtualDF, pVirtualDFRoot, ptszStreamName, 0, STGM_READWRITE | STGM_SHARE_EXCLUSIVE | STGM_FAILIFTHERE, &pvsnRootNewChildStm); DH_HRCHECK(hr, TEXT("AddStream")) ; } if(S_OK == hr && NULL != pvsnRootNewChildStm) { pChildStm = pvsnRootNewChildStm->GetIStreamPointer(); } if(S_OK == hr) { DH_TRACE(( DH_LVL_TRACE1, TEXT("VirtualStmNode::AddStream completed successfully."))); } else { DH_TRACE(( DH_LVL_ERROR, TEXT("VirtualStmNode::AddStream not successful, hr=0x%lx."), hr)); } // Write a random stream to the stream, in order to test // ReadClassStm later. if(S_OK == hr) { hr = pvsnRootNewChildStm->Write( ptszStreamName, _tcslen(ptszStreamName), &culWritten); DH_HRCHECK(hr, TEXT("IStream::Write")) ; } // Legit tests of Read/WriteClassStg on the root storage // First call Stat on root storage and check the CLSID of it. if (S_OK == hr) { hr = pVirtualDFRoot->Stat(&statStg, STATFLAG_NONAME); DH_HRCHECK(hr, TEXT("VirtualCtrNode::Stat")) ; } if (S_OK != hr) { DH_TRACE(( DH_LVL_ERROR, TEXT("VirtualCtrNode::Stat unsuccessful, hr=0x%lx."), hr)); } 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_ERROR, TEXT("Root DocFile doesn't have CLSID_NULL unexpectedly."))); fPass = FALSE; } // Then call ReadClassStg to see if this API work correctly if (S_OK == hr) { hr = ReadClassStg(pRootStg, &pclsid); } if ((S_OK == hr) && (IsEqualCLSID(pclsid, CLSID_NULL))) { DH_TRACE(( DH_LVL_TRACE1, TEXT("ReadClassStg returns CLSID_NULL as expected."))); } else { DH_TRACE(( DH_LVL_ERROR, TEXT("ReadClassStg not return CLSID_NULL as expected. hr=0x%lx"), hr)); fPass = FALSE; } // Now write the new CLSID into the root storage object if (S_OK == hr) { hr = WriteClassStg(pRootStg, TEST_CLSID); DH_HRCHECK(hr, TEXT("WriteClassStg")); } // Call Stat again to check if the above WriteClassStg and the next // ReadClassStg work 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_ERROR, TEXT("VirtualCtrNode::Stat unsuccessful, hr=0x%lx."), hr)); } if ((S_OK == hr) && (IsEqualCLSID(statStg.clsid, TEST_CLSID))) { DH_TRACE(( DH_LVL_TRACE1, TEXT("Root DocFile has TEST_CLSID as expected."))); } else { DH_TRACE(( DH_LVL_ERROR, TEXT("Root DocFile doesn't have TEST_CLSID unexpectedly."))); fPass = FALSE; } if (S_OK == hr) { hr = ReadClassStg(pRootStg, &pclsid); } if ((S_OK == hr) && (IsEqualCLSID(pclsid, TEST_CLSID))) { DH_TRACE(( DH_LVL_TRACE1, TEXT("ReadClassStg returns TEST_CLSID as expected."))); } else { DH_TRACE(( DH_LVL_ERROR, TEXT("ReadClassStg not return TEST_CLSID as expected. hr=0x%lx"), hr)); fPass = FALSE; } // --------- flatfile change --------------- if(!StorageIsFlat()) { // --------- flatfile change --------------- // Legit tests of Set/GetConvertStg on the child storage // First call Stat on root storage and check the CLSID of it. if (S_OK == hr) { hr = pvcnRootNewChildStg->Stat(&statStg, STATFLAG_NONAME); DH_HRCHECK(hr, TEXT("VirtualCtrNode::Stat")) ; } if (S_OK != hr) { DH_TRACE(( DH_LVL_ERROR, TEXT("VirtualCtrNode::Stat unsuccessful, hr=0x%lx."), hr)); } 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_ERROR, TEXT("Child Storage doesn't have CLSID_NULL unexpectedly."))); fPass = FALSE; } // Then call ReadClassStg to see if this API work correctly if (S_OK == hr) { hr = ReadClassStg(pChildStg, &pclsid); } if ((S_OK == hr) && (IsEqualCLSID(pclsid, CLSID_NULL))) { DH_TRACE(( DH_LVL_TRACE1, TEXT("ReadClassStg returns CLSID_NULL as expected."))); } else { DH_TRACE(( DH_LVL_ERROR, TEXT("ReadClassStg not return CLSID_NULL as expected. hr=0x%lx"), hr)); fPass = FALSE; } // Now write the new CLSID into the child storage object if (S_OK == hr) { hr = WriteClassStg(pChildStg, TEST_CLSID); DH_HRCHECK(hr, TEXT("WriteClassStg")); } // Call Stat again to check if the above WriteClassStg and the next // ReadClassStg work correctly if (S_OK == hr) { hr = pvcnRootNewChildStg->Stat(&statStg, STATFLAG_NONAME); DH_HRCHECK(hr, TEXT("VirtualCtrNode::Stat")) ; } if (S_OK != hr) { DH_TRACE(( DH_LVL_ERROR, TEXT("VirtualCtrNode::Stat unsuccessful, hr=0x%lx."), hr)); } if ((S_OK == hr) && (IsEqualCLSID(statStg.clsid, TEST_CLSID))) { DH_TRACE(( DH_LVL_TRACE1, TEXT("Child Storage has TEST_CLSID as expected."))); } else { DH_TRACE(( DH_LVL_ERROR, TEXT("Child Storage doesn't have TEST_CLSID unexpectedly."))); fPass = FALSE; } if (S_OK == hr) { hr = ReadClassStg(pChildStg, &pclsid); } if ((S_OK == hr) && (IsEqualCLSID(pclsid, TEST_CLSID))) { DH_TRACE(( DH_LVL_TRACE1, TEXT("ReadClassStg returns TEST_CLSID as expected."))); } else { DH_TRACE(( DH_LVL_ERROR, TEXT("ReadClassStg not return TEST_CLSID as expected. hr=0x%lx"), hr)); fPass = FALSE; } // --------- flatfile change --------------- } // --------- flatfile change --------------- // Illegit tests // Pass NULL as IStorage pointer, it should fail #ifdef _MAC DH_TRACE(( DH_LVL_ERROR, TEXT("!!!!!!!!!!!!!!!!Invalid param testing skipped"), hr)); #else if (S_OK == hr) { hr = WriteClassStg(NULL, TEST_CLSID); } if (E_INVALIDARG == hr) { hr = S_OK; } else { DH_TRACE(( DH_LVL_ERROR, TEXT("WriteClassStg did not return as expected, hr=0x%lx"), hr)); fPass = FALSE; } if (S_OK == hr) { hr = ReadClassStg(NULL, &pclsid); } if (E_INVALIDARG == hr) { hr = S_OK; } else { DH_TRACE(( DH_LVL_ERROR, TEXT("ReadClassStg did not return as expected, hr=0x%lx"), hr)); fPass = FALSE; } #endif //_MAC // Legit tests of Set/GetConvertStg on the child stream // First call Stat on child stream and check the CLSID of it. if (S_OK == hr) { hr = pvsnRootNewChildStm->Stat(&statStm, STATFLAG_NONAME); DH_HRCHECK(hr, TEXT("VirtualStmNode::Stat")) ; } if (S_OK != hr) { DH_TRACE(( DH_LVL_ERROR, TEXT("VirtualStmNode::Stat unsuccessful, hr=0x%lx."), hr)); } if ((S_OK == hr) && (IsEqualCLSID(statStm.clsid, CLSID_NULL))) { DH_TRACE(( DH_LVL_TRACE1, TEXT("Child Stream has CLSID_NULL as expected."))); } else { DH_TRACE(( DH_LVL_ERROR, TEXT("Child Stream doesn't have CLSID_NULL unexpectedly."))); fPass = FALSE; } // Then call ReadClassStm to see if this API work correctly // Since ReadClassStm can only read the CLSID written previously by // WriteClassStm, it'll return STG_E_READFAULT in this case. if (S_OK == hr) { hr = ReadClassStm(pChildStm, &pclsid); } if (STG_E_READFAULT == hr) { DH_TRACE(( DH_LVL_TRACE1, TEXT("ReadClassStm returns STG_E_READFAULT as expected."))); hr = S_OK; } else { DH_TRACE(( DH_LVL_ERROR, TEXT("Err: ReadClassStm not return STG_E_READFAULT. hr=0x%lx"), hr)); fPass = FALSE; } // Get the seek pointer before writing, then retore to this offset // when we want to ReadClassStm later. if (S_OK == hr) { LISet32(liZero, 0L); hr = pChildStm->Seek(liZero, STREAM_SEEK_CUR, &uli); ulPosition = ULIGetLow(uli); DH_HRCHECK(hr, TEXT("IStream::Seek")); } // Now write a new CLSID into stream if (S_OK == hr) { hr = WriteClassStm(pChildStm, TEST_CLSID); DH_HRCHECK(hr, TEXT("WriteClassStm")); } // Call Stat again to check if the above WriteClassStm and the next // ReadClassStm work correctly if (S_OK == hr) { hr = pvsnRootNewChildStm->Stat(&statStm, STATFLAG_NONAME); DH_HRCHECK(hr, TEXT("VirtualStmNode::Stat")) ; } if (S_OK != hr) { DH_TRACE(( DH_LVL_ERROR, TEXT("VirtualStmNode::Stat unsuccessful, hr=0x%lx."), hr)); } if ((S_OK == hr) && (IsEqualCLSID(statStg.clsid, TEST_CLSID))) { DH_TRACE(( DH_LVL_TRACE1, TEXT("Child Stream has TEST_CLSID as expected."))); } else { DH_TRACE(( DH_LVL_ERROR, TEXT("Child Stream doesn't have TEST_CLSID unexpectedly."))); fPass = FALSE; } // Since ReadClassStm calls pstm->ReadAt(...) but not get CLSID from // pstm->Stat, basically it needs correct seek pointer, we need get it. if (S_OK == hr) { LISet32(liStreamPos, ulPosition); hr = pChildStm->Seek(liStreamPos, STREAM_SEEK_SET, NULL); DH_HRCHECK(hr, TEXT("IStream::Seek")); } if (S_OK == hr) { hr = ReadClassStm(pChildStm, &pclsid); } if ((S_OK == hr) && (IsEqualCLSID(pclsid, TEST_CLSID))) { DH_TRACE(( DH_LVL_TRACE1, TEXT("ReadClassStm returns TEST_CLSID as expected."))); } else { DH_TRACE(( DH_LVL_ERROR, TEXT("ReadClassStm not return TEST_CLSID as expected. hr=0x%lx"), hr)); fPass = FALSE; } // Illegit tests // Pass NULL as IStream pointer, it should fail #ifdef _MAC DH_TRACE(( DH_LVL_ERROR, TEXT("!!!!!!!!!!!!!!!!Invalid param testing skipped"), hr)); #else if (S_OK == hr) { hr = WriteClassStm(NULL, TEST_CLSID); } if (E_INVALIDARG == hr) { hr = S_OK; } else { DH_TRACE(( DH_LVL_ERROR, TEXT("WriteClassStm did not return as expected, hr=0x%lx"), hr)); fPass = FALSE; } if (S_OK == hr) { hr = ReadClassStm(NULL, &pclsid); } if (E_INVALIDARG == hr) { hr = S_OK; } else { DH_TRACE(( DH_LVL_ERROR, TEXT("ReadClassStm did not return as expected, hr = 0x%lx"), hr)); fPass = FALSE; } #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_ERROR, TEXT("VirtualCtrNode::Commit unsuccessful, hr=0x%lx."), hr)); } // Release the child stream if (S_OK == hr) { hr = pvsnRootNewChildStm->Close(); DH_HRCHECK(hr, TEXT("VirutalStmNode::Close")); } // --------- flatfile change --------------- if(!StorageIsFlat()) { // --------- flatfile change --------------- // Release child and root storages if (S_OK == hr) { hr = pvcnRootNewChildStg->Close(); DH_HRCHECK(hr, TEXT("VirtualCtrNode::Close")); } if (S_OK == hr) { DH_TRACE(( DH_LVL_TRACE1, TEXT("VirtualStmNode::Close completed successfully."))); } else { DH_TRACE(( DH_LVL_ERROR, TEXT("VirtualStmNode::Close unsuccessful, hr=0x%lx."), hr)); } // --------- flatfile change --------------- } // --------- flatfile change --------------- 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_ERROR, 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 COMTEST_105 passed.")) ); } else if (4 == NTMAJVER()) //No fix bug in NT4. { DH_LOG((LOG_FAIL, TEXT("COMTEST_105 failed on NT4. Bug#54738"))); // test failed. make sure it failed. hr = FirstError (hr, E_FAIL); } else { DH_LOG(( LOG_FAIL, TEXT("Test variation COMTEST_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); // Delete temp strings if (NULL != pRootNewChildStgName) { delete []pRootNewChildStgName; pRootNewChildStgName = NULL; } if (NULL != ptszStreamName) { delete []ptszStreamName; ptszStreamName = NULL; } // Stop logging the test DH_TRACE((DH_LVL_TRACE1, TEXT("Test variation COMTEST_105 finished")) ); DH_TRACE((DH_LVL_TRACE1, TEXT("--------------------------------------------")) ); return hr; } //---------------------------------------------------------------------------- // // Test: COMTEST-106 // // Synopsis: Create a root docfile with a child storage and an IStream inside // of the child IStorage. Random data is written to the IStream and // the CRC is computed for the data. Then commit the child storage, // verify the CRC of data, if it is correct, then commit the root // storage, and again verify the CRC of data. First round passed in // STGC_DEFAULT, then change the IStream data, then repeat the above // commit process by passed in STGC_OVERWRITE. Finally, change the // IStream data again, repeat the process for commit by passed in // STGC_DANGEROUSLYCIMMITMERELYTODISKCACHE. // // Since transacted tests contain more detail tests about Commit, // here just keep it simple in base tests. Also, STGC_ONLYIFCURRENT // is not test because it should be used in multiple users // environment. // // Only IStorage::Commit is tested, because IStream::Commit has no // effect other than flushing internal memory buffers to the parent // storage object. It does not matter if commit changes to streams. // // Arguments:[argc] // [argv] // // Returns: HRESULT // // Notes: This test runs in direct, transacted, and transacted deny write // modes // // History: 15-Aug-1996 JiminLi Created. // // To run the test, do the following at command prompt. // a. stgbase /seed:0 /dfdepth:0-0 /dfstg:0-0 /dfstm:0-0 /t:COMTEST-106 // /dfRootMode:dirReadWriteShEx /dfStgMode:dirReadWriteShEx // b. stgbase /seed:0 /dfdepth:0-0 /dfstg:0-0 /dfstm:0-0 /t:COMTEST-106 // /dfRootMode:xactReadWriteShEx /dfStgMode:xactReadWriteShEx // c. stgbase /seed:0 /dfdepth:0-0 /dfstg:0-0 /dfstm:0-0 /t:COMTEST-106 // /dfRootMode:xactReadWriteShDenyW /dfStgMode:xactReadWriteShEx // // Conversion: COMTEST_106 // //----------------------------------------------------------------------------- HRESULT COMTEST_106(int argc, char *argv[]) { HRESULT hr = S_OK; ChanceDF *pTestChanceDF = NULL; VirtualDF *pTestVirtualDF = NULL; VirtualCtrNode *pVirtualDFRoot = NULL; VirtualCtrNode *pvcnRootNewChildStg = NULL; VirtualCtrNode *pstgCommitMe = NULL; VirtualStmNode *pvsnNewChildStm = NULL; LPTSTR pRootNewChildStgName = NULL; LPTSTR ptcsBuffer = NULL; DG_STRING *pdgu = NULL; DG_INTEGER *pdgi = NULL; USHORT usErr = 0; LPTSTR ptszStreamName = NULL; DWORD dwRootMode = 0; DWORD dwStgMode = 0; DWORD dwOriginalCRC = 0; DWORD dwCommitCRC = 0; BOOL fRetry = TRUE; BOOL fPass = TRUE; ULONG culWritten = 0; ULONG ulPosition = 0; ULONG culRandIOBytes = 0; ULONG culRead = 0; LARGE_INTEGER liZero; ULARGE_INTEGER uliSize; DH_FUNCENTRY(NULL, DH_LVL_DFLIB, _TEXT("COMTEST_106")); DH_TRACE((DH_LVL_TRACE1, TEXT("--------------------------------------------")) ); DH_TRACE((DH_LVL_TRACE1, TEXT("Test variation COMTEST_106 started.")) ); DH_TRACE(( DH_LVL_TRACE1, TEXT("Attempt legit and illegit tests on IStorage::Commit."))); // 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 COMTEST_106, Access mode: %lx"), dwRootMode)); } // 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); DH_HRCHECK(hr, TEXT("AddStorage")) ; } if(S_OK == hr) { DH_TRACE(( DH_LVL_TRACE1, TEXT("AddStorage completed successfully."))); } else { DH_TRACE(( DH_LVL_ERROR, TEXT("AddStorage not successful, hr=0x%lx."), hr)); } // Add a child stream under the child storage if(S_OK == hr) { // Generate random name for stream hr = GenerateRandomName(pdgu,MINLENGTH,MAXLENGTH,&ptszStreamName); DH_HRCHECK(hr, TEXT("GenerateRandomName")) ; } if(S_OK == hr) { hr = AddStream( pTestVirtualDF, pvcnRootNewChildStg, ptszStreamName, 0, STGM_READWRITE | STGM_SHARE_EXCLUSIVE | STGM_FAILIFTHERE, &pvsnNewChildStm); DH_HRCHECK(hr, TEXT("AddStream")) ; } if(S_OK == hr) { DH_TRACE(( DH_LVL_TRACE1, TEXT("VirtualStmNode::AddStream completed successfully."))); } else { DH_TRACE(( DH_LVL_ERROR, TEXT("VirtualStmNode::AddStream not successful, hr=0x%lx."), hr)); } // Generate a random number culRandIOBytes if (S_OK == hr) { usErr = pdgi->Generate(&culRandIOBytes, RAND_IO_MIN, RAND_IO_MAX); if (DG_RC_SUCCESS != usErr) { hr = E_FAIL; } } if (S_OK == hr) { hr = GenerateRandomString( pdgu, culRandIOBytes, culRandIOBytes, &ptcsBuffer); DH_HRCHECK(hr, TEXT("GenerateRandomString")); } if (S_OK == hr) { hr = pvsnNewChildStm->Write( ptcsBuffer, culRandIOBytes, &culWritten); } if(S_OK != hr) { DH_TRACE(( DH_LVL_TRACE1, TEXT("IStream::Write function wasn't successful, hr=0x%lx."), hr)); } // Calculate the CRC for stream data if (S_OK == hr) { hr = CalculateCRCForDataBuffer( ptcsBuffer, culRandIOBytes, &dwOriginalCRC); DH_HRCHECK(hr, TEXT("CalculateCRCForDataBuffer")); } // Delete temp buffer if (NULL != ptcsBuffer) { delete []ptcsBuffer; ptcsBuffer = NULL; } // Test on STGC_DEFAULT pstgCommitMe = pvcnRootNewChildStg; while ((S_OK == hr) && (fRetry == TRUE)) { hr = pstgCommitMe->Commit(STGC_DEFAULT); if (S_OK == hr) { // verify IStream data after commit() // Allocate a buffer of required size ptcsBuffer = new TCHAR [culRandIOBytes]; if (NULL == ptcsBuffer) { hr = E_OUTOFMEMORY; } if (S_OK == hr) { LISet32(liZero, 0L); hr = pvsnNewChildStm->Seek(liZero, STREAM_SEEK_SET, NULL); DH_HRCHECK(hr, TEXT("IStream::Seek")); } if (S_OK == hr) { memset(ptcsBuffer, '\0', culRandIOBytes * sizeof(TCHAR)); hr = pvsnNewChildStm->Read( ptcsBuffer, culRandIOBytes, &culRead); } if ((S_OK != hr) || (culRead != culRandIOBytes)) { DH_TRACE(( DH_LVL_ERROR, TEXT("IStream::Read not successful, hr=0x%lx."), hr)); fPass = FALSE; } // Calculate the CRC for stream data if (S_OK == hr) { hr = CalculateCRCForDataBuffer( ptcsBuffer, culRandIOBytes, &dwCommitCRC); DH_HRCHECK(hr, TEXT("CalculateCRCForDataBuffer")); } // Compare corresponding dwMemCRC and dwActCRC and verify if (S_OK == hr) { if (dwOriginalCRC != dwCommitCRC) { DH_TRACE(( DH_LVL_ERROR, TEXT("CRC's before/after commit unmatch."))); fPass = FALSE; } } // Delete temp buffer if (NULL != ptcsBuffer) { delete []ptcsBuffer; ptcsBuffer = NULL; } // if child storage just commited ok, stay in loop and now // commit root, otherwise set flag to terminate loop if ((fPass == TRUE) && (pstgCommitMe == pvcnRootNewChildStg)) { pstgCommitMe = pVirtualDFRoot; } else { fRetry = FALSE; } } else { DH_TRACE(( DH_LVL_ERROR, TEXT("VirtualCtrNode::Commit failed. hr = 0x%lx"), hr)); break; } } // Now make some changes on IStream data, re-set the stream size to // a new random size, then seek from beginning and rewrite the stream // data of the new size, and CRC it. // Generate a random number culRandIOBytes if (S_OK == hr) { usErr = pdgi->Generate(&culRandIOBytes, RAND_IO_MIN, RAND_IO_MAX); if (DG_RC_SUCCESS != usErr) { hr = E_FAIL; } } if (S_OK == hr) { hr = GenerateRandomString( pdgu, culRandIOBytes, culRandIOBytes, &ptcsBuffer); DH_HRCHECK(hr, TEXT("GenerateRandomString")); } if (S_OK == hr) { ULISet32(uliSize, culRandIOBytes); hr = pvsnNewChildStm->SetSize(uliSize); DH_HRCHECK(hr, TEXT("VirtualStmNode::SetSize")); } if (S_OK == hr) { LISet32(liZero, 0L); hr = pvsnNewChildStm->Seek(liZero, STREAM_SEEK_SET, NULL); DH_HRCHECK(hr, TEXT("IStream::Seek")); } if (S_OK == hr) { hr = pvsnNewChildStm->Write( ptcsBuffer, culRandIOBytes, &culWritten); } if(S_OK != hr) { DH_TRACE(( DH_LVL_ERROR, TEXT("IStream::Write function wasn't successful, hr=0x%lx."), hr)); } // Calculate the CRC for stream data if (S_OK == hr) { hr = CalculateCRCForDataBuffer( ptcsBuffer, culRandIOBytes, &dwOriginalCRC); DH_HRCHECK(hr, TEXT("CalculateCRCForDataBuffer")); } // Delete temp buffer if (NULL != ptcsBuffer) { delete []ptcsBuffer; ptcsBuffer = NULL; } // Test on STGC_OVERWRITE pstgCommitMe = pvcnRootNewChildStg; while ((S_OK == hr) && (fRetry == TRUE)) { hr = pstgCommitMe->Commit(STGC_OVERWRITE); if (S_OK == hr) { // verify IStream data after commit() // Allocate a buffer of required size ptcsBuffer = new TCHAR [culRandIOBytes]; if (NULL == ptcsBuffer) { hr = E_OUTOFMEMORY; } if (S_OK == hr) { LISet32(liZero, 0L); hr = pvsnNewChildStm->Seek(liZero, STREAM_SEEK_SET, NULL); DH_HRCHECK(hr, TEXT("IStream::Seek")); } if (S_OK == hr) { memset(ptcsBuffer, '\0', culRandIOBytes * sizeof(TCHAR)); hr = pvsnNewChildStm->Read( ptcsBuffer, culRandIOBytes, &culRead); } if ((S_OK != hr) || (culRead != culRandIOBytes)) { DH_TRACE(( DH_LVL_ERROR, TEXT("IStream::Read not successful, hr=0x%lx."), hr)); fPass = FALSE; } // Calculate the CRC for stream data if (S_OK == hr) { hr = CalculateCRCForDataBuffer( ptcsBuffer, culRandIOBytes, &dwCommitCRC); DH_HRCHECK(hr, TEXT("CalculateCRCForDataBuffer")); } // Compare corresponding dwMemCRC and dwActCRC and verify if (S_OK == hr) { if (dwOriginalCRC != dwCommitCRC) { DH_TRACE(( DH_LVL_ERROR, TEXT("CRC's before/after commit unmatch."))); fPass = FALSE; } } // Delete temp buffer if (NULL != ptcsBuffer) { delete []ptcsBuffer; ptcsBuffer = NULL; } // if child storage just commited ok, stay in loop and now // commit root, otherwise set flag to terminate loop if ((fPass == TRUE) && (pstgCommitMe == pvcnRootNewChildStg)) { pstgCommitMe = pVirtualDFRoot; } else { fRetry = FALSE; } } else { DH_TRACE(( DH_LVL_ERROR, TEXT("VirtualCtrNode::Commit failed. hr = 0x%lx"), hr)); break; } } // Now again make some changes on IStream data, re-set the stream size // to a new random size, then seek from beginning and rewrite the stream // data of the new size, and CRC it. // Generate a random number culRandIOBytes if (S_OK == hr) { usErr = pdgi->Generate(&culRandIOBytes, RAND_IO_MIN, RAND_IO_MAX); if (DG_RC_SUCCESS != usErr) { hr = E_FAIL; } } if (S_OK == hr) { hr = GenerateRandomString( pdgu, culRandIOBytes, culRandIOBytes, &ptcsBuffer); DH_HRCHECK(hr, TEXT("GenerateRandomString")); } if (S_OK == hr) { ULISet32(uliSize, culRandIOBytes); hr = pvsnNewChildStm->SetSize(uliSize); DH_HRCHECK(hr, TEXT("VirtualStmNode::SetSize")); } if (S_OK == hr) { LISet32(liZero, 0L); hr = pvsnNewChildStm->Seek(liZero, STREAM_SEEK_SET, NULL); DH_HRCHECK(hr, TEXT("IStream::Seek")); } if (S_OK == hr) { hr = pvsnNewChildStm->Write( ptcsBuffer, culRandIOBytes, &culWritten); } if(S_OK != hr) { DH_TRACE(( DH_LVL_ERROR, TEXT("IStream::Write function wasn't successful, hr=0x%lx."), hr)); } // Calculate the CRC for stream data if (S_OK == hr) { hr = CalculateCRCForDataBuffer( ptcsBuffer, culRandIOBytes, &dwOriginalCRC); DH_HRCHECK(hr, TEXT("CalculateCRCForDataBuffer")); } // Delete temp buffer if (NULL != ptcsBuffer) { delete []ptcsBuffer; ptcsBuffer = NULL; } // Test on STGC_OVERWRITE pstgCommitMe = pvcnRootNewChildStg; while ((S_OK == hr) && (fRetry == TRUE)) { hr = pstgCommitMe->Commit(STGC_DANGEROUSLYCOMMITMERELYTODISKCACHE); if (S_OK == hr) { // verify IStream data after commit() // Allocate a buffer of required size ptcsBuffer = new TCHAR [culRandIOBytes]; if (NULL == ptcsBuffer) { hr = E_OUTOFMEMORY; } if (S_OK == hr) { LISet32(liZero, 0L); hr = pvsnNewChildStm->Seek(liZero, STREAM_SEEK_SET, NULL); DH_HRCHECK(hr, TEXT("IStream::Seek")); } if (S_OK == hr) { memset(ptcsBuffer, '\0', culRandIOBytes * sizeof(TCHAR)); hr = pvsnNewChildStm->Read( ptcsBuffer, culRandIOBytes, &culRead); } if ((S_OK != hr) || (culRead != culRandIOBytes)) { DH_TRACE(( DH_LVL_ERROR, TEXT("IStream::Read not successful, hr=0x%lx."), hr)); fPass = FALSE; } // Calculate the CRC for stream data if (S_OK == hr) { hr = CalculateCRCForDataBuffer( ptcsBuffer, culRandIOBytes, &dwCommitCRC); DH_HRCHECK(hr, TEXT("CalculateCRCForDataBuffer")); } // Compare corresponding dwMemCRC and dwActCRC and verify if (S_OK == hr) { if (dwOriginalCRC != dwCommitCRC) { DH_TRACE(( DH_LVL_ERROR, TEXT("CRC's before/after commit unmatch."))); fPass = FALSE; } } // Delete temp buffer if (NULL != ptcsBuffer) { delete []ptcsBuffer; ptcsBuffer = NULL; } // if child storage just commited ok, stay in loop and now // commit root, otherwise set flag to terminate loop if ((fPass == TRUE) && (pstgCommitMe == pvcnRootNewChildStg)) { pstgCommitMe = pVirtualDFRoot; } else { fRetry = FALSE; } } else { DH_TRACE(( DH_LVL_ERROR, TEXT("VirtualCtrNode::Commit failed. hr = 0x%lx"), hr)); break; } } // Release the child stream if (S_OK == hr) { hr = pvsnNewChildStm->Close(); DH_HRCHECK(hr, TEXT("VirutalStmNode::Close")); } // Release child and root storages if (S_OK == hr) { hr = pvcnRootNewChildStg->Close(); DH_HRCHECK(hr, TEXT("VirtualCtrNode::Close")); } if (S_OK == hr) { DH_TRACE(( DH_LVL_TRACE1, TEXT("VirtualStmNode::Close completed successfully."))); } else { DH_TRACE(( DH_LVL_ERROR, TEXT("VirtualStmNode::Close unsuccessful, hr=0x%lx."), hr)); } 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_ERROR, 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 COMTEST_106 passed.")) ); } else { DH_LOG(( LOG_FAIL, TEXT("Test variation COMTEST_106 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; } if (NULL != ptszStreamName) { delete []ptszStreamName; ptszStreamName = NULL; } // Stop logging the test DH_TRACE((DH_LVL_TRACE1, TEXT("Test variation COMTEST_106 finished")) ); DH_TRACE((DH_LVL_TRACE1, TEXT("--------------------------------------------")) ); return hr; }