/------------------------------------------------------------------------- // // Microsoft OLE // Copyright (C) Microsoft Corporation, 1994 - 1995. // // File: apitests.cxx // // Contents: storage base tests basically pertaining to API tests in general. // // Functions: // // History: 18-June-1996 NarindK Created. // 27-Mar-97 SCousens conversionified // //-------------------------------------------------------------------------- #include #pragma hdrstop #include #include #include "init.hxx" // undo the affects of the wrapper. We need to test the actual APIs here, // not what we think we should be calling to test docfile/nssfiles. #undef StgCreateDocfile #undef StgOpenStorage // CheckErrorTest macros. // These check the return value to an invalid api call. // These must remain as #defines as we change local variables. #define CheckErrorTest(err, msg, pstg) \ DH_ASSERT (NULL == pstg); \ hr = DH_HRERRORCHECK (hr, err, msg); \ if ((S_OK != hr) || (NULL != pstg)) \ { \ fPass = FALSE; \ hr = S_OK; \ } \ // release it if we accidentally got one \ if (NULL != pstg) \ { \ pstg->Release (); \ pstg = NULL; \ } #define CheckErrorTest2(err, msg) \ hr = DH_HRERRORCHECK (hr, err, msg); \ if (S_OK != hr) \ { \ fPass = FALSE; \ hr = S_OK; \ } //---------------------------------------------------------------------------- // // Test: APITEST_100 // // Synopsis: This test attempts various operations on StgCreateDocFile, Stg // OpenStorage API's // // Arguments:[argc] // [argv] // // Returns: HRESULT // // Notes: This test runs in direct, transacted, and transacted deny write // modes // // History: 18-June-1996 NarindK Created. // // New Test Notes: // 1. Old File: IAPISTG.CXX // 2. Old name of test : IllegitAPIStg test // New Name of test : APITEST_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:APITEST-100 // /dfRootMode:dirReadWriteShEx /dfname:APITEST.100 /labmode // b. stgbase /seed:2 /dfdepth:0-0 /dfstg:0-0 /dfstm:0-0 /t:APITEST-100 // /dfRootMode:xactReadWriteShEx /dfname:APITEST.100 /labmode // c. stgbase /seed:2 /dfdepth:0-0 /dfstg:0-0 /dfstm:0-0 /t:APITEST-100 // /dfRootMode:xactReadWriteShDenyW /dfname:APITEST.100 /labmode // // BUGNOTE: Conversion: APITEST-100 NO // //----------------------------------------------------------------------------- HRESULT APITEST_100(int argc, char *argv[]) { HRESULT hr = S_OK; HRESULT hr2 = S_OK; ChanceDF *pTestChanceDF = NULL; VirtualDF *pTestVirtualDF = NULL; VirtualCtrNode *pVirtualDFRoot = NULL; LPTSTR pRootDocFileName = NULL; DWORD dwRootMode = NULL; LPSTORAGE pIStorage = NULL; LPSTORAGE pIStorageOpen = NULL; LPOLESTR pOleStrTemp = NULL; TCHAR tszTestName[10] = TEXT("NonExist"); LPOLESTR pOleStrTest = NULL; SNB snbTest = NULL; SNB snbTemp = NULL; ULONG ulRef = 0; OLECHAR *ocsSNBChar = NULL; ULONG i = 0; BOOL fPass = TRUE; // Not for 2phase. Bail. if (DoingDistrib ()) { return S_OK; } DH_FUNCENTRY(NULL, DH_LVL_DFLIB, _TEXT("APITEST_100")); DH_TRACE((DH_LVL_TRACE1, TEXT("--------------------------------------------")) ); DH_TRACE((DH_LVL_TRACE1, TEXT("Test variation APITEST_100 started.")) ); DH_TRACE((DH_LVL_TRACE1, TEXT("Attempt illegitimate ops on StgCreateDocFIle & StgOpenStorage."))); // Create the new ChanceDocFile tree that would consist of chance nodes. if (S_OK == hr) { pTestChanceDF = new ChanceDF(); if(NULL == pTestChanceDF) { hr = E_OUTOFMEMORY; } DH_HRCHECK(hr, TEXT("new ChanceDF")) ; } if (S_OK == hr) { hr = pTestChanceDF->CreateFromParams(argc, argv); DH_HRCHECK(hr, TEXT("ChanceDF::CreateFromParams")) ; } if (S_OK == hr) { dwRootMode = pTestChanceDF->GetRootMode(); DH_TRACE(( DH_LVL_TRACE1, TEXT("Run Mode for APITEST_100, Access mode: %lx"), pTestChanceDF->GetRootMode())); } // Get RootDocFile name if (S_OK == hr) { if(NULL != pTestChanceDF->GetDocFileName()) { pRootDocFileName = new TCHAR[_tcslen(pTestChanceDF->GetDocFileName())+1]; if (pRootDocFileName == NULL) { hr = E_OUTOFMEMORY; } else { _tcscpy(pRootDocFileName, pTestChanceDF->GetDocFileName()); } DH_HRCHECK(hr, TEXT("new TCHAR")); } DH_HRCHECK(hr, TEXT("ChanceDF::GetDocFileName")) ; } if(S_OK == hr) { // Convert RootDocFile name to OLECHAR hr = TStringToOleString(pRootDocFileName, &pOleStrTemp); DH_HRCHECK(hr, TEXT("TStringToOleString")) ; } // Try calling StgCreateDocFile with mode STGM_CREATE|STGM_CONVERT if (S_OK == hr) { pIStorage = NULL; hr = StgCreateDocfile( pOleStrTemp, STGM_CREATE | STGM_CONVERT, 0, &pIStorage); CheckErrorTest(STG_E_INVALIDFLAG, TEXT ("StgCreateDocfile inv Flags"), pIStorage); } // Try calling StgCreateDocFile with mode equal to -1 if (S_OK == hr) { pIStorage = NULL; hr = StgCreateDocfile( pOleStrTemp, (DWORD) -1, 0, &pIStorage); CheckErrorTest(STG_E_INVALIDFLAG, TEXT ("StgCreateDocfile inv mode"), pIStorage); } // Try calling StgCreateDocFile with nonzero reserved parameter if (S_OK == hr) { pIStorage = NULL; hr = StgCreateDocfile( pOleStrTemp, STGM_CREATE | dwRootMode, (DWORD)999, &pIStorage); CheckErrorTest(STG_E_INVALIDPARAMETER, TEXT ("StgCreateDocfile inv reserved"), pIStorage); } // Try calling StgCreateDocFile with NULL ppstgOpen parameter 4th if (S_OK == hr) { hr = StgCreateDocfile( pOleStrTemp, dwRootMode, 0, NULL); CheckErrorTest2(STG_E_INVALIDPOINTER, TEXT ("StgCreateDocfile inv ppstg bucket")); } // Now create a valid DocFile // Create the VirtualDocFile tree from the ChanceDocFile tree created in // the previous step. The VirtualDocFile tree consists of VirtualCtrNodes // and VirtualStmNodes. if (S_OK == hr) { pTestVirtualDF = new VirtualDF(); if(NULL == pTestVirtualDF) { hr = E_OUTOFMEMORY; } DH_HRCHECK(hr, TEXT("new VirtualDF")) ; } if (S_OK == hr) { hr = pTestVirtualDF->GenerateVirtualDF(pTestChanceDF, &pVirtualDFRoot); DH_HRCHECK(hr, TEXT("VirtualCtrNode::GenerateVirtualDF")) ; } // Now try commiting with grfCommitFlags = -1 if (S_OK == hr) { hr = pVirtualDFRoot->Commit((DWORD) -1); CheckErrorTest2(STG_E_INVALIDFLAG, TEXT ("VirtualCtrNode::Commit inv flag")); } // Now do a valid commit if (S_OK == hr) { hr = pVirtualDFRoot->Commit(STGC_DEFAULT); DH_HRCHECK (hr, TEXT("VirtualCtrNode::Commit")); } // Close the root docfile if (NULL != pVirtualDFRoot) { hr2 = pVirtualDFRoot->Close(); DH_HRCHECK (hr2, TEXT("VirtualCtrNode::Close")); hr = FirstError (hr, hr2); } // Instantiate DocFile with grfMode=-1 if (S_OK == hr) { pIStorageOpen = NULL; hr = StgOpenStorage( pOleStrTemp, NULL, (DWORD) -1, NULL, 0, &pIStorageOpen); CheckErrorTest(STG_E_INVALIDFLAG, TEXT ("StgOpenStorage inv mode"), pIStorageOpen); } // Instantiate DocFile with name as " " // NOTE: The old test checked the erro value to be STG_E_FILENOTFOUND in // this case. On NT, we get STG_E_PATHNOTFOUND and on Chicago, we get // STG_E_ACCESSDENIED, so let us check against S_OK itself. if (S_OK == hr) { pIStorageOpen = NULL; hr = StgOpenStorage( (OLECHAR *) " ", NULL, dwRootMode, NULL, 0, &pIStorageOpen); if (RunningOnNT()) { CheckErrorTest(STG_E_PATHNOTFOUND, TEXT("StgOpenStorage inv name"), pIStorageOpen); } else { CheckErrorTest(STG_E_ACCESSDENIED, TEXT("StgOpenStorage inv name"), pIStorageOpen); } } // Instantiate DocFile with nonexisting file name if(S_OK == hr) { // Convert tszTestName to OLECHAR hr = TStringToOleString(tszTestName, &pOleStrTest); DH_HRCHECK(hr, TEXT("TStringToOleString")) ; } if (S_OK == hr) { pIStorageOpen = NULL; hr = StgOpenStorage( pOleStrTest, NULL, dwRootMode, NULL, 0, &pIStorageOpen); CheckErrorTest(STG_E_FILENOTFOUND, TEXT ("StgOpenStorage inv name"), pIStorageOpen); } // Instantiate DocFile with NULL file name if (S_OK == hr) { pIStorageOpen = NULL; hr = StgOpenStorage( NULL, NULL, dwRootMode, NULL, 0, &pIStorageOpen); CheckErrorTest(STG_E_INVALIDNAME, TEXT ("StgOpenStorage NULL name"), pIStorageOpen); } // Instantiate DocFile with non zero dwReserved parameter if (S_OK == hr) { pIStorageOpen = NULL; hr = StgOpenStorage( pOleStrTemp, NULL, dwRootMode, NULL, 999, &pIStorageOpen); CheckErrorTest(STG_E_INVALIDPARAMETER, TEXT ("StgOpenStorage inv reserved"), pIStorageOpen); } // Instantiate DocFile with NULL ppstgOpen parameter (6th) if (S_OK == hr) { hr = StgOpenStorage( pOleStrTemp, NULL, dwRootMode, NULL, 0, NULL); CheckErrorTest2(STG_E_INVALIDPOINTER, TEXT ("StgOpenStorage NULL ppstg")); } // Instantiate DocFile with grfMode as dwRootMode|STGM_DELETEONRELEASE // NOTE: The doc says, erro code in this case to be STG_E_INVALIDFUNCTION, // but error STG_E_INVALIDFLAG returned. if (S_OK == hr) { pIStorageOpen = NULL; hr = StgOpenStorage( pOleStrTemp, NULL, dwRootMode | STGM_DELETEONRELEASE, NULL, 0, &pIStorageOpen); CheckErrorTest(STG_E_INVALIDFUNCTION, TEXT ("StgOpenStorage DELETEONRELEASE in mode"), pIStorageOpen); } // Create snbTest with spcae for two names and set name list to NULL i.e. // a vaild SNB with no name in the block if(S_OK == hr) { snbTest = (OLECHAR **) new OLECHAR [sizeof(OLECHAR *) * 2]; if(NULL == snbTest) { hr = E_OUTOFMEMORY; } else { *snbTest = NULL; } DH_HRCHECK (hr, TEXT("new OLECHAR")); } // Instantiate DocFile with above empty but valid SNB if (S_OK == hr) { pIStorageOpen = NULL; hr = StgOpenStorage( pOleStrTemp, NULL, dwRootMode, snbTest, 0, &pIStorageOpen); DH_HRCHECK(hr, TEXT("StgOpenStorage empty SNB")) ; // Release the pointer if(NULL != pIStorageOpen) { ulRef = pIStorageOpen->Release(); DH_ASSERT (0 == ulRef); pIStorageOpen = NULL; } } // Allocate space for long name and fill name with // X's, make next SNB elment NULL, and make a call to StgOpenStorage API // with too long a name in SNB if(S_OK == hr) { *snbTest = (OLECHAR *) new OLECHAR [MAX_STG_NAME_LEN*12]; if (NULL == *snbTest) { hr = E_OUTOFMEMORY; } DH_HRCHECK (hr, TEXT("new OLECHAR")); } if(S_OK == hr) { snbTemp = snbTest; ocsSNBChar = *snbTemp; for (i=0; i<( MAX_STG_NAME_LEN*12 -1); i++) { ocsSNBChar[i] = 'X'; } ocsSNBChar[i] = '\0'; // Assign second element as NULL snbTemp++; *snbTemp = NULL; } // Instantiate DocFile with above SNB with too long a name in it. // NOTE: In the old test, this was supposed to fail. Doesn't fail // now... Confirmed with Philipla - No length verification of SNB // names done in ValidateSNB in OLE if (S_OK == hr) { pIStorageOpen = NULL; hr = StgOpenStorage( pOleStrTemp, NULL, dwRootMode, snbTest, 0, &pIStorageOpen); DH_HRCHECK (hr, TEXT("StgOpenStorage long SNB")); //Release storage pointer if(NULL != pIStorageOpen) { ulRef = pIStorageOpen->Release(); DH_ASSERT (0 == ulRef); pIStorageOpen = NULL; } } // if something did no pass, mark test (hr) as E_FAIL if (FALSE == fPass) { hr = FirstError (hr, E_FAIL); } // if everything goes well, log test as passed else failed. if ((S_OK == hr) && (TRUE == fPass)) { DH_LOG((LOG_PASS, TEXT("Test variation APITEST_100 passed.")) ); } else { DH_LOG(( LOG_FAIL, TEXT("Test variation APITEST_100 failed; hr=%#lx; fPass=%d"), hr, fPass)); } // Cleanup // Delete Chance docfile tree if(NULL != pTestChanceDF) { hr2 = pTestChanceDF->DeleteChanceDocFileTree( pTestChanceDF->GetChanceDFRoot()); DH_HRCHECK(hr2, TEXT("ChanceDF::DeleteChanceFileDocTree")) ; delete pTestChanceDF; pTestChanceDF = NULL; } // Delete Virtual docfile tree if(NULL != pTestVirtualDF) { hr2 = pTestVirtualDF->DeleteVirtualDocFileTree(pVirtualDFRoot); DH_HRCHECK(hr2, TEXT("VirtualDF::DeleteVirtualFileDocTree")) ; delete pTestVirtualDF; pTestVirtualDF = NULL; } // Delete the docfile on disk if((S_OK == hr) && (NULL != pRootDocFileName)) { if(FALSE == DeleteFile(pRootDocFileName)) { hr2 = HRESULT_FROM_WIN32(GetLastError()) ; DH_HRCHECK(hr2, TEXT("DeleteFile")) ; } } // Delete temp strings if(NULL != pOleStrTemp) { delete []pOleStrTemp; pOleStrTemp = NULL; } if(NULL != pOleStrTest) { delete []pOleStrTest; pOleStrTest = NULL; } if(NULL != pRootDocFileName) { delete []pRootDocFileName; pRootDocFileName = NULL; } // Free SNB if(NULL != snbTest) { if(NULL != *snbTest) { delete [] *snbTest; *snbTest = NULL; } delete [] snbTest; snbTest = NULL; } // Stop logging the test DH_TRACE((DH_LVL_TRACE1, TEXT("Test variation APITEST_100 finished")) ); DH_TRACE((DH_LVL_TRACE1, TEXT("--------------------------------------------")) ); return hr; } //---------------------------------------------------------------------------- // // Test: APITEST_101 // // Synopsis: The test attempts various illegitimate operations using names // greater than MAX_STG_NAME_LEN, it then attempts to create // several random named root docfiles. If the create is succesful, // then a random named child IStorage or IStream is also created. // Whether or not the root create was successful, we attempt to // open the root docfile (this is expected to fail, the point is // to check for asserts/GP faults rather than return codes). If // the instantiation is successful, the test also tries to // instantiate the child object. All objects are then released. // // Arguments:[argc] // [argv] // // Returns: HRESULT // // History: 18-June-1996 NarindK Created. // // Notes: This test runs in direct, transacted, and transacted deny write // modes // // New Test Notes: // 1. Old File: IANAMES.CXX // 2. Old name of test : IllegitAPINames test // New Name of test : APITEST_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:APITEST-101 // /dfRootMode:dirReadWriteShEx /dfStgMode:dirReadWriteShEx // b. stgbase /seed:2 /dfdepth:0-0 /dfstg:0-0 /dfstm:0-0 /t:APITEST-101 // /dfRootMode:xactReadWriteShEx /dfStgMode:xactReadWriteShEx // c. stgbase /seed:2 /dfdepth:0-0 /dfstg:0-0 /dfstm:0-0 /t:APITEST-101 // /dfRootMode:xactReadWriteShDenyW /dfStgMode:xactReadWriteShEx // // BUGNOTE: Conversion: APITEST-101 NO // //----------------------------------------------------------------------------- HRESULT APITEST_101(int argc, char *argv[]) { #ifdef _MAC // Simple mode not ported yet; check with the developers // and remove this when ready DH_TRACE((DH_LVL_TRACE1, TEXT("!!!!!!!!!!!!!!!APITEST-101 crashes.")) ); DH_TRACE((DH_LVL_TRACE1, TEXT("!!!!!!!!!!!!!!!To be investigated")) ); return E_NOTIMPL; #else HRESULT hr = S_OK; HRESULT hr2 = S_OK; ChanceDF *pTestChanceDF = NULL; VirtualDF *pTestVirtualDF = NULL; VirtualCtrNode *pVirtualDFRoot = NULL; LPTSTR pFileName = NULL; LPOLESTR poszBadName = NULL; LPOLESTR poszBadNameStg = NULL; LPTSTR ptszBadNameStg = NULL; DWORD dwRootMode = 0; ULONG i = 0; LPSTORAGE pIStorage = NULL; LPSTORAGE pIStorageChild = NULL; LPSTREAM pIStreamChild = NULL; DG_STRING *pdgu = NULL; DG_INTEGER *pdgi = NULL; LPTSTR pRootNewChildStgName = NULL; VirtualCtrNode *pvcnRootNewChildStorage= NULL; BOOL fPass = TRUE; // Not for 2phase. Bail. if (DoingDistrib ()) { return S_OK; } DH_FUNCENTRY(NULL, DH_LVL_DFLIB, _TEXT("APITEST_101")); DH_TRACE((DH_LVL_TRACE1, TEXT("--------------------------------------------")) ); DH_TRACE((DH_LVL_TRACE1, TEXT("Test variation APITEST_101 started.")) ); DH_TRACE((DH_LVL_TRACE1, TEXT("Call StgCreateDocFile/CreateStorage/CreateStream with too long names"))); // Create the new ChanceDocFile tree that would consist of chance nodes. if (S_OK == hr) { pTestChanceDF = new ChanceDF(); if(NULL == pTestChanceDF) { hr = E_OUTOFMEMORY; } DH_HRCHECK(hr, TEXT("new ChanceDF")) ; } if (S_OK == hr) { hr = pTestChanceDF->CreateFromParams(argc, argv); DH_HRCHECK(hr, TEXT("ChanceDF::CreateFromParams")) ; } if (S_OK == hr) { dwRootMode = pTestChanceDF->GetRootMode(); DH_TRACE(( DH_LVL_TRACE1, TEXT("Run Mode for APITEST_101, Access mode: %lx"), pTestChanceDF->GetRootMode())); } // Call StgCreateDocFile with too long a name for docfile. // NOTE: Old test to fail with MAX_STG_NAME_LEN*3, but not in new test, // fails with MAX_STG_NAME_LEN*4. // NOTE: Crashes in DfFromName in OLE if length is of MAX_STG_NAME_LEN*8 // CHECK!!! if(S_OK == hr) { poszBadName = (OLECHAR *) new OLECHAR [MAX_STG_NAME_LEN*4]; if (NULL == poszBadName) { hr = E_OUTOFMEMORY; } DH_HRCHECK(hr, TEXT("new OLECHAR")) ; } if(S_OK == hr) { for (i=0; i<( MAX_STG_NAME_LEN*4 -1); i++) { poszBadName[i] = i%20 + OLECHAR('A'); } poszBadName[i] = OLECHAR('\0'); } // Try calling StgCreateDocFile with the above long name pszBadName if (S_OK == hr) { pIStorage = NULL; DH_TRACE ((DH_LVL_TRACE4, TEXT("Filename:%s"), poszBadName)); //BUGBUG - work on chicago? hr = StgCreateDocfile( poszBadName, dwRootMode | STGM_CREATE, 0, &pIStorage); CheckErrorTest(STG_E_PATHNOTFOUND, TEXT ("StgCreateDocfile long name"), pIStorage); } // Now create a valid DocFile // Create the VirtualDocFile tree from the ChanceDocFile tree created in // the previous step. if (S_OK == hr) { pTestVirtualDF = new VirtualDF(); if(NULL == pTestVirtualDF) { hr = E_OUTOFMEMORY; } DH_HRCHECK(hr, TEXT("new VirtualDF")) ; } if (S_OK == hr) { hr = pTestVirtualDF->GenerateVirtualDF(pTestChanceDF, &pVirtualDFRoot); DH_HRCHECK(hr, TEXT("VirtualDF::GenerateVirtualDF")) ; } // Get IStorage pointer if (S_OK == hr) { pIStorage = pVirtualDFRoot->GetIStoragePointer(); DH_ASSERT (NULL != pIStorage); if (NULL == pIStorage) { hr = E_FAIL; } } // Call CreateStorage with too long a name for docfile. if(S_OK == hr) { ptszBadNameStg = (TCHAR *) new TCHAR [MAX_STG_NAME_LEN*3]; if (NULL == ptszBadNameStg) { hr = E_OUTOFMEMORY; } DH_HRCHECK(hr, TEXT("new TCHAR")) ; } if(S_OK == hr) { for (i=0; i<( MAX_STG_NAME_LEN*3 -1); i++) { ptszBadNameStg[i] = TEXT('Y'); } ptszBadNameStg[i] = TEXT('\0'); } if(S_OK == hr) { // Convert Bad storage name to OLECHAR hr = TStringToOleString(ptszBadNameStg, &poszBadNameStg); DH_HRCHECK(hr, TEXT("TStringToOleString")) ; } // now call CreateStorage with too long a name... if (S_OK == hr) { hr = pIStorage->CreateStorage( poszBadNameStg, pTestChanceDF->GetStgMode(), 0, 0, &pIStorageChild); CheckErrorTest(STG_E_INVALIDNAME, TEXT ("IStorage::CreateStorage long name"), pIStorageChild); } // Now call CreateStream with too long a name... if (S_OK == hr) { hr = pIStorage->CreateStream( poszBadNameStg, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &pIStreamChild); CheckErrorTest(STG_E_INVALIDNAME, TEXT ("IStorage::CreateStream long name"), pIStreamChild); } // Now add a Valid storage to root. Call AddStorage that in turns calls // CreateStorage if (S_OK == hr) { pdgu = pTestVirtualDF->GetDataGenUnicode(); DH_ASSERT (NULL != pdgu); if (NULL == pdgu) { hr = E_FAIL; } } 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")) ; } // Now try to rename this storage element to a bad name. if(S_OK == hr) { DH_EXPECTEDERROR (STG_E_INVALIDNAME); hr = pvcnRootNewChildStorage->Rename(ptszBadNameStg); DH_NOEXPECTEDERROR (); CheckErrorTest2(STG_E_INVALIDNAME, TEXT ("VirtualCtrNode::Rename long name")); } // Close the Storage pvcnRootNewChildStorage if (NULL != pvcnRootNewChildStorage) { hr2 = pvcnRootNewChildStorage->Close(); DH_HRCHECK(hr2, TEXT("VirtualCtrNode::Close")) ; hr = FirstError (hr, hr2); } // Close the root docfile if (NULL != pVirtualDFRoot) { hr2 = pVirtualDFRoot->Close(); DH_HRCHECK(hr2, TEXT("VirtualCtrNode::Close")) ; hr = FirstError (hr, hr2); } // Delete temp strings if(NULL != poszBadNameStg) { delete [] poszBadNameStg; poszBadNameStg = NULL; } if(NULL != poszBadName) { delete [] poszBadName; poszBadName = NULL; } if(NULL != ptszBadNameStg) { delete [] ptszBadNameStg; ptszBadNameStg = NULL; } if(NULL != pRootNewChildStgName) { delete [] pRootNewChildStgName; pRootNewChildStgName = NULL; } // In the following section of test: //make a random number of random length, random character root //docfiles. for this variation, we don't care if the operation //succeeds, looking for GP faults and asserts only. if the //StgCreateDocfile fails, we'll still attempt the open. of //course, the open in this case will be expected to fail, but //again, we won't be checking return codes... If the StgCreateDocfile //passes, we'll create a random name IStream or IStorage too. ULONG count = 0; ULONG cMinNum = 16; ULONG cMaxNum = 128; LPTSTR ptszRandomRootName = NULL; LPTSTR ptszRandomChildName = NULL; ULONG countFlag = 0; ULONG cMinFlag = 0; ULONG cMaxFlag = 100; ULONG nChildType = 0; LPSTORAGE pstgRoot = NULL; LPSTORAGE pstgChild = NULL; LPSTREAM pstmChild = NULL; LPOLESTR poszRandomRootName = NULL; LPOLESTR poszRandomChildName = NULL; ULONG ulRef = 0; if (S_OK == hr) { pdgi = pTestVirtualDF->GetDataGenInteger(); DH_ASSERT (NULL != pdgi); if (NULL == pdgi) { hr = E_FAIL; } } if(S_OK == hr) { hr = pdgi->Generate(&count, cMinNum, cMaxNum); DH_HRCHECK(hr, TEXT("dgi::Generate")) ; } while(count--) { if(S_OK == hr) { hr=GenerateRandomName(pdgu,MINLENGTH,MAXLENGTH,&ptszRandomRootName); DH_HRCHECK(hr, TEXT("GenerateRandomName")) ; } if(S_OK == hr) { // Convert name to OLECHAR hr = TStringToOleString(ptszRandomRootName, &poszRandomRootName); DH_HRCHECK(hr, TEXT("TStringToOleString")) ; } if (S_OK == hr) { pstgRoot = NULL; hr = StgCreateDocfile( poszRandomRootName, dwRootMode | STGM_CREATE, 0, &pstgRoot); DH_HRCHECK(hr, TEXT("StgCreateDocfile")) ; } nChildType = NONE; if(S_OK == hr) { if(S_OK == hr) { hr=GenerateRandomName( pdgu, MINLENGTH, MAXLENGTH, &ptszRandomChildName); DH_HRCHECK(hr, TEXT("GenerateRandomName")) ; } if(S_OK == hr) { // Convert name to OLECHAR hr = TStringToOleString( ptszRandomChildName, &poszRandomChildName); DH_HRCHECK(hr, TEXT("TStringToOleString")) ; } if(S_OK == hr) { hr = pdgi->Generate(&countFlag, cMinFlag, cMaxFlag); DH_HRCHECK(hr, TEXT("dgi::Generate")) ; } if(countFlag > (cMaxFlag/2)) { hr = pstgRoot->CreateStorage( poszRandomChildName, pTestChanceDF->GetStgMode(), 0, 0, &pstgChild); DH_HRCHECK(hr, TEXT("IStorage::CreateStorage")) ; if(S_OK == hr) { nChildType = STORAGE; hr = pstgRoot->Commit(STGC_DEFAULT); DH_HRCHECK(hr, TEXT("IStorage::Commit")) ; ulRef = pstgChild->Release(); DH_ASSERT (0 == ulRef); pstgChild = NULL; } } else { hr = pstgRoot->CreateStream( poszRandomChildName, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &pstmChild); DH_HRCHECK(hr, TEXT("IStorage::CreateStream")) ; if(S_OK == hr) { nChildType = STREAM; hr = pstgRoot->Commit(STGC_DEFAULT); DH_HRCHECK(hr, TEXT("IStorage::Commit")) ; ulRef = pstmChild->Release(); DH_ASSERT (0 == ulRef); pstmChild = NULL; } } ulRef = pstgRoot->Release(); DH_ASSERT (0 == ulRef); pstgRoot = NULL; } //Try to open Root Storage whetehr the creation was successful or not hr = StgOpenStorage( poszRandomRootName, NULL, pTestChanceDF->GetStgMode(), NULL, 0, &pstgRoot); DH_HRCHECK(hr, TEXT("StgOpenStorage")) ; if(S_OK == hr) { switch(nChildType) { case STORAGE: { hr = pstgRoot->OpenStorage( poszRandomChildName, NULL, pTestChanceDF->GetStgMode(), NULL, 0, &pstgChild); DH_HRCHECK(hr, TEXT("IStorage::OpenStorage")) ; if(S_OK == hr) { ulRef = pstgChild->Release(); DH_ASSERT (0 == ulRef); pstgChild = NULL; } break; } case STREAM: { hr = pstgRoot->OpenStream( poszRandomChildName, NULL, STGM_READWRITE|STGM_SHARE_EXCLUSIVE, 0, &pstmChild); DH_HRCHECK(hr, TEXT("IStorage::OpenStream")) ; if(S_OK == hr) { ulRef = pstmChild->Release(); DH_ASSERT (0 == ulRef); pstmChild = NULL; } break; } } ulRef = pstgRoot->Release(); DH_ASSERT (0 == ulRef); pstgRoot = NULL; } // Delete temp strings if(NULL != ptszRandomChildName) { delete [] ptszRandomChildName; ptszRandomChildName = NULL; } if(NULL != ptszRandomRootName) { if(FALSE == DeleteFile(ptszRandomRootName)) { hr = HRESULT_FROM_WIN32(GetLastError()) ; DH_HRCHECK(hr, TEXT("DeleteFile")) ; } delete [] ptszRandomRootName; ptszRandomRootName = NULL; } if(NULL != poszRandomChildName) { delete [] poszRandomChildName; poszRandomChildName = NULL; } if(NULL != poszRandomChildName) { delete [] poszRandomChildName; poszRandomChildName = NULL; } } // if something did no pass, mark test (hr) as E_FAIL if (FALSE == fPass) { hr = FirstError (hr, E_FAIL); } // if everything goes well, log test as passed else failed. if ((S_OK == hr) && (TRUE == fPass)) { DH_LOG((LOG_PASS, TEXT("Test variation APITEST_101 passed.")) ); } else { DH_LOG((LOG_FAIL, TEXT("Test variation APITEST_101 failed; hr=%#lx; fPass=%d"), hr, fPass)); } // Cleanup // Get the name of file, will be used later to delete the file if(NULL != pTestVirtualDF) { pFileName= new TCHAR[_tcslen(pTestVirtualDF->GetDocFileName())+1]; if (pFileName != NULL) { _tcscpy(pFileName, pTestVirtualDF->GetDocFileName()); } } // Delete Chance docfile tree if(NULL != pTestChanceDF) { hr2 = pTestChanceDF->DeleteChanceDocFileTree( pTestChanceDF->GetChanceDFRoot()); DH_HRCHECK(hr2, TEXT("ChanceDF::DeleteChanceFileDocTree")) ; delete pTestChanceDF; pTestChanceDF = NULL; } // Delete Virtual docfile tree if(NULL != pTestVirtualDF) { hr2 = pTestVirtualDF->DeleteVirtualDocFileTree(pVirtualDFRoot); DH_HRCHECK(hr2, TEXT("VirtualDF::DeleteVirtualFileDocTree")) ; delete pTestVirtualDF; pTestVirtualDF = NULL; } // Delete the docfile on disk if((S_OK == hr) && (NULL != pFileName)) { if(FALSE == DeleteFile(pFileName)) { hr2 = HRESULT_FROM_WIN32(GetLastError()) ; DH_HRCHECK(hr2, TEXT("DeleteFile")) ; } } // Delete temp strings if(NULL != pFileName) { delete []pFileName; pFileName = NULL; } // Stop logging the test DH_TRACE((DH_LVL_TRACE1, TEXT("Test variation APITEST_101 finished")) ); DH_TRACE((DH_LVL_TRACE1, TEXT("--------------------------------------------")) ); return hr; #endif //_MAC } //---------------------------------------------------------------------------- // // Test: APITEST_102 // // Synopsis: Attempts various operations in obtaining enumerators, checking // for proper error return. Then gets a valid enumerator, and // attempts various illegitimate method calls on it. Verify // proper return codes. // // Arguments:[argc] // [argv] // // Returns: HRESULT // // History: 18-June-1996 NarindK Created. // // Notes: This test runs in direct, transacted, and transacted deny write // modes // // New Test Notes: // 1. Old File: IAENUM.CXX // 2. Old name of test : IllegitAPIEnum test // New Name of test : APITEST_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:APITEST-102 // /dfRootMode:dirReadWriteShEx /dfStgMode:dirReadWriteShEx /labmode // b. stgbase /seed:2 /dfdepth:0-0 /dfstg:0-0 /dfstm:0-0 /t:APITEST-102 // /dfRootMode:xactReadWriteShEx /dfStgMode:xactReadWriteShEx /labmode // c. stgbase /seed:2 /dfdepth:0-0 /dfstg:0-0 /dfstm:0-0 /t:APITEST-102 // /dfRootMode:xactReadWriteShDenyW /dfStgMode:xactReadWriteShEx /labmode // // BUGNOTE: Conversion: APITEST_102 //----------------------------------------------------------------------------- HRESULT APITEST_102(int argc, char *argv[]) { HRESULT hr = S_OK; HRESULT hr2 = S_OK; ChanceDF *pTestChanceDF = NULL; VirtualDF *pTestVirtualDF = NULL; VirtualCtrNode *pVirtualDFRoot = NULL; LPTSTR pRootNewChildStgName = NULL; VirtualCtrNode *pvcnRootNewChildStorage= NULL; DG_STRING *pdgu = NULL; DG_INTEGER *pdgi = NULL; LPENUMSTATSTG penumWalk = NULL; ULONG cMinNum = 1; ULONG cMaxNum = 999; DWORD dwReserved1 = 0; DWORD dwReserved3 = 0; LPTSTR pReserved2 = NULL; ULONG ulRef = 0; BOOL fPass = TRUE; STATSTG statStg; ULONG celtFetched = 0; LPMALLOC pMalloc = NULL; DH_FUNCENTRY(NULL, DH_LVL_DFLIB, _TEXT("APITEST_102")); DH_TRACE((DH_LVL_TRACE1, TEXT("--------------------------------------------")) ); DH_TRACE((DH_LVL_TRACE1, TEXT("Test variation APITEST_102 started.")) ); DH_TRACE((DH_LVL_TRACE1, TEXT("Attempt different illegitimate opeations on IEnumSTATSTG. "))); // 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 APITEST_102, Access mode: %lx"), pTestChanceDF->GetRootMode())); } // Adds a new storage to the root storage. if (S_OK == hr) { pdgu = pTestVirtualDF->GetDataGenUnicode(); DH_ASSERT (NULL != pdgu); if (NULL == pdgu) { hr = E_FAIL; } } if(S_OK == hr) { hr = GenerateRandomName(pdgu,MINLENGTH,MAXLENGTH,&pRootNewChildStgName); DH_HRCHECK(hr, TEXT("GenerateRandomName")) ; } if(S_OK == hr) { hr = AddStorage( pTestVirtualDF, pVirtualDFRoot, pRootNewChildStgName, pTestChanceDF->GetStgMode()| STGM_CREATE | STGM_FAILIFTHERE, &pvcnRootNewChildStorage); DH_HRCHECK(hr, TEXT("AddStorage")) ; } // BUGBUG: Use Random commit modes... if (S_OK == hr) { hr = pVirtualDFRoot->Commit(STGC_DEFAULT); DH_HRCHECK(hr, TEXT("VirtualCtrNode::Commit")) ; } // Close the Child storage if (NULL != pvcnRootNewChildStorage) { hr2 = pvcnRootNewChildStorage->Close(); DH_HRCHECK(hr2, TEXT("VirtualCtrNode::Close")) ; hr = FirstError (hr, hr2); } // Get the random number generator if (S_OK == hr) { pdgi = pTestVirtualDF->GetDataGenInteger(); DH_ASSERT (NULL != pdgi); if (NULL == pdgi) { hr = E_FAIL; } } if(S_OK == hr) { hr = pdgi->Generate(&dwReserved1, cMinNum, cMaxNum); DH_HRCHECK(hr, TEXT("dgi::Generate")) ; } //Call EnumElements with invalid parameters if(S_OK == hr) { DH_EXPECTEDERROR (STG_E_INVALIDPARAMETER); hr = pVirtualDFRoot->EnumElements( dwReserved1, pReserved2, dwReserved3, &penumWalk); DH_NOEXPECTEDERROR (); CheckErrorTest(STG_E_INVALIDPARAMETER, TEXT ("VirtualCtrNode::EnumElements inv dwReserved1"), penumWalk); } if(S_OK == hr) { hr = pdgi->Generate(&dwReserved3, cMinNum, cMaxNum); DH_HRCHECK(hr, TEXT("dgi::Generate")) ; } if(S_OK == hr) { DH_EXPECTEDERROR (STG_E_INVALIDPARAMETER); hr = pVirtualDFRoot->EnumElements( dwReserved1, pReserved2, dwReserved3, &penumWalk); DH_NOEXPECTEDERROR (); CheckErrorTest(STG_E_INVALIDPARAMETER, TEXT ("VirtualCtrNode::EnumElements inv dwReserved3"), penumWalk); } if(S_OK == hr) { hr = GenerateRandomName(pdgu,MINLENGTH,MAXLENGTH, &pReserved2); DH_HRCHECK(hr, TEXT("GenerateRandomName")) ; } if(S_OK == hr) { DH_EXPECTEDERROR (STG_E_INVALIDPARAMETER); hr = pVirtualDFRoot->EnumElements( dwReserved1, pReserved2, dwReserved3, &penumWalk); DH_NOEXPECTEDERROR (); CheckErrorTest(STG_E_INVALIDPARAMETER, TEXT ("VirtualCtrNode::EnumElements inv pvReserved1"), penumWalk); } // Now call EnumElements with NULL ppenm 4th parameter. if(S_OK == hr) { DH_EXPECTEDERROR (STG_E_INVALIDPOINTER); hr = pVirtualDFRoot->EnumElements( 0, NULL, 0, NULL); DH_NOEXPECTEDERROR (); CheckErrorTest2(STG_E_INVALIDPOINTER, TEXT ("VirtualCtrNode::EnumElements NULL ppEnum")); } // Make a valid call to EnumElements now if(S_OK == hr) { hr = pVirtualDFRoot->EnumElements( 0, NULL, 0, &penumWalk); DH_HRCHECK(hr, TEXT("VirtualCtrNode::EnumElements")) ; DH_ASSERT (NULL != penumWalk); } // Now try the following skip calls - Attempt to skip 0 elements and // attempt to skip MAX_ULONG elements. // Attempt to Skip 0 elements. if(S_OK == hr) { hr = penumWalk->Skip(0L); DH_HRCHECK(hr, TEXT("IEnumSTATSTG::Skip")) ; } // Attempt to Skip ULONG_MAX elements. // NOTE: In the old test, this was supposed to return S_OK, but it returns // S_FALSE if(S_OK == hr) { hr = penumWalk->Skip(ULONG_MAX); CheckErrorTest2(S_FALSE, TEXT ("IEnumSTATSTG::Skip ULONG_MAX")); } // Call Clone with NULL ppenum parameter (ist) if(S_OK == hr) { hr = penumWalk->Clone(NULL); CheckErrorTest2(STG_E_INVALIDPOINTER, TEXT ("IEnumSTATSTG::Clone NULL ppEnum")); } if(S_OK == hr) { statStg.pwcsName = NULL; // first get pmalloc that would be used to free up the name string from // STATSTG. hr = CoGetMalloc(MEMCTX_TASK, &pMalloc); DH_HRCHECK(hr, TEXT("CoGetMalloc")) ; } // Reset the enumerator back to start and then test Next methods if(S_OK == hr) { hr = penumWalk->Reset(); DH_HRCHECK(hr, TEXT("IEnumSTATSTG:Reset")) ; } // Call Next with celt equal to zero, but pceltFetched as not NULL if(S_OK == hr) { hr = penumWalk->Next(0, &statStg, &celtFetched); DH_HRCHECK(hr, TEXT("IEnumSTATSTG::Next celt 0")) ; } // Call Next with celt equal to 999 and celtFetched as NULL if(S_OK == hr) { hr = penumWalk->Next(999, &statStg ,NULL); CheckErrorTest2(STG_E_INVALIDPARAMETER, TEXT ("IEnumSTATSTG::Next celt 999 and pceltFetched NULL")); } // Call Next with rgelt as NULL (2nd parameter). celtFetched may be NULL // when celt asked is 1 if(S_OK == hr) { hr = penumWalk->Next(1, NULL, NULL); CheckErrorTest2(STG_E_INVALIDPOINTER, TEXT ("IEnumSTATSTG::Next rgelt NULL")); } // Call Next with celt as 1 and pceltFetched as NULL. Allowed as per spec if(S_OK == hr) { hr = penumWalk->Next(1, &statStg, NULL); DH_HRCHECK(hr, TEXT("IEnumSTATSTG::Next celt 1 and pceltFetched NULL")); } // Clean up if(NULL != statStg.pwcsName) { pMalloc->Free(statStg.pwcsName); statStg.pwcsName = NULL; } // Free LPENUMSTATSTG pointer if(NULL != penumWalk) { ulRef = penumWalk->Release(); DH_ASSERT (0 == ulRef); penumWalk = NULL; } // Close the root docfile if (NULL != pVirtualDFRoot) { hr2 = pVirtualDFRoot->Close(); DH_HRCHECK (hr2, TEXT("VirtualCtrNode::Close")); hr = FirstError (hr, hr2); } // if something did no pass, mark test (hr) as E_FAIL if (FALSE == fPass) { hr = FirstError (hr, E_FAIL); } // if everything goes well, log test as passed else failed. if ((S_OK == hr) && (TRUE == fPass)) { DH_LOG((LOG_PASS, TEXT("Test variation APITEST_102 passed.")) ); } else { DH_LOG((LOG_FAIL, TEXT("Test variation APITEST_102 failed; hr=%#lx; fPass=%d"), hr, fPass)); } // Cleanup CleanupTestDocfile (&pVirtualDFRoot, &pTestVirtualDF, &pTestChanceDF, S_OK == hr); // free strings if(NULL != pReserved2) { delete [] pReserved2; pReserved2 = NULL; } if(NULL != pRootNewChildStgName) { delete [] pRootNewChildStgName; pRootNewChildStgName = NULL; } // Stop logging the test DH_TRACE((DH_LVL_TRACE1, TEXT("Test variation APITEST_102 finished")) ); DH_TRACE((DH_LVL_TRACE1, TEXT("--------------------------------------------")) ); return hr; } //---------------------------------------------------------------------------- // // Test: APITEST_103 // // Synopsis: Attempts various illegit operations on the IStorage interface, // verifies proper return codes. // // Arguments:[argc] // [argv] // // Returns: HRESULT // // History: 18-June-1996 NarindK Created. // // Notes: This test runs in direct, transacted, and transacted deny write // modes // // New Test Notes: // 1. Old File: IASTORAG.CXX // 2. Old name of test : IllegitAPIStorage test // New Name of test : APITEST_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:APITEST-103 // /dfRootMode:dirReadWriteShEx /dfStgMode:dirReadWriteShEx // b. stgbase /seed:2 /dfdepth:0-0 /dfstg:0-0 /dfstm:0-0 /t:APITEST-103 // /dfRootMode:xactReadWriteShEx /dfStgMode:xactReadWriteShEx // c. stgbase /seed:2 /dfdepth:0-0 /dfstg:0-0 /dfstm:0-0 /t:APITEST-103 // /dfRootMode:xactReadWriteShDenyW /dfStgMode:xactReadWriteShEx // // BUGNOTE: Conversion: APITEST_103 //----------------------------------------------------------------------------- HRESULT APITEST_103(int argc, char *argv[]) { HRESULT hr = S_OK; HRESULT hr2 = S_OK; ChanceDF *pTestChanceDF = NULL; VirtualDF *pTestVirtualDF = NULL; VirtualCtrNode *pVirtualDFRoot = NULL; LPTSTR ptszChildStgName = NULL; LPOLESTR poszChildStgName = NULL; LPSTORAGE pStgRoot = NULL; LPSTORAGE pStgChild = NULL; LPSTORAGE pStgChild2 = NULL; LPSTREAM pStmChild = NULL; DG_STRING *pdgu = NULL; DG_INTEGER *pdgi = NULL; ULONG cRandom = 0; ULONG cMin = 1; ULONG cMax = 999; SNB snbTest = NULL; SNB snbTemp = NULL; OLECHAR *ocsSNBChar = NULL; ULONG ulRef = 0; ULONG i = 0; BOOL fPass = TRUE; DH_FUNCENTRY(NULL, DH_LVL_DFLIB, _TEXT("APITEST_103")); DH_TRACE((DH_LVL_TRACE1, TEXT("--------------------------------------------")) ); DH_TRACE((DH_LVL_TRACE1, TEXT("Test variation APITEST_103 started.")) ); DH_TRACE((DH_LVL_TRACE1, TEXT("Attempt various illegitimate operations on IStorage interface"))); // 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 APITEST_103, Access mode: %lx"), pTestChanceDF->GetRootMode())); } // Get IStorage pointer if (S_OK == hr) { pStgRoot = pVirtualDFRoot->GetIStoragePointer(); DH_ASSERT (NULL != pStgRoot); if (NULL == pStgRoot) { hr = E_FAIL; } } if (S_OK == hr) { pdgu = pTestVirtualDF->GetDataGenUnicode(); DH_ASSERT (NULL != pdgu); if (NULL == pdgu) { hr = E_FAIL; } } if(S_OK == hr) { hr = GenerateRandomName(pdgu,MINLENGTH,MAXLENGTH,&ptszChildStgName); DH_HRCHECK(hr, TEXT("GenerateRandomName")) ; } if(S_OK == hr) { // Convert name to OLECHAR hr = TStringToOleString(ptszChildStgName, &poszChildStgName); DH_HRCHECK(hr, TEXT("TStringToOleString")) ; } // Call CreateStorage with grfmode=-1 if (S_OK == hr) { hr = pStgRoot->CreateStorage( poszChildStgName, (DWORD) -1, 0, 0, &pStgChild); CheckErrorTest(STG_E_INVALIDFLAG, TEXT ("IStorage::CreateStorage inv mode"), pStgChild); } if (S_OK == hr) { pdgi = pTestVirtualDF->GetDataGenInteger(); DH_ASSERT (NULL != pdgi); if (NULL == pdgi) { hr = E_FAIL; } } if (S_OK == hr) { hr = pdgi->Generate(&cRandom, cMin, cMax); DH_HRCHECK(hr, TEXT("dgi::Generate")) ; } // Call CreateStorage with random data in dwReserved1 if (S_OK == hr) { hr = pStgRoot->CreateStorage( poszChildStgName, pTestChanceDF->GetStgMode() | STGM_CREATE, cRandom, 0, &pStgChild); CheckErrorTest(STG_E_INVALIDPARAMETER, TEXT ("IStorage::CreateStorage inv dwReserved1"), pStgChild); } // Call CreateStorage with random data in dwReserved2 if (S_OK == hr) { hr = pStgRoot->CreateStorage( poszChildStgName, pTestChanceDF->GetStgMode() | STGM_CREATE, 0, cRandom, &pStgChild); CheckErrorTest(STG_E_INVALIDPARAMETER, TEXT ("IStorage::CreateStorage inv dwReserved2"), pStgChild); } // Call CreateStorage with NULL 5th ppstg parameter if (S_OK == hr) { hr = pStgRoot->CreateStorage( poszChildStgName, pTestChanceDF->GetStgMode() | STGM_CREATE, 0, 0, NULL); CheckErrorTest2(STG_E_INVALIDPOINTER, TEXT ("IStorage::CreateStorage NULL ppstg")); } // Create a stream with poszChildName and later on try to instantiate the // child storage with that same name poszChildName if (S_OK == hr) { hr = pStgRoot->CreateStream( poszChildStgName, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &pStmChild); DH_HRCHECK (hr, TEXT("IStorage::CreateStream")); } // BUGBUG: Use Random commit modes... if (S_OK == hr) { hr = pVirtualDFRoot->Commit(STGC_DEFAULT); DH_HRCHECK (hr, TEXT("VirtualCtrNode::Commit")); } // Close stream... if (NULL != pStmChild) { ulRef = pStmChild->Release(); DH_ASSERT (0 == ulRef); pStmChild = NULL; } // Now try opening storage with name with which above stream was created // i.e. poszChildName if (S_OK == hr) { pStgChild = NULL; hr = pStgRoot->OpenStorage( poszChildStgName, NULL, pTestChanceDF->GetStgMode(), NULL, 0, &pStgChild); CheckErrorTest(STG_E_FILENOTFOUND, TEXT ("IStorage::OpenStorage inv name"), pStgChild); } //Destroy the stream element of this root storage having name poszChildStg //Name if(S_OK == hr) { hr = pStgRoot->DestroyElement(poszChildStgName); DH_HRCHECK(hr, TEXT("IStorage::DestroyElement")) ; } // Create a valid storage with name poszChildStgName if (S_OK == hr) { pStgChild = NULL; hr = pStgRoot->CreateStorage( poszChildStgName, pTestChanceDF->GetStgMode() | STGM_CREATE | STGM_FAILIFTHERE, 0, 0, &pStgChild); DH_HRCHECK(hr, TEXT("IStorage::CreateStorage")) ; } // Commit with grfCommitFlags = -1 if (S_OK == hr) { hr = pStgChild->Commit((DWORD) -1); CheckErrorTest2(STG_E_INVALIDFLAG, TEXT ("IStorage::Commit inv flag")); } // Commit the child. BUGBUG: Use random commit modes if (S_OK == hr) { hr = pStgChild->Commit(STGC_DEFAULT); DH_HRCHECK (hr, TEXT("IStorage::Commit")); } // Commit the root storage. BUGBUG: Use random commit modes if (S_OK == hr) { hr = pVirtualDFRoot->Commit(STGC_DEFAULT); DH_HRCHECK (hr, TEXT("VirtualCtrNode::Commit")); } // Attempt second instantiation of pStgChild which is already open. if (S_OK == hr) { hr = pStgRoot->OpenStorage( poszChildStgName, NULL, pTestChanceDF->GetStgMode(), NULL, 0, &pStgChild2); CheckErrorTest(STG_E_ACCESSDENIED, TEXT ("IStorage::OpenStorage 2nd time"), pStgChild2); } // Release the child if (NULL != pStgChild) { ulRef = pStgChild->Release(); DH_ASSERT (0 == ulRef); pStgChild = NULL; } // Now try to open child IStorage, but with grfMode = -1 if (S_OK == hr) { pStgChild = NULL; hr = pStgRoot->OpenStorage( poszChildStgName, NULL, (DWORD) -1, NULL, 0, &pStgChild); CheckErrorTest(STG_E_INVALIDFLAG, TEXT ("IStorage::OpenStorage inv mode"), pStgChild); } // Attempt OpenStorage with name as "" of IStorage to be opened. if (S_OK == hr) { pStgChild = NULL; hr = pStgRoot->OpenStorage( (OLECHAR *) " ", NULL, pTestChanceDF->GetStgMode(), NULL, 0, &pStgChild); CheckErrorTest(STG_E_FILENOTFOUND, TEXT ("IStorage::OpenStorage inv name"), pStgChild); } // Attempt OpenStorage with name as NULL of IStorage to be opened. #ifdef _MAC DH_TRACE((DH_LVL_TRACE1, TEXT("OpenStorage with NULL name skipped.")) ); #else if (S_OK == hr) { pStgChild = NULL; hr = pStgRoot->OpenStorage( NULL, NULL, pTestChanceDF->GetStgMode(), NULL, 0, &pStgChild); CheckErrorTest(STG_E_INVALIDNAME, TEXT ("IStorage::OpenStorage NULL name"), pStgChild); } #endif //_MAC // Attempt OpenStorage with name as NULL ppstg, 6th parameter. if (S_OK == hr) { hr = pStgRoot->OpenStorage( poszChildStgName, NULL, pTestChanceDF->GetStgMode(), NULL, 0, NULL); CheckErrorTest2(STG_E_INVALIDPOINTER, TEXT ("IStorage::OpenStorage NULL ppstg")); } // Attempt OpenStorage with random data in dwReserved parameter if (S_OK == hr && NULL != pdgi) { hr = pdgi->Generate(&cRandom, cMin, cMax); DH_HRCHECK(hr, TEXT("dgi::Generate")) ; } if (S_OK == hr) { pStgChild = NULL; hr = pStgRoot->OpenStorage( poszChildStgName, NULL, pTestChanceDF->GetStgMode(), NULL, cRandom, &pStgChild); CheckErrorTest(STG_E_INVALIDPARAMETER, TEXT ("IStorage::OpenStorage inv dwReserved"), pStgChild); } // Attempt OpenStorage with uninitialized SNB, should fail, but no GP // fault should occur. if(S_OK == hr) { snbTest = (OLECHAR **) new OLECHAR [sizeof(OLECHAR *) * 2]; if(NULL == snbTest) { hr = E_OUTOFMEMORY; } else { // bad pointer so SNB is not initialized *snbTest = (OLECHAR*)0xBAADF00D; } DH_HRCHECK (hr, TEXT("new OLECHAR")); } if (S_OK == hr) { pStgChild = NULL; hr = pStgRoot->OpenStorage( poszChildStgName, NULL, pTestChanceDF->GetStgMode(), snbTest, 0, &pStgChild); CheckErrorTest(STG_E_INVALIDPARAMETER, TEXT ("IStorage::OpenStorage uninitd SNB"), pStgChild); } // Attempt OpenStorage with SNB with no name in block, although it has // space for two names, set name list to NULL if(S_OK == hr && NULL != snbTest) { *snbTest = NULL; } if (S_OK == hr) { pStgChild = NULL; hr = pStgRoot->OpenStorage( poszChildStgName, NULL, pTestChanceDF->GetStgMode(), snbTest, 0, &pStgChild); CheckErrorTest(STG_E_INVALIDPARAMETER, TEXT ("IStorage::OpenStorage empty SNB"), pStgChild); } // Allocate space for long name and fill name with X's, make next SNB // element NULL, and make a call to IStorage::OpenStorage with too long a // name in SNB if(S_OK == hr && NULL != snbTest) { *snbTest = (OLECHAR *) new OLECHAR [MAX_STG_NAME_LEN*4]; if (NULL == *snbTest) { hr = E_OUTOFMEMORY; } DH_HRCHECK (hr, TEXT("new OLECHAR")); } if(S_OK == hr && NULL != snbTest) { snbTemp = snbTest; ocsSNBChar = *snbTemp; for (i=0; i<( MAX_STG_NAME_LEN*4 -1); i++) { ocsSNBChar[i] = 'X'; } ocsSNBChar[i] = '\0'; // Assign second element as NULL snbTemp++; *snbTemp = NULL; } if (S_OK == hr) { pStgChild = NULL; hr = pStgRoot->OpenStorage( poszChildStgName, NULL, pTestChanceDF->GetStgMode(), snbTest, 0, &pStgChild); CheckErrorTest(STG_E_INVALIDPARAMETER, TEXT ("IStorage::OpenStorage too long SNB"), pStgChild); } // Close the root docfile if (NULL != pVirtualDFRoot) { hr2 = pVirtualDFRoot->Close(); DH_HRCHECK (hr2, TEXT("VirtualCtrNode::Close")); hr = FirstError (hr, hr2); } // if something did no pass, mark test (hr) as E_FAIL if (FALSE == fPass) { hr = FirstError (hr, E_FAIL); } // if everything goes well, log test as passed else failed. if ((S_OK == hr) && (TRUE == fPass)) { DH_LOG((LOG_PASS, TEXT("Test variation APITEST_103 passed.")) ); } else { DH_LOG((LOG_FAIL, TEXT("Test variation APITEST_103 failed; hr=%#lx; fPass=%d"), hr, fPass)); } // Cleanup CleanupTestDocfile (&pVirtualDFRoot, &pTestVirtualDF, &pTestChanceDF, S_OK == hr); // Delete temp strings if(NULL != ptszChildStgName) { delete ptszChildStgName; ptszChildStgName = NULL; } if(NULL != poszChildStgName) { delete poszChildStgName; poszChildStgName = NULL; } // Free SNB if(NULL != snbTest) { if(NULL != *snbTest) { delete [] *snbTest; *snbTest = NULL; } delete [] snbTest; snbTest = NULL; } // Stop logging the test DH_TRACE((DH_LVL_TRACE1, TEXT("Test variation APITEST_103 finished")) ); DH_TRACE((DH_LVL_TRACE1, TEXT("--------------------------------------------")) ); return hr; } //---------------------------------------------------------------------------- // // Test: APITEST_104 // // Synopsis: Attempts various illegit operations on the IStream interface, // verifies proper return codes. // // Arguments:[argc] // [argv] // // Returns: HRESULT // // History: 18-June-1996 NarindK Created. // // Notes: This test runs in direct, transacted, and transacted deny write // modes // // New Test Notes: // 1. Old File: IASTREAM.CXX // 2. Old name of test : IllegitAPIStream test // New Name of test : APITEST_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:APITEST-104 // /dfRootMode:dirReadWriteShEx // b. stgbase /seed:2 /dfdepth:0-0 /dfstg:0-0 /dfstm:0-0 /t:APITEST-104 // /dfRootMode:xactReadWriteShEx // c. stgbase /seed:2 /dfdepth:0-0 /dfstg:0-0 /dfstm:0-0 /t:APITEST-104 // /dfRootMode:xactReadWriteShDenyW // // BUGNOTE: Conversion: APITEST_104 //----------------------------------------------------------------------------- HRESULT APITEST_104(int argc, char *argv[]) { HRESULT hr = S_OK; HRESULT hr2 = S_OK; ChanceDF *pTestChanceDF = NULL; VirtualDF *pTestVirtualDF = NULL; VirtualCtrNode *pVirtualDFRoot = NULL; LPTSTR ptszChildStmName = NULL; LPOLESTR poszChildStmName = NULL; LPSTORAGE pStgRoot = NULL; LPSTORAGE pStgChild = NULL; LPSTREAM pStmChild = NULL; LPSTREAM pStmChild2 = NULL; ULONG ulRef = 0; DG_STRING *pdgu = NULL; DG_INTEGER *pdgi = NULL; ULONG cRandom = 0; ULONG cMin = 1; ULONG cMax = 999; BOOL fPass = TRUE; DH_FUNCENTRY(NULL, DH_LVL_DFLIB, _TEXT("APITEST_104")); DH_TRACE((DH_LVL_TRACE1, TEXT("--------------------------------------------")) ); DH_TRACE((DH_LVL_TRACE1, TEXT("Test variation APITEST_104 started.")) ); DH_TRACE((DH_LVL_TRACE1, TEXT("Attempt illegitimate operations on IStream interface. "))); // 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 APITEST_104, Access mode: %lx"), pTestChanceDF->GetRootMode())); } // Get IStorage pointer if (S_OK == hr) { pStgRoot = pVirtualDFRoot->GetIStoragePointer(); DH_ASSERT (NULL != pStgRoot); if (NULL == pStgRoot) { hr = E_FAIL; } } // Get DG_STRING pointer if (S_OK == hr) { pdgu = pTestVirtualDF->GetDataGenUnicode(); DH_ASSERT (NULL != pdgu); if (NULL == pdgu) { hr = E_FAIL; } } // Generate random name for stream if(S_OK == hr) { hr = GenerateRandomName(pdgu,MINLENGTH,MAXLENGTH, &ptszChildStmName); DH_HRCHECK(hr, TEXT("GenerateRandomName")) ; } if(S_OK == hr) { // Convert name to OLECHAR hr = TStringToOleString(ptszChildStmName, &poszChildStmName); DH_HRCHECK(hr, TEXT("TStringToOleString")) ; } // Attempt CreateStream with grfmode=-1 if (S_OK == hr) { hr = pStgRoot->CreateStream( poszChildStmName, (DWORD) -1, 0, 0, &pStmChild); CheckErrorTest(STG_E_INVALIDFLAG, TEXT ("IStorage::CreateStream inv grfMode"), pStmChild); } // Get DG_INTEGER pointer if (S_OK == hr) { pdgi = pTestVirtualDF->GetDataGenInteger(); DH_ASSERT (NULL != pdgi); if (NULL == pdgi) { hr = E_FAIL; } } if (S_OK == hr) { hr = pdgi->Generate(&cRandom, cMin, cMax); DH_HRCHECK(hr, TEXT("dgi::Generate")) ; } // Call CreateStorage with random data in dwReserved1 if (S_OK == hr) { hr = pStgRoot->CreateStream( poszChildStmName, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, cRandom, 0, &pStmChild); CheckErrorTest(STG_E_INVALIDPARAMETER, TEXT ("IStorage::CreateStream inv dwReserved1"), pStmChild); } // Call CreateStream with random data in dwReserved2 if (S_OK == hr) { hr = pStgRoot->CreateStream( poszChildStmName, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, cRandom, &pStmChild); CheckErrorTest(STG_E_INVALIDPARAMETER, TEXT ("IStorage::CreateStream inv dwReserved2"), pStmChild); } // Call CreateStorage with NULL 5th ppstm parameter if (S_OK == hr) { hr = pStgRoot->CreateStream( poszChildStmName, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, NULL); CheckErrorTest2(STG_E_INVALIDPOINTER, TEXT ("IStorage::CreateStream NULL ppstm")); } // Create a storage with poszChildStmName and later on try to instantiate // child stream with that same name poszChildStmName if (S_OK == hr) { hr = pStgRoot->CreateStorage( poszChildStmName, STGM_READWRITE | STGM_SHARE_EXCLUSIVE | STGM_CREATE, 0, 0, &pStgChild); DH_HRCHECK (hr, TEXT ("IStorage::CreateStream")); DH_ASSERT (NULL != pStgChild); } // BUGBUG: Use Random commit modes... if (S_OK == hr) { hr = pVirtualDFRoot->Commit(STGC_DEFAULT); DH_HRCHECK (hr, TEXT ("VirtualCtrNode::Commit")); } // Close storage... if (NULL != pStgChild) { ulRef = pStgChild->Release(); DH_ASSERT (0 == ulRef); pStgChild = NULL; } // Now try opening storage with name with which above stream was created // i.e. poszChildStmName if (S_OK == hr) { pStmChild = NULL; hr = pStgRoot->OpenStream( poszChildStmName, NULL, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &pStmChild); CheckErrorTest(STG_E_FILENOTFOUND, TEXT ("IStorage::CreateStream inv name"), pStmChild); } //Destroy the storage element of this root storage having name poszChildStm //Name if(S_OK == hr) { hr = pStgRoot->DestroyElement(poszChildStmName); DH_HRCHECK(hr, TEXT("IStorage::DestroyElement")) ; } // Create a valid stream with name poszChildStmName if (S_OK == hr) { pStmChild = NULL; hr = pStgRoot->CreateStream( poszChildStmName, STGM_READWRITE | STGM_SHARE_EXCLUSIVE | STGM_FAILIFTHERE, 0, 0, &pStmChild); DH_HRCHECK (hr, TEXT("IStorage::CreateStream")); } // BUGBUG: Use Random commit modes... if (S_OK == hr) { hr = pVirtualDFRoot->Commit(STGC_DEFAULT); DH_HRCHECK (hr, TEXT("VirtualCtrNode::Commit")); } // Attempt second instance of IStream to be instantiated. if (S_OK == hr) { pStmChild2 = NULL; hr = pStgRoot->OpenStream( poszChildStmName, NULL, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &pStmChild2); CheckErrorTest(STG_E_ACCESSDENIED, TEXT ("IStorage::OpenStream 2nd time"), pStmChild2); } // Release the stream if(NULL != pStmChild) { ulRef = pStmChild->Release(); DH_ASSERT (0 == ulRef); pStmChild = NULL; } // Now attempt opening the stream with grfMode = -1 if (S_OK == hr) { pStmChild = NULL; hr = pStgRoot->OpenStream( poszChildStmName, NULL, (DWORD) -1, 0, &pStmChild); CheckErrorTest(STG_E_INVALIDFLAG, TEXT ("IStorage::OpenStream inv grfMode"), pStmChild); } // Now attempt opening the stream with name as "" if (S_OK == hr) { pStmChild = NULL; hr = pStgRoot->OpenStream( (OLECHAR *) " ", NULL, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &pStmChild); CheckErrorTest(STG_E_FILENOTFOUND, TEXT ("IStorage::OpenStream inv name"), pStmChild); } // Now attempt opening the stream with name as NULL #ifdef _MAC DH_TRACE((DH_LVL_TRACE1, TEXT("OpenStream with NULL name skipped.")) ); #else if (S_OK == hr) { pStmChild = NULL; hr = pStgRoot->OpenStream( NULL, NULL, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &pStmChild); CheckErrorTest(STG_E_INVALIDNAME, TEXT ("IStorage::OpenStream NULL name"), pStmChild); } #endif // _MAC // Now attempt opening the stream with random data in pReserved1 . For test // we just put pStgRoot for pReserved1 variable. if (S_OK == hr) { pStmChild = NULL; hr = pStgRoot->OpenStream( poszChildStmName, pStgRoot, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &pStmChild); CheckErrorTest(STG_E_INVALIDPARAMETER, TEXT ("IStorage::OpenStream inv pReserved1"), pStmChild); } // Now attempt opening the stream with random data in dwReserved2 if (S_OK == hr) { pStmChild = NULL; hr = pStgRoot->OpenStream( poszChildStmName, NULL, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, cRandom, &pStmChild); CheckErrorTest(STG_E_INVALIDPARAMETER, TEXT ("IStorage::OpenStream inv dwReserved2"), pStmChild); } // Now attempt opening the stream with NULL ppstm (5th parameter) if (S_OK == hr) { hr = pStgRoot->OpenStream( poszChildStmName, NULL, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, NULL); CheckErrorTest2(STG_E_INVALIDPOINTER, TEXT ("IStorage::OpenStream NULL ppstm")); } // Now attempt opening the stream normally if (S_OK == hr) { pStmChild = NULL; hr = pStgRoot->OpenStream( poszChildStmName, NULL, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &pStmChild); DH_HRCHECK (hr, TEXT("IStorage::OpenStream")); // Release the stream if(S_OK == hr) { ulRef = pStmChild->Release(); DH_ASSERT (0 == ulRef); } } // Release the root docfile if (NULL != pVirtualDFRoot) { hr2 = pVirtualDFRoot->Close(); DH_HRCHECK (hr2, TEXT("VirtualCtrNode::Close")); hr = FirstError (hr, hr2); } // if something did not pass, mark test (hr) as E_FAIL if (FALSE == fPass) { hr = FirstError (hr, E_FAIL); } // if everything goes well, log test as passed else failed. if ((S_OK == hr) && (TRUE == fPass)) { DH_LOG((LOG_PASS, TEXT("Test variation APITEST_104 passed.")) ); } else { DH_LOG((LOG_FAIL, TEXT("Test variation APITEST_104 failed; hr=%#lx; fPass=%d"), hr, fPass)); } // Cleanup CleanupTestDocfile (&pVirtualDFRoot, &pTestVirtualDF, &pTestChanceDF, S_OK == hr); // Delete temp string if(NULL != ptszChildStmName) { delete []ptszChildStmName; ptszChildStmName = NULL; } if(NULL != poszChildStmName) { delete []poszChildStmName; poszChildStmName = NULL; } // Stop logging the test DH_TRACE((DH_LVL_TRACE1, TEXT("Test variation APITEST_104 finished")) ); DH_TRACE((DH_LVL_TRACE1, TEXT("--------------------------------------------")) ); return hr; } // for non _OLE_NSS_, funcs are stubbed out below #ifdef _OLE_NSS_ //---------------------------------------------------------------------------- // // Test: APITEST_200 // // Synopsis: This test attempts various operations on StgCreateStorageEx, // StgOpenStorageEx API's // // Arguments:[argc] // [argv] // // Returns: HRESULT // // Notes: This test runs in direct, transacted, and transacted deny write // modes // // History: 18-June-1996 NarindK Created. // // New Test Notes: // 1. Old File: IAPISTG.CXX // 2. Old name of test : IllegitAPIStg test // New Name of test : APITEST_200 // 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:APITEST-200 // /dfRootMode:dirReadWriteShEx /dfname:APITEST.200 /labmode // b. stgbase /seed:2 /dfdepth:0-0 /dfstg:0-0 /dfstm:0-0 /t:APITEST-200 // /dfRootMode:xactReadWriteShEx /dfname:APITEST.200 /labmode // c. stgbase /seed:2 /dfdepth:0-0 /dfstg:0-0 /dfstm:0-0 /t:APITEST-200 // /dfRootMode:xactReadWriteShDenyW /dfname:APITEST.200 /labmode // // BUGNOTE: Conversion: APITEST-200 NO // //----------------------------------------------------------------------------- HRESULT APITEST_200(int argc, char *argv[]) { HRESULT hr = S_OK; HRESULT hr2 = S_OK; ChanceDF *pTestChanceDF = NULL; VirtualDF *pTestVirtualDF = NULL; VirtualCtrNode *pVirtualDFRoot = NULL; LPTSTR pRootDocFileName = NULL; DWORD dwRootMode = NULL; LPSTORAGE pIStorage = NULL; LPSTORAGE pIStorageOpen = NULL; LPOLESTR pOleStrTemp = NULL; TCHAR tszTestName[10] = TEXT("NonExist"); LPOLESTR pOleStrTest = NULL; SNB snbTest = NULL; SNB snbTemp = NULL; ULONG ulRef = 0; OLECHAR *ocsSNBChar = NULL; ULONG i = 0; BOOL fPass = TRUE; CLSID clsidBogus = {0xBAADF00D, 0xBAAD, 0xF00D, {0xA0, 0xA0, 0xA0, 0xA0, 0xA0, 0xA0, 0xA0, 0xA0}}; DWORD stgfmt = StorageIsFlat()?STGFMT_FILE:0; // Not for 2phase. Bail. if (DoingDistrib ()) { return S_OK; } DH_FUNCENTRY(NULL, DH_LVL_DFLIB, _TEXT("APITEST_200")); DH_TRACE((DH_LVL_ALWAYS, TEXT("Test variation APITEST_200 started.")) ); DH_TRACE((DH_LVL_ALWAYS, TEXT("Attempt illegitimate ops on StgCreateStorageEx & ") TEXT("StgOpenStorageEx."))); // Create the new ChanceDocFile tree that would consist of chance nodes. if (S_OK == hr) { pTestChanceDF = new ChanceDF(); if(NULL == pTestChanceDF) { hr = E_OUTOFMEMORY; } DH_HRCHECK (hr, TEXT("new ChanceDF")); } if (S_OK == hr) { hr = pTestChanceDF->CreateFromParams(argc, argv); DH_HRCHECK(hr, TEXT("ChanceDF::CreateFromParams")) ; } if (S_OK == hr) { dwRootMode = pTestChanceDF->GetRootMode(); DH_TRACE(( DH_LVL_TRACE1, TEXT("Run Mode for APITEST_200, Access mode: %lx"), pTestChanceDF->GetRootMode())); } // Get RootDocFile name if (S_OK == hr) { if(NULL != pTestChanceDF->GetDocFileName()) { pRootDocFileName = new TCHAR[_tcslen(pTestChanceDF->GetDocFileName())+1]; if (pRootDocFileName == NULL) { hr = E_OUTOFMEMORY; } else { _tcscpy(pRootDocFileName, pTestChanceDF->GetDocFileName()); } DH_HRCHECK (hr, TEXT("new TCHAR")); } DH_HRCHECK(hr, TEXT("ChanceDF::GetDocFileName()")) ; } if(S_OK == hr) { // Convert RootDocFile name to OLECHAR hr = TStringToOleString(pRootDocFileName, &pOleStrTemp); DH_HRCHECK(hr, TEXT("TStringToOleString")) ; } // Try calling StgCreateStorageEx with mode STGM_CREATE|STGM_CONVERT DH_TRACE ((DH_LVL_TRACE4, TEXT("Try calling StgCreateStorageEx with mode STGM_CREATE|STGM_CONVERT"))); if (S_OK == hr) { pIStorage = NULL; hr = StgCreateStorageEx( pOleStrTemp, STGM_CREATE | STGM_CONVERT, stgfmt, 0, NULL, NULL, IID_IStorage, (void**)&pIStorage); CheckErrorTest(STG_E_INVALIDFLAG, TEXT ("StgCreateStorageEx inv grfMode"), pIStorage); } // Try calling StgCreateStorageEx with grfMode equal to -1 DH_TRACE ((DH_LVL_TRACE4, TEXT ("Try calling StgCreateStorageEx with grfMode equal to -1"))); if (S_OK == hr) { pIStorage = NULL; hr = StgCreateStorageEx( pOleStrTemp, (DWORD) -1, stgfmt, 0, NULL, NULL, IID_IStorage, (void**)&pIStorage); CheckErrorTest(STG_E_INVALIDFLAG, TEXT ("StgCreateStorageEx inv grfMode"), pIStorage); } // Try calling StgCreateStorageEx with stgfmt equal to -1 DH_TRACE ((DH_LVL_TRACE4, TEXT ("Try calling StgCreateStorageEx with stgfmt equal to -1"))); if (S_OK == hr) { pIStorage = NULL; hr = StgCreateStorageEx( pOleStrTemp, dwRootMode, (DWORD)-1, 0, NULL, NULL, IID_IStorage, (void**)&pIStorage); CheckErrorTest(STG_E_INVALIDPARAMETER, TEXT ("StgCreateStorageEx inv stgfmt"), pIStorage); } // Try calling StgCreateStorageEx with gfrAttr equal to -1 DH_TRACE ((DH_LVL_TRACE4, TEXT ("Try calling StgCreateStorageEx with gfrAttr equal to -1"))); if (S_OK == hr) { pIStorage = NULL; hr = StgCreateStorageEx( pOleStrTemp, dwRootMode, stgfmt, (DWORD)-1, NULL, NULL, IID_IStorage, (void**)&pIStorage); CheckErrorTest(STG_E_INVALIDFLAG, TEXT ("StgCreateStorageEx inv grfAttr"), pIStorage); } // Try calling StgCreateStorageEx with nonzero reserved1 DH_TRACE ((DH_LVL_TRACE4, TEXT ("Try calling StgCreateStorageEx with nonzero reserved1"))); // With 1795 changes to "dwReserved" Parameter to -> version number, // sector size (allowed is 512, 4096 only) and reserved parameter as // typedef struct tagSTGOPTIONS // { // USHORT usVersion; // Version 1 // USHORT reserved; // must be 0 for padding // ULONG ulSectorSize; // docfile header sector size (512) // } STGOPTIONS; STGOPTIONS stgOptions; stgOptions.usVersion = 1; stgOptions.reserved = 999; stgOptions.ulSectorSize = 512; if (S_OK == hr) { pIStorage = NULL; hr = StgCreateStorageEx( pOleStrTemp, dwRootMode, stgfmt, 0, &stgOptions, NULL, IID_IStorage, (void**)&pIStorage); CheckErrorTest(STG_E_INVALIDPARAMETER, TEXT ("StgCreateStorageEx inv STGOPTIONS dwreserved"), pIStorage); } if (S_OK == hr) { stgOptions.reserved = 0; stgOptions.ulSectorSize = 999; // Allowed is 512 and 4096 only pIStorage = NULL; hr = StgCreateStorageEx( pOleStrTemp, dwRootMode, stgfmt, 0, &stgOptions, NULL, IID_IStorage, (void**)&pIStorage); CheckErrorTest(STG_E_INVALIDPARAMETER, TEXT ("StgCreateStorageEx inv STGOPTIONS ulSectorSize"), pIStorage); } // Try calling StgCreateStorageEx with nonzero reserved2 DH_TRACE ((DH_LVL_TRACE4, TEXT ("Try calling StgCreateStorageEx with nonzero reserved2"))); if (S_OK == hr) { stgOptions.ulSectorSize = 512; // Allowed is 512 and 4096 only pIStorage = NULL; hr = StgCreateStorageEx( pOleStrTemp, dwRootMode, stgfmt, 0, &stgOptions, (void*)999, IID_IStorage, (void**)&pIStorage); CheckErrorTest(STG_E_INVALIDPARAMETER, TEXT ("StgCreateStorageEx inv reserved2"), pIStorage); } // Try calling StgCreateStorageEx with invalid IID DH_TRACE ((DH_LVL_TRACE4, TEXT ("Try calling StgCreateStorageEx with invalid IID"))); if (S_OK == hr) { pIStorage = NULL; hr = StgCreateStorageEx( pOleStrTemp, dwRootMode, stgfmt, 0, &stgOptions, NULL, clsidBogus, (void**)&pIStorage); CheckErrorTest(E_NOINTERFACE, TEXT ("StgCreateStorageEx inv riid"), pIStorage); } // Try calling StgCreateStorageEx with NULL ppstgOpen parameter DH_TRACE ((DH_LVL_TRACE4, TEXT ("Try calling StgCreateStorageEx with NULL ppstgOpen parameter"))); if (S_OK == hr) { hr = StgCreateStorageEx( pOleStrTemp, dwRootMode, stgfmt, 0, &stgOptions, NULL, IID_IStorage, NULL); CheckErrorTest2(STG_E_INVALIDPOINTER, TEXT ("StgCreateStorageEx NULL ppstg")); } // Now create a valid DocFile // Create the VirtualDocFile tree from the ChanceDocFile tree created in // the previous step. The VirtualDocFile tree consists of VirtualCtrNodes // and VirtualStmNodes. if (S_OK == hr) { pTestVirtualDF = new VirtualDF(STGTYPE_NSSFILE); if(NULL == pTestVirtualDF) { hr = E_OUTOFMEMORY; } DH_HRCHECK (hr, TEXT("new VirtualDF")); } if (S_OK == hr) { hr = pTestVirtualDF->GenerateVirtualDF(pTestChanceDF, &pVirtualDFRoot); DH_HRCHECK(hr, TEXT("VirtualDF::GenerateVirtualDF")) ; } // Try commiting with grfCommitFlags = -1 DH_TRACE ((DH_LVL_TRACE4, TEXT ("Try commiting with grfCommitFlags = -1"))); if (S_OK == hr) { hr = pVirtualDFRoot->Commit((DWORD) -1); CheckErrorTest2(STG_E_INVALIDFLAG, TEXT("VirtualCtrNode::Commit inv flags")); } // Now do a valid commit if (S_OK == hr) { hr = pVirtualDFRoot->Commit(STGC_DEFAULT); DH_HRCHECK (hr, TEXT("VirtualCtrNode::Commit")); } // Close the root docfile if (NULL != pVirtualDFRoot) { hr2 = pVirtualDFRoot->Close(); DH_HRCHECK (hr2, TEXT("VirtualCtrNode::Close")); hr = FirstError (hr, hr2); } // Instantiate DocFile with name as "" // NOTE: The old test checked the erro value to be STG_E_FILENOTFOUND in // this case. On NT, we get STG_E_PATHNOTFOUND and on Chicago, we get // STG_E_ACCESSDENIED, so let us check against S_OK itself. DH_TRACE ((DH_LVL_TRACE4, TEXT ("Instantiate DocFile with name as ' '"))); if (S_OK == hr) { pIStorageOpen = NULL; hr = StgOpenStorageEx( (OLECHAR *) " ", dwRootMode, stgfmt, 0, NULL, NULL, IID_IStorage, (void**)&pIStorageOpen); //BUGBUG: what exactly are we expecting failure code? if (RunningOnNT()) { // HACKHACK: dont know exactly what the OS will return here..... if (STG_E_PATHNOTFOUND == hr || STG_E_FILENOTFOUND == hr || STG_E_INVALIDNAME == hr) { DH_TRACE ((DH_LVL_TRACE2, TEXT("Actual return value:hr=%#x"), hr)); hr = STG_E_PATHNOTFOUND; } CheckErrorTest(STG_E_PATHNOTFOUND, TEXT ("StgOpenStorageEx inv name"), pIStorageOpen); } else { CheckErrorTest(STG_E_ACCESSDENIED, TEXT ("StgOpenStorageEx inv name"), pIStorageOpen); } } // Instantiate DocFile with nonexisting file name if(S_OK == hr) { // Convert tszTestName to OLECHAR hr = TStringToOleString(tszTestName, &pOleStrTest); DH_HRCHECK(hr, TEXT("TStringToOleString")) ; } DH_TRACE ((DH_LVL_TRACE4, TEXT ("Instantiate DocFile with nonexisting file name"))); if (S_OK == hr) { pIStorageOpen = NULL; hr = StgOpenStorageEx( pOleStrTest, dwRootMode, stgfmt, 0, NULL, NULL, IID_IStorage, (void**)&pIStorageOpen); CheckErrorTest(STG_E_FILENOTFOUND, TEXT ("StgOpenStorageEx bad name"), pIStorageOpen); } // Instantiate DocFile with NULL file name DH_TRACE ((DH_LVL_TRACE4, TEXT ("Instantiate DocFile with NULL file name"))); if (S_OK == hr) { pIStorageOpen = NULL; hr = StgOpenStorageEx( NULL, dwRootMode, stgfmt, 0, NULL, NULL, IID_IStorage, (void**)&pIStorageOpen); CheckErrorTest(STG_E_INVALIDNAME, TEXT ("StgOpenStorageEx NULL name"), pIStorageOpen); } // Instantiate DocFile with grfMode=-1 DH_TRACE ((DH_LVL_TRACE4, TEXT ("Instantiate DocFile with grfMode=-1"))); if (S_OK == hr) { pIStorageOpen = NULL; hr = StgOpenStorageEx( pOleStrTemp, (DWORD) -1, stgfmt, 0, NULL, NULL, IID_IStorage, (void**)&pIStorageOpen); CheckErrorTest(STG_E_INVALIDFLAG, TEXT ("StgOpenStorageEx inv grfMode"), pIStorageOpen); } // Instantiate DocFile with grfMode as dwRootMode|STGM_DELETEONRELEASE // NOTE: The doc says, erro code in this case to be STG_E_INVALIDFUNCTION, // but error STG_E_INVALIDFLAG returned. DH_TRACE ((DH_LVL_TRACE4, TEXT ("Instantiate DocFile with grfMode as dwRootMode|STGM_DELETEONRELEASE"))); if (S_OK == hr) { pIStorageOpen = NULL; hr = StgOpenStorageEx( pOleStrTemp, dwRootMode | STGM_DELETEONRELEASE, stgfmt, 0, NULL, NULL, IID_IStorage, (void**)&pIStorageOpen); CheckErrorTest(STG_E_INVALIDFUNCTION, TEXT ("StgOpenStorageEx inv grfMode"), pIStorageOpen); } // Instantiate DocFile with stgfmt=-1 DH_TRACE ((DH_LVL_TRACE4, TEXT ("Instantiate DocFile with stgfmt=-1"))); if (S_OK == hr) { pIStorageOpen = NULL; hr = StgOpenStorageEx( pOleStrTemp, dwRootMode, (DWORD)-1, 0, NULL, NULL, IID_IStorage, (void**)&pIStorageOpen); CheckErrorTest(STG_E_INVALIDPARAMETER, TEXT ("StgOpenStorageEx inv stgfmt"), pIStorageOpen); } // Instantiate docfile with grfAttr == -1 DH_TRACE ((DH_LVL_TRACE4, TEXT ("Instantiate docfile with grfAttr == -1"))); if (S_OK == hr) { pIStorageOpen = NULL; hr = StgOpenStorageEx( pOleStrTemp, dwRootMode, stgfmt, (DWORD)-1, NULL, NULL, IID_IStorage, (void**)&pIStorageOpen); CheckErrorTest(STG_E_INVALIDFLAG, TEXT ("StgOpenStorageEx inv grfAttr"), pIStorageOpen); } // Instantiate docfile with pTransaction == -1 DH_TRACE ((DH_LVL_TRACE4, TEXT ("Instantiate docfile with reserved1 (pTransaction) == -1"))); if (S_OK == hr) { stgOptions.reserved = (USHORT)(-1); pIStorageOpen = NULL; hr = StgOpenStorageEx( pOleStrTemp, dwRootMode, stgfmt, 0, &stgOptions, NULL, IID_IStorage, (void**)&pIStorageOpen); CheckErrorTest(STG_E_INVALIDPARAMETER, TEXT ("StgOpenStorageEx inv reserved1"), pIStorageOpen); } // Instantiate docfile with pSecurity == -1 DH_TRACE ((DH_LVL_TRACE4, TEXT ("Instantiate docfile with reserved2 (pSecurity) == -1"))); if (S_OK == hr) { stgOptions.reserved = 0; pIStorageOpen = NULL; hr = StgOpenStorageEx( pOleStrTemp, dwRootMode, stgfmt, 0, NULL, (void*)-1, IID_IStorage, (void**)&pIStorageOpen); CheckErrorTest(STG_E_INVALIDPARAMETER, TEXT ("StgOpenStorageEx inv reserved2"), pIStorageOpen); } // Instantiate docfile with bogus refiid DH_TRACE ((DH_LVL_TRACE4, TEXT ("Instantiate docfile with bogus refiid"))); if (S_OK == hr) { pIStorageOpen = NULL; hr = StgOpenStorageEx( pOleStrTemp, dwRootMode, stgfmt, 0, NULL, NULL, clsidBogus, (void**)&pIStorageOpen); // ----------- flatfile change --------------- if(!StorageIsFlat()) { // ----------- flatfile change --------------- CheckErrorTest(E_NOINTERFACE, TEXT ("StgOpenStorageEx inv riid"), pIStorageOpen); } else { CheckErrorTest(STG_E_INVALIDFUNCTION, TEXT ("StgOpenStorageEx of a docfile with inv riid"), pIStorageOpen); } // ----------- flatfile change --------------- } // Instantiate DocFile with NULL ppstgOpen parameter (8th) DH_TRACE ((DH_LVL_TRACE4, TEXT ("Instantiate DocFile with NULL ppstgOpen parameter"))); if (S_OK == hr) { hr = StgOpenStorageEx( pOleStrTest, dwRootMode, stgfmt, 0, NULL, NULL, IID_IStorage, NULL); CheckErrorTest2(STG_E_INVALIDPOINTER, TEXT ("StgOpenStorageEx NULL ppstg")); } // Instatiate correctly. DH_TRACE ((DH_LVL_TRACE4, TEXT ("Instantiate DocFile"))); if (S_OK == hr) { pIStorageOpen = NULL; hr = StgOpenStorageEx( pOleStrTemp, dwRootMode, stgfmt, 0, NULL, NULL, IID_IStorage, (void**)&pIStorageOpen); // ----------- flatfile change --------------- if(StorageIsFlat()) { CheckErrorTest(STG_E_INVALIDFUNCTION, TEXT ("StgOpenStorageEx -opening docfile as flatfile"), pIStorageOpen); } // ----------- flatfile change --------------- DH_HRCHECK (hr, TEXT("StgOpenStorageEx")); // close it. if (NULL != pIStorageOpen) { ulRef = pIStorageOpen->Release(); DH_ASSERT (0 == ulRef); pIStorageOpen = NULL; } } // if something did not pass, mark test (hr) as E_FAIL if (FALSE == fPass) { hr = FirstError (hr, E_FAIL); } // if everything goes well, log test as passed else failed. if ((S_OK == hr) && (TRUE == fPass)) { DH_LOG((LOG_PASS, TEXT("Test variation APITEST_200 passed.")) ); } else { DH_LOG((LOG_FAIL, TEXT("Test variation APITEST_200 failed; hr=%#lx; fPass=%d."), hr, fPass)); } // Cleanup // Delete Chance docfile tree if(NULL != pTestChanceDF) { hr2 = pTestChanceDF->DeleteChanceDocFileTree( pTestChanceDF->GetChanceDFRoot()); DH_HRCHECK(hr2, TEXT("ChanceDF::DeleteChanceFileDocTree")) ; delete pTestChanceDF; pTestChanceDF = NULL; } // Delete Virtual docfile tree if(NULL != pTestVirtualDF) { hr2 = pTestVirtualDF->DeleteVirtualDocFileTree(pVirtualDFRoot); DH_HRCHECK(hr2, TEXT("VirtualDF::DeleteVirtualFileDocTree")) ; delete pTestVirtualDF; pTestVirtualDF = NULL; } // Delete the docfile on disk if((S_OK == hr) && (NULL != pRootDocFileName)) { if(FALSE == DeleteFile(pRootDocFileName)) { hr2 = HRESULT_FROM_WIN32(GetLastError()) ; DH_HRCHECK(hr2, TEXT("DeleteFile")) ; } } // Delete temp strings if(NULL != pOleStrTemp) { delete []pOleStrTemp; pOleStrTemp = NULL; } if(NULL != pOleStrTest) { delete []pOleStrTest; pOleStrTest = NULL; } if(NULL != pRootDocFileName) { delete []pRootDocFileName; pRootDocFileName = NULL; } // Stop logging the test DH_TRACE((DH_LVL_ALWAYS, TEXT("Test variation APITEST_200 finished")) ); return hr; } //---------------------------------------------------------------------------- // // Test: APITEST_201 // // Synopsis: The test attempts various illegitimate operations using names // greater than MAX_STG_NAME_LEN, it then attempts to create // several random named root docfiles. If the create is succesful, // then a random named child IStorage or IStream is also created. // Whether or not the root create was successful, we attempt to // open the root docfile (this is expected to fail, the point is // to check for asserts/GP faults rather than return codes). If // the instantiation is successful, the test also tries to // instantiate the child object. All objects are then released. // // Arguments:[argc] // [argv] // // Returns: HRESULT // // History: 18-June-1996 NarindK Created. // // Notes: This test runs in direct, transacted, and transacted deny write // modes // // New Test Notes: // 1. Old File: IANAMES.CXX // 2. Old name of test : IllegitAPINames test // New Name of test : APITEST_201 // 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:APITEST-201 // /dfRootMode:dirReadWriteShEx /dfStgMode:dirReadWriteShEx // b. stgbase /seed:2 /dfdepth:0-0 /dfstg:0-0 /dfstm:0-0 /t:APITEST-201 // /dfRootMode:xactReadWriteShEx /dfStgMode:xactReadWriteShEx // c. stgbase /seed:2 /dfdepth:0-0 /dfstg:0-0 /dfstm:0-0 /t:APITEST-201 // /dfRootMode:xactReadWriteShDenyW /dfStgMode:xactReadWriteShEx // // BUGNOTE: Conversion: APITEST-201 NO // //----------------------------------------------------------------------------- HRESULT APITEST_201(int argc, char *argv[]) { HRESULT hr = S_OK; HRESULT hr2 = S_OK; ChanceDF *pTestChanceDF = NULL; VirtualDF *pTestVirtualDF = NULL; VirtualCtrNode *pVirtualDFRoot = NULL; LPTSTR pFileName = NULL; LPOLESTR poszBadName = NULL; LPOLESTR poszBadNameStg = NULL; LPTSTR ptszBadNameStg = NULL; DWORD dwRootMode = 0; ULONG i = 0; LPSTORAGE pIStorage = NULL; LPSTORAGE pIStorageChild = NULL; LPSTREAM pIStreamChild = NULL; DG_STRING *pdgu = NULL; DG_INTEGER *pdgi = NULL; LPTSTR pRootNewChildStgName = NULL; VirtualCtrNode *pvcnRootNewChildStorage= NULL; BOOL fPass = TRUE; DWORD stgfmt = StorageIsFlat()?STGFMT_FILE:0; // Not for 2phase. Bail. if (DoingDistrib ()) { return S_OK; } DH_FUNCENTRY(NULL, DH_LVL_DFLIB, _TEXT("APITEST_201")); DH_TRACE((DH_LVL_ALWAYS, TEXT("Test variation APITEST_201 started.")) ); DH_TRACE((DH_LVL_ALWAYS, TEXT("Call StgCreateDocFile/CreateStorage/CreateStream with ") TEXT("too long names."))); // Create the new ChanceDocFile tree that would consist of chance nodes. if (S_OK == hr) { pTestChanceDF = new ChanceDF(); if(NULL == pTestChanceDF) { hr = E_OUTOFMEMORY; } DH_HRCHECK (hr, TEXT("new ChanceDF")); } if (S_OK == hr) { hr = pTestChanceDF->CreateFromParams(argc, argv); DH_HRCHECK(hr, TEXT("ChanceDF::CreateFromParams")) ; } if (S_OK == hr) { dwRootMode = pTestChanceDF->GetRootMode(); DH_TRACE(( DH_LVL_TRACE1, TEXT("Run Mode for APITEST_201, Access mode: %lx"), pTestChanceDF->GetRootMode())); } // Call StgCreateDocFile with too long a name for docfile. // NOTE: Old test to fail with MAX_STG_NAME_LEN*3, but not in new test, // fails with MAX_STG_NAME_LEN*4. // NOTE: Crashes in DfFromName in OLE if length is of MAX_STG_NAME_LEN*8 // CHECK!!! if(S_OK == hr) { poszBadName = (OLECHAR *) new OLECHAR [MAX_STG_NAME_LEN*4]; if (NULL == poszBadName) { hr = E_OUTOFMEMORY; } DH_HRCHECK (hr, TEXT("new OLECHAR")); } if(S_OK == hr) { for (i=0; i<( MAX_STG_NAME_LEN*4 -1); i++) { poszBadName[i] = 'X'; } poszBadName[i] ='\0'; } // Try calling StgCreateDocFile with the above long name pszBadName if (S_OK == hr) { pIStorage = NULL; hr = StgCreateStorageEx( poszBadName, dwRootMode | STGM_CREATE, stgfmt, 0, NULL, NULL, IID_IStorage, (void**)&pIStorage); // HACKHACK: dont know exactly what the OS will return here..... if (STG_E_PATHNOTFOUND == hr || STG_E_FILENOTFOUND == hr || STG_E_INVALIDNAME == hr) { DH_TRACE ((DH_LVL_TRACE2, TEXT("Actual return value:hr=%#x"), hr)); hr = STG_E_PATHNOTFOUND; } CheckErrorTest(STG_E_PATHNOTFOUND, TEXT ("StgCreateStorageEx inv name"), pIStorage); } // Now create a valid DocFile // Create the VirtualDocFile tree from the ChanceDocFile tree created in // the previous step. if (S_OK == hr) { pTestVirtualDF = new VirtualDF(STGTYPE_NSSFILE); if(NULL == pTestVirtualDF) { hr = E_OUTOFMEMORY; } DH_HRCHECK (hr, TEXT("new VirtualDF")); } if (S_OK == hr) { hr = pTestVirtualDF->GenerateVirtualDF(pTestChanceDF, &pVirtualDFRoot); DH_HRCHECK(hr, TEXT("VirtualDF::GenerateVirtualDF")) ; } // Get IStorage pointer if (S_OK == hr) { pIStorage = pVirtualDFRoot->GetIStoragePointer(); DH_ASSERT (NULL != pIStorage); if (NULL == pIStorage) { hr = E_FAIL; } } // Call CreateStorage with too long a name for docfile. if(S_OK == hr) { ptszBadNameStg = (TCHAR *) new TCHAR [MAX_STG_NAME_LEN*3]; if (NULL == ptszBadNameStg) { hr = E_OUTOFMEMORY; } DH_HRCHECK (hr, TEXT("new TCHAR")); } if(S_OK == hr) { for (i=0; i<( MAX_STG_NAME_LEN*3 -1); i++) { ptszBadNameStg[i] = 'X'; } ptszBadNameStg[i] ='\0'; } if(S_OK == hr) { // Convert Bad storage name to OLECHAR hr = TStringToOleString(ptszBadNameStg, &poszBadNameStg); DH_HRCHECK(hr, TEXT("TStringToOleString")) ; } // ----------- flatfile change --------------- if(!StorageIsFlat()) { // ----------- flatfile change --------------- // now call CreateStorage with too long a name... if (S_OK == hr) { hr = pIStorage->CreateStorage( poszBadNameStg, pTestChanceDF->GetStgMode(), 0, 0, &pIStorageChild); CheckErrorTest(STG_E_INVALIDNAME, TEXT ("IStorage::CreateStorage long name"), pIStorageChild); } // ----------- flatfile change --------------- } // ----------- flatfile change --------------- // Now call CreateStream with too long a name... if (S_OK == hr) { hr = pIStorage->CreateStream( poszBadNameStg, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &pIStreamChild); CheckErrorTest(STG_E_INVALIDNAME, TEXT ("IStorage::CreateStream long name"), pIStreamChild); } // Now add a Valid storage to root. Call AddStorage that in turns calls // CreateStorage if (S_OK == hr) { pdgu = pTestVirtualDF->GetDataGenUnicode(); DH_ASSERT (NULL != pdgu); if (NULL == pdgu) { hr = E_FAIL; } } // ----------- flatfile change --------------- if(!StorageIsFlat()) { // ----------- flatfile change --------------- 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")) ; } // Now try to rename this storage element to a bad name. if(S_OK == hr) { DH_EXPECTEDERROR (STG_E_INVALIDNAME); hr = pvcnRootNewChildStorage->Rename(ptszBadNameStg); DH_NOEXPECTEDERROR (); CheckErrorTest2(STG_E_INVALIDNAME, TEXT ("VirtualCtrNode::Rename inv name")); } // Close the Storage pvcnRootNewChildStorage if (S_OK == hr) { hr = pvcnRootNewChildStorage->Close(); DH_HRCHECK (hr, TEXT("VirtualCtrNode::Close")); } // ----------- flatfile change --------------- } // ----------- flatfile change --------------- // Close the root docfile if (NULL != pVirtualDFRoot) { hr = pVirtualDFRoot->Close(); DH_HRCHECK (hr, TEXT("VirtualCtrNode::Close")); } // Delete temp strings if(NULL != poszBadNameStg) { delete [] poszBadNameStg; poszBadNameStg = NULL; } if(NULL != poszBadName) { delete [] poszBadName; poszBadName = NULL; } if(NULL != ptszBadNameStg) { delete [] ptszBadNameStg; ptszBadNameStg = NULL; } if(NULL != pRootNewChildStgName) { delete [] pRootNewChildStgName; pRootNewChildStgName = NULL; } // In the following section of test: //make a random number of random length, random character root //docfiles. for this variation, we don't care if the operation //succeeds, looking for GP faults and asserts only. if the //StgCreateDocfile fails, we'll still attempt the open. of //course, the open in this case will be expected to fail, but //again, we won't be checking return codes... If the StgCreateDocfile //passes, we'll create a random name IStream or IStorage too. ULONG count = 0; ULONG cMinNum = 16; ULONG cMaxNum = 128; LPTSTR ptszRandomRootName = NULL; LPTSTR ptszRandomChildName = NULL; ULONG countFlag = 0; ULONG cMinFlag = 0; ULONG cMaxFlag = 100; ULONG nChildType = 0; LPSTORAGE pstgRoot = NULL; LPSTORAGE pstgChild = NULL; LPSTREAM pstmChild = NULL; LPOLESTR poszRandomRootName = NULL; LPOLESTR poszRandomChildName = NULL; ULONG ulRef = 0; if (S_OK == hr) { pdgi = pTestVirtualDF->GetDataGenInteger(); DH_ASSERT (NULL != pdgi); if (NULL == pdgi) { hr = E_FAIL; } } if(S_OK == hr) { hr = pdgi->Generate(&count, cMinNum, cMaxNum); DH_HRCHECK(hr, TEXT("pdgi::Generate")) ; } while(count--) { if(S_OK == hr) { hr=GenerateRandomName(pdgu,MINLENGTH,MAXLENGTH,&ptszRandomRootName); DH_HRCHECK(hr, TEXT("GenerateRandomName")) ; } if(S_OK == hr) { // Convert name to OLECHAR hr = TStringToOleString(ptszRandomRootName, &poszRandomRootName); DH_HRCHECK(hr, TEXT("TStringToOleString")) ; } if (S_OK == hr) { pstgRoot = NULL; hr = StgCreateStorageEx( poszRandomRootName, dwRootMode | STGM_CREATE, stgfmt, 0, NULL, NULL, IID_IStorage, (void**)&pstgRoot); DH_HRCHECK (hr, TEXT("StgCreateStorageEx")); } nChildType = NONE; if(S_OK == hr) { if(S_OK == hr) { hr=GenerateRandomName( pdgu, MINLENGTH, MAXLENGTH, &ptszRandomChildName); DH_HRCHECK(hr, TEXT("GenerateRandomName")) ; } if(S_OK == hr) { // Convert name to OLECHAR hr = TStringToOleString( ptszRandomChildName, &poszRandomChildName); DH_HRCHECK(hr, TEXT("TStringToOleString")) ; } if(S_OK == hr) { hr = pdgi->Generate(&countFlag, cMinFlag, cMaxFlag); DH_HRCHECK(hr, TEXT("pdgi::Generate")) ; } if(!StorageIsFlat() && countFlag > (cMaxFlag/2)) { hr = pstgRoot->CreateStorage( poszRandomChildName, pTestChanceDF->GetStgMode(), 0, 0, &pstgChild); DH_HRCHECK(hr, TEXT("IStorage::CreateStorage")); if(S_OK == hr) { nChildType = STORAGE; hr = pstgRoot->Commit(STGC_DEFAULT); DH_HRCHECK(hr, TEXT("IStorage::Commit")); ulRef = pstgChild->Release(); DH_ASSERT (0 == ulRef); pstgChild = NULL; } } else { hr = pstgRoot->CreateStream( poszRandomChildName, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &pstmChild); DH_HRCHECK(hr, TEXT("IStorage::CreateStream")); if(S_OK == hr) { nChildType = STREAM; hr = pstgRoot->Commit(STGC_DEFAULT); DH_HRCHECK(hr, TEXT("IStorage::Commit")); ulRef = pstmChild->Release(); DH_ASSERT (0 == ulRef); pstmChild = NULL; } } ulRef = pstgRoot->Release(); DH_ASSERT (0 == ulRef); pstgRoot = NULL; } //Try to open Root Storage whetehr the creation was successful or not hr = StgOpenStorageEx( poszRandomRootName, pTestChanceDF->GetStgMode(), stgfmt, 0, NULL, NULL, IID_IStorage, (void**)&pstgRoot); DH_HRCHECK (hr, TEXT("StgOpenStorageEx")); if(S_OK == hr) { switch(nChildType) { case STORAGE: { hr = pstgRoot->OpenStorage( poszRandomChildName, NULL, pTestChanceDF->GetStgMode(), NULL, 0, &pstgChild); DH_HRCHECK(hr, TEXT("IStorage::OpenStorage")); if(S_OK == hr) { ulRef = pstgChild->Release(); DH_ASSERT (0 == ulRef); pstgChild = NULL; } } break; case STREAM: { hr = pstgRoot->OpenStream( poszRandomChildName, NULL, STGM_READWRITE|STGM_SHARE_EXCLUSIVE, 0, &pstmChild); DH_HRCHECK(hr, TEXT("IStorage::OpenStream")); if(S_OK == hr) { ulRef = pstmChild->Release(); DH_ASSERT (0 == ulRef); pstmChild = NULL; } } break; } /* switch */ ulRef = pstgRoot->Release(); DH_ASSERT (0 == ulRef); pstgRoot = NULL; } // Delete temp strings if(NULL != ptszRandomChildName) { delete [] ptszRandomChildName; ptszRandomChildName = NULL; } if(NULL != ptszRandomRootName) { if(FALSE == DeleteFile(ptszRandomRootName)) { hr = HRESULT_FROM_WIN32(GetLastError()) ; DH_HRCHECK(hr, TEXT("DeleteFile")) ; } delete [] ptszRandomRootName; ptszRandomRootName = NULL; } if(NULL != poszRandomChildName) { delete [] poszRandomChildName; poszRandomChildName = NULL; } if(NULL != poszRandomChildName) { delete [] poszRandomChildName; poszRandomChildName = NULL; } } // if something did not pass, mark test (hr) as E_FAIL if (FALSE == fPass) { hr = FirstError (hr, E_FAIL); } // if everything goes well, log test as passed else failed. if ((S_OK == hr) && (TRUE == fPass)) { DH_LOG((LOG_PASS, TEXT("Test variation APITEST_201 passed.")) ); } else { DH_LOG((LOG_FAIL, TEXT("Test variation APITEST_201 failed; hr=%#lx; fPass=%d."), hr, fPass)); } // Cleanup // Get the name of file, will be used later to delete the file if(NULL != pTestVirtualDF) { pFileName= new TCHAR[_tcslen(pTestVirtualDF->GetDocFileName())+1]; if (pFileName != NULL) { _tcscpy(pFileName, pTestVirtualDF->GetDocFileName()); } } // Delete Chance docfile tree if(NULL != pTestChanceDF) { hr2 = pTestChanceDF->DeleteChanceDocFileTree( pTestChanceDF->GetChanceDFRoot()); DH_HRCHECK(hr2, TEXT("ChanceDF::DeleteChanceFileDocTree")) ; delete pTestChanceDF; pTestChanceDF = NULL; } // Delete Virtual docfile tree if(NULL != pTestVirtualDF) { hr2 = pTestVirtualDF->DeleteVirtualDocFileTree(pVirtualDFRoot); DH_HRCHECK(hr2, TEXT("VirtualDF::DeleteVirtualFileDocTree")) ; delete pTestVirtualDF; pTestVirtualDF = NULL; } // Delete the docfile on disk if((S_OK == hr) && (NULL != pFileName)) { if(FALSE == DeleteFile(pFileName)) { hr = HRESULT_FROM_WIN32(GetLastError()) ; DH_HRCHECK(hr, TEXT("DeleteFile")) ; } } // Delete temp strings if(NULL != pFileName) { delete []pFileName; pFileName = NULL; } // Stop logging the test DH_TRACE((DH_LVL_ALWAYS, TEXT("Test variation APITEST_201 finished")) ); return hr; } //---------------------------------------------------------------------------- // // Test: APITEST_202 // // Synopsis: Attempts various operations in obtaining enumerators, checking // for proper error return. Then gets a valid enumerator, and // attempts various illegitimate method calls on it. Verify // proper return codes. // // Arguments:[argc] // [argv] // // Returns: HRESULT // // History: 18-June-1996 NarindK Created. // // Notes: This test runs in direct, transacted, and transacted deny write // modes // // New Test Notes: // 1. Old File: IAENUM.CXX // 2. Old name of test : IllegitAPIEnum test // New Name of test : APITEST_202 // 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:APITEST-202 // /dfRootMode:dirReadWriteShEx /dfStgMode:dirReadWriteShEx /labmode // b. stgbase /seed:2 /dfdepth:0-0 /dfstg:0-0 /dfstm:0-0 /t:APITEST-202 // /dfRootMode:xactReadWriteShEx /dfStgMode:xactReadWriteShEx /labmode // c. stgbase /seed:2 /dfdepth:0-0 /dfstg:0-0 /dfstm:0-0 /t:APITEST-202 // /dfRootMode:xactReadWriteShDenyW /dfStgMode:xactReadWriteShEx /labmode // // BUGNOTE: Conversion: APITEST_202 //----------------------------------------------------------------------------- HRESULT APITEST_202(int argc, char *argv[]) { HRESULT hr = S_OK; HRESULT hr2 = S_OK; ChanceDF *pTestChanceDF = NULL; VirtualDF *pTestVirtualDF = NULL; VirtualCtrNode *pVirtualDFRoot = NULL; LPTSTR pRootNewChildStgName = NULL; VirtualCtrNode *pvcnRootNewChildStorage= NULL; DG_STRING *pdgu = NULL; DG_INTEGER *pdgi = NULL; LPENUMSTATSTG penumWalk = NULL; ULONG cMinNum = 1; ULONG cMaxNum = 999; DWORD dwReserved1 = 0; DWORD dwReserved3 = 0; LPTSTR pReserved2 = NULL; ULONG ulRef = 0; BOOL fPass = TRUE; ULONG celtFetched = 0; STATSTG statStg; LPMALLOC pMalloc = NULL; STATSTG *pStatStg = NULL; INT cAskMoreThanPresent = 2; // Set to 2 since only 1 substg // added in test DH_FUNCENTRY(NULL, DH_LVL_DFLIB, _TEXT("APITEST_202")); DH_TRACE((DH_LVL_ALWAYS, TEXT("Test variation APITEST_202 started")) ); DH_TRACE((DH_LVL_ALWAYS, TEXT("Attempt different illegitimate opeations on IEnumSTATSTG"))); // 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 APITEST_202, Access mode: %lx"), pTestChanceDF->GetRootMode())); } // Adds a new storage to the root storage. if (S_OK == hr) { pdgu = pTestVirtualDF->GetDataGenUnicode(); DH_ASSERT (NULL != pdgu); if (NULL == pdgu) { hr = E_FAIL; } } if(S_OK == hr) { 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, pTestChanceDF->GetStgMode()| STGM_CREATE | STGM_FAILIFTHERE, &pvcnRootNewChildStorage); DH_HRCHECK(hr, TEXT("AddStorage")) ; } // ----------- flatfile change --------------- } // ----------- flatfile change --------------- // BUGBUG: Use Random commit modes... if (S_OK == hr) { hr = pVirtualDFRoot->Commit(STGC_DEFAULT); DH_HRCHECK(hr, TEXT("VirtualCtrNode::Commit")) ; } // ----------- flatfile change --------------- if(!StorageIsFlat()) { // ----------- flatfile change --------------- // Close the Child storage if (S_OK == hr) { hr = pvcnRootNewChildStorage->Close(); DH_HRCHECK(hr, TEXT("VirtualCtrNode::Close")) ; } // ----------- flatfile change --------------- } // ----------- flatfile change --------------- // Get the random number generator if (S_OK == hr) { pdgi = pTestVirtualDF->GetDataGenInteger(); DH_ASSERT (NULL != pdgi); if (NULL == pdgi) { hr = E_FAIL; } } if(S_OK == hr) { hr = pdgi->Generate(&dwReserved1, cMinNum, cMaxNum); DH_HRCHECK(hr, TEXT("pdgi::Generate")) ; } if(S_OK == hr) { DH_EXPECTEDERROR (STG_E_INVALIDPARAMETER); hr = pVirtualDFRoot->EnumElements( dwReserved1, pReserved2, dwReserved3, &penumWalk); DH_NOEXPECTEDERROR (); CheckErrorTest(STG_E_INVALIDPARAMETER, TEXT ("VirtualCtrNode::EnumElements inv dwReserved1"), penumWalk); } if(S_OK == hr) { hr = pdgi->Generate(&dwReserved3, cMinNum, cMaxNum); DH_HRCHECK(hr, TEXT("dgi::Generate")) ; } if(S_OK == hr) { DH_EXPECTEDERROR (STG_E_INVALIDPARAMETER); hr = pVirtualDFRoot->EnumElements( dwReserved1, pReserved2, dwReserved3, &penumWalk); DH_NOEXPECTEDERROR (); CheckErrorTest(STG_E_INVALIDPARAMETER, TEXT ("VirtualCtrNode::EnumElements inv dwReserved3"), penumWalk); } if(S_OK == hr) { hr = GenerateRandomName(pdgu,MINLENGTH,MAXLENGTH, &pReserved2); DH_HRCHECK(hr, TEXT("GenerateRandomName")) ; } if(S_OK == hr) { DH_EXPECTEDERROR (STG_E_INVALIDPARAMETER); hr = pVirtualDFRoot->EnumElements( dwReserved1, pReserved2, dwReserved3, &penumWalk); DH_NOEXPECTEDERROR (); CheckErrorTest(STG_E_INVALIDPARAMETER, TEXT ("VirtualCtrNode::EnumElements inv pReserved2"), penumWalk); } // Now call EnumElements with NULL ppenm 4th parameter. if(S_OK == hr) { DH_EXPECTEDERROR (STG_E_INVALIDPOINTER); hr = pVirtualDFRoot->EnumElements( 0, NULL, 0, NULL); DH_NOEXPECTEDERROR (); CheckErrorTest2(STG_E_INVALIDPOINTER, TEXT ("VirtualCtrNode::EnumElements NULL penum")); } // Make a valid call to EnumElements now if(S_OK == hr) { hr = pVirtualDFRoot->EnumElements( 0, NULL, 0, &penumWalk); DH_HRCHECK(hr, TEXT("VirtualCtrNode::EnumElements")) ; } // Now try the following skip calls - Attempt to skip 0 elements and // attempt to skip MAX_ULONG elements. // Attempt to Skip 0 elements. if(S_OK == hr) { hr = penumWalk->Skip(0L); DH_HRCHECK(hr, TEXT("IEnumSTATSTG::Skip")) ; } // Attempt to Skip ULONG_MAX elements. // NOTE: In the old test, this was supposed to return S_OK, but it returns // S_FALSE if(S_OK == hr) { hr = penumWalk->Skip(ULONG_MAX); CheckErrorTest2(S_FALSE, TEXT ("IEnumSTATSTG::Skip ULONG_MAX")); } // Call Clone with NULL ppenum parameter (ist) if(S_OK == hr) { hr = penumWalk->Clone(NULL); CheckErrorTest2(STG_E_INVALIDPOINTER, TEXT ("IEnumSTATSTG::Clone NULL ppEnum")); } if(S_OK == hr) { statStg.pwcsName = NULL; // first get pmalloc that would be used to free up the name string from // STATSTG. hr = CoGetMalloc(MEMCTX_TASK, &pMalloc); DH_HRCHECK(hr, TEXT("CoGetMalloc")) ; } // Reset the enumerator back to start and then test Next methods if(S_OK == hr) { hr = penumWalk->Reset(); DH_HRCHECK(hr, TEXT("IEnumSTATSTG:Reset")) ; } // Call Next with celt equal to zero, but pceltFetched as not NULL. if(S_OK == hr) { hr = penumWalk->Next(0, &statStg ,&celtFetched); DH_TRACE((DH_LVL_TRACE4, TEXT("celt given 0, celtFetched is %lu, hr is %lx\n"), celtFetched, hr)); DH_HRCHECK (hr, TEXT("IEnumSTATSTG::Next celt 0")); } // Call Next with celt equal to 999, but celtFetched set to NULL if(S_OK == hr) { hr = penumWalk->Next(999, &statStg ,NULL); CheckErrorTest2(STG_E_INVALIDPARAMETER, TEXT ("IEnumSTATSTG::Next celt 999 and pceltFetched NULL")); } // Call Next with rgelt as NULL (2nd parameter). celtFetched may be NULL // when celt asked is 1 if(S_OK == hr) { hr = penumWalk->Next(1, NULL, NULL); CheckErrorTest2(STG_E_INVALIDPOINTER, TEXT ("IEnumSTATSTG::Next rgelt NULL")); } // Call Next with celt as 1 and pceltFetched as NULL. Allowed as per spec // For docfile/nssfile, it will pass since it has a substorage added as // above. For flatfile, it will pass since it has CONTENTS stream always if(S_OK == hr) { hr = penumWalk->Next(1, &statStg, NULL); DH_TRACE((DH_LVL_TRACE4, TEXT("Name of element fetched is %s\n"), statStg.pwcsName)); DH_HRCHECK(hr, TEXT("IEnumSTATSTG::Next celt 1 and pceltFetched NULL")); } // Clean up if(NULL != statStg.pwcsName) { pMalloc->Free(statStg.pwcsName); statStg.pwcsName = NULL; } // Call Next with celt more than elements in stg & celtFetched as not NULL if(S_OK == hr) { hr = penumWalk->Reset(); DH_HRCHECK(hr, TEXT("IEnumSTATSTG:Reset")) ; } if(S_OK == hr) { pStatStg = new STATSTG[cAskMoreThanPresent]; if(NULL == pStatStg) { hr = E_OUTOFMEMORY; } } if(S_OK == hr) { hr = penumWalk->Next(cAskMoreThanPresent, pStatStg ,&celtFetched); DH_TRACE((DH_LVL_TRACE4, TEXT("IEnumSTATSTG celt more, hr %lx, celtFetched %lu\n"), hr, celtFetched)); CheckErrorTest2(S_FALSE, TEXT ("IEnumSTATSTG::Next celt more number of elements")); } if(NULL != pStatStg) { delete [] pStatStg; pStatStg= NULL; } // Free LPENUMSTATSTG pointer if(NULL != penumWalk) { ulRef = penumWalk->Release(); DH_ASSERT (0 == ulRef); penumWalk = NULL; } // Close the root docfile if (NULL != pVirtualDFRoot) { hr2 = pVirtualDFRoot->Close(); DH_HRCHECK (hr2, TEXT("VirtualCtrNode::Close")); hr = FirstError (hr, hr2); } // if something did not pass, mark test (hr) as E_FAIL if (FALSE == fPass) { hr = FirstError (hr, E_FAIL); } // if everything goes well, log test as passed else failed. if ((S_OK == hr) && (TRUE == fPass)) { DH_LOG((LOG_PASS, TEXT("Test variation APITEST_202 passed.")) ); } else { DH_LOG((LOG_FAIL, TEXT("Test variation APITEST_202 failed; hr=%#lx; fPass=%d."), hr, fPass)); } // Cleanup CleanupTestDocfile (&pVirtualDFRoot, &pTestVirtualDF, &pTestChanceDF, S_OK == hr); // free strings if(NULL != pReserved2) { delete [] pReserved2; pReserved2 = NULL; } if(NULL != pRootNewChildStgName) { delete [] pRootNewChildStgName; pRootNewChildStgName = NULL; } // Stop logging the test DH_TRACE((DH_LVL_ALWAYS, TEXT("Test variation APITEST_202 finished")) ); return hr; } //---------------------------------------------------------------------------- // // Test: APITEST_203 // // Synopsis: Attempts various illegit operations on the IStorage interface, // verifies proper return codes. // // Arguments:[argc] // [argv] // // Returns: HRESULT // // History: 18-June-1996 NarindK Created. // // Notes: This test runs in direct, transacted, and transacted deny write // modes // // New Test Notes: // 1. Old File: IASTORAG.CXX // 2. Old name of test : IllegitAPIStorage test // New Name of test : APITEST_203 // 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:APITEST-203 // /dfRootMode:dirReadWriteShEx /dfStgMode:dirReadWriteShEx // b. stgbase /seed:2 /dfdepth:0-0 /dfstg:0-0 /dfstm:0-0 /t:APITEST-203 // /dfRootMode:xactReadWriteShEx /dfStgMode:xactReadWriteShEx // c. stgbase /seed:2 /dfdepth:0-0 /dfstg:0-0 /dfstm:0-0 /t:APITEST-203 // /dfRootMode:xactReadWriteShDenyW /dfStgMode:xactReadWriteShEx // // BUGNOTE: Conversion: APITEST_203 //----------------------------------------------------------------------------- HRESULT APITEST_203(int argc, char *argv[]) { HRESULT hr = S_OK; HRESULT hrExpected = E_NOTIMPL; // Flatfile change HRESULT hr2 = S_OK; ChanceDF *pTestChanceDF = NULL; VirtualDF *pTestVirtualDF = NULL; VirtualCtrNode *pVirtualDFRoot = NULL; LPTSTR ptszChildStgName = NULL; LPOLESTR poszChildStgName = NULL; LPSTORAGE pStgRoot = NULL; LPSTORAGE pStgChild = NULL; LPSTORAGE pStgChild2 = NULL; LPSTREAM pStmChild = NULL; DG_STRING *pdgu = NULL; DG_INTEGER *pdgi = NULL; ULONG cRandom = 0; ULONG cMin = 1; ULONG cMax = 999; SNB snbTest = NULL; SNB snbTemp = NULL; OLECHAR *ocsSNBChar = NULL; ULONG ulRef = 0; ULONG i = 0; BOOL fPass = TRUE; DH_FUNCENTRY(NULL, DH_LVL_DFLIB, _TEXT("APITEST_203")); DH_TRACE((DH_LVL_ALWAYS, TEXT("Test variation APITEST_203 started.")) ); DH_TRACE((DH_LVL_ALWAYS, TEXT("Attempt various illegitimate operations on IStorage interface"))); // 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 APITEST_203, Access mode: %lx"), pTestChanceDF->GetRootMode())); } // Get IStorage pointer if (S_OK == hr) { pStgRoot = pVirtualDFRoot->GetIStoragePointer(); DH_ASSERT (NULL != pStgRoot); if (NULL == pStgRoot) { hr = E_FAIL; } } if (S_OK == hr) { pdgu = pTestVirtualDF->GetDataGenUnicode(); DH_ASSERT (NULL != pdgu); if (NULL == pdgu) { hr = E_FAIL; } } if(S_OK == hr) { hr = GenerateRandomName(pdgu,MINLENGTH,MAXLENGTH,&ptszChildStgName); DH_HRCHECK(hr, TEXT("GenerateRandomName")) ; } if(S_OK == hr) { // Convert name to OLECHAR hr = TStringToOleString(ptszChildStgName, &poszChildStgName); DH_HRCHECK(hr, TEXT("TStringToOleString")) ; } // Call CreateStorage with grfmode=-1 if (S_OK == hr) { hr = pStgRoot->CreateStorage( poszChildStgName, (DWORD) -1, 0, 0, &pStgChild); // ----------- flatfile change --------------- hrExpected = StorageIsFlat() ? E_NOTIMPL : STG_E_INVALIDFLAG; // ----------- flatfile change --------------- CheckErrorTest(hrExpected, TEXT ("IStorage::CreateStorage inv grfMode"), pStgChild); } if (S_OK == hr) { pdgi = pTestVirtualDF->GetDataGenInteger(); DH_ASSERT (NULL != pdgi); if (NULL == pdgi) { hr = E_FAIL; } } if (S_OK == hr) { hr = pdgi->Generate(&cRandom, cMin, cMax); DH_HRCHECK(hr, TEXT("dgi::Generate")) ; } // Call CreateStorage with random data in dwReserved1 if (S_OK == hr) { hr = pStgRoot->CreateStorage( poszChildStgName, pTestChanceDF->GetStgMode() | STGM_CREATE, cRandom, 0, &pStgChild); // ----------- flatfile change --------------- hrExpected = StorageIsFlat() ? E_NOTIMPL : STG_E_INVALIDPARAMETER; // ----------- flatfile change --------------- CheckErrorTest(hrExpected, TEXT ("IStorage::CreateStorage inv dwReserved1"), pStgChild); } // Call CreateStorage with random data in dwReserved2 if (S_OK == hr) { hr = pStgRoot->CreateStorage( poszChildStgName, pTestChanceDF->GetStgMode() | STGM_CREATE, 0, cRandom, &pStgChild); // ----------- flatfile change --------------- hrExpected = StorageIsFlat() ? E_NOTIMPL : STG_E_INVALIDPARAMETER; // ----------- flatfile change --------------- CheckErrorTest(hrExpected, TEXT ("IStorage::CreateStorage inv dwReserved2"), pStgChild); } // Call CreateStorage with NULL 5th ppstg parameter if (S_OK == hr) { hr = pStgRoot->CreateStorage( poszChildStgName, pTestChanceDF->GetStgMode() | STGM_CREATE, 0, 0, NULL); // ----------- flatfile change --------------- hrExpected = StorageIsFlat() ? E_NOTIMPL : STG_E_INVALIDPOINTER; // ----------- flatfile change --------------- CheckErrorTest2(hrExpected, TEXT ("IStorage::CreateStorage NULL ppstg")); } // Create a stream with poszChildName and later on try to instantiate the // child storage with that same name poszChildName if (S_OK == hr) { hr = pStgRoot->CreateStream( poszChildStgName, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &pStmChild); DH_HRCHECK (hr, TEXT("IStorage::CreateStream")); } // BUGBUG: Use Random commit modes... if (S_OK == hr) { hr = pVirtualDFRoot->Commit(STGC_DEFAULT); DH_HRCHECK (hr, TEXT("VirtualCtrNode::Commit")); } // Close stream... if (NULL != pStmChild) { ulRef = pStmChild->Release(); DH_ASSERT (0 == ulRef); } // Now try opening storage with name with which above stream was created // i.e. poszChildName if (S_OK == hr) { pStgChild = NULL; hr = pStgRoot->OpenStorage( poszChildStgName, NULL, pTestChanceDF->GetStgMode(), NULL, 0, &pStgChild); // ----------- flatfile change --------------- hrExpected = StorageIsFlat() ? E_NOTIMPL : STG_E_FILENOTFOUND; // ----------- flatfile change --------------- CheckErrorTest(hrExpected, TEXT ("IStorage::OpenStorage inv name"), pStgChild); } //Destroy the stream element of this root storage having name poszChildStg //Name if(S_OK == hr) { hr = pStgRoot->DestroyElement(poszChildStgName); DH_HRCHECK(hr, TEXT("IStorage::DestroyElement")) ; } // ----------- flatfile change --------------- if(!StorageIsFlat()) // ----------- flatfile change --------------- { // Create a valid storage with name poszChildStgName if (S_OK == hr) { pStgChild = NULL; hr = pStgRoot->CreateStorage( poszChildStgName, pTestChanceDF->GetStgMode() | STGM_CREATE | STGM_FAILIFTHERE, 0, 0, &pStgChild); DH_HRCHECK (hr, TEXT("IStorage::CreateStorage")); } // Commit with grfCommitFlags = -1 if (S_OK == hr) { hr = pStgChild->Commit((DWORD) -1); CheckErrorTest2(STG_E_INVALIDFLAG, TEXT("IStorage::Commit inv flag")); } // Commit the child. BUGBUG: Use random commit modes if (S_OK == hr) { hr = pStgChild->Commit(STGC_DEFAULT); DH_HRCHECK (hr, TEXT("IStorage::Commit")); } // Commit the root storage. BUGBUG: Use random commit modes if (S_OK == hr) { hr = pVirtualDFRoot->Commit(STGC_DEFAULT); DH_HRCHECK (hr, TEXT("VirtualCtrNode::Commit")); } // Attempt second instantiation of pStgChild which is already open. if (S_OK == hr) { hr = pStgRoot->OpenStorage( poszChildStgName, NULL, pTestChanceDF->GetStgMode(), NULL, 0, &pStgChild2); CheckErrorTest(STG_E_ACCESSDENIED, TEXT ("IStorage::OpenStorage 2nd time"), pStgChild2); } if (S_OK == hr) { ulRef = pStgChild->Release(); DH_ASSERT (0 == ulRef); } // Now try to open child IStorage, but with grfMode = -1 if (S_OK == hr) { pStgChild = NULL; hr = pStgRoot->OpenStorage( poszChildStgName, NULL, (DWORD) -1, NULL, 0, &pStgChild); CheckErrorTest(STG_E_INVALIDFLAG, TEXT ("IStorage::OpenStorage inv grfMode"), pStgChild); } // Attempt OpenStorage with name as " " of IStorage to be opened. if (S_OK == hr) { pStgChild = NULL; hr = pStgRoot->OpenStorage( (OLECHAR *) " ", NULL, pTestChanceDF->GetStgMode(), NULL, 0, &pStgChild); CheckErrorTest(STG_E_FILENOTFOUND, TEXT ("IStorage::OpenStorage inv name"), pStgChild); } // Attempt OpenStorage with name as NULL of IStorage to be opened. if (S_OK == hr) { pStgChild = NULL; hr = pStgRoot->OpenStorage( NULL, NULL, pTestChanceDF->GetStgMode(), NULL, 0, &pStgChild); CheckErrorTest(STG_E_INVALIDNAME, TEXT ("IStorage::OpenStorage NULL name"), pStgChild); } // Attempt OpenStorage with name as NULL ppstg, 6th parameter. if (S_OK == hr) { hr = pStgRoot->OpenStorage( poszChildStgName, NULL, pTestChanceDF->GetStgMode(), NULL, 0, NULL); CheckErrorTest2(STG_E_INVALIDPOINTER, TEXT ("IStorage::OpenStorage NULL ppstg")); } // Attempt OpenStorage with random data in dwReserved parameter if (S_OK == hr) { hr = pdgi->Generate(&cRandom, cMin, cMax); DH_HRCHECK(hr, TEXT("dgi::Generate")) ; } if (S_OK == hr) { pStgChild = NULL; hr = pStgRoot->OpenStorage( poszChildStgName, NULL, pTestChanceDF->GetStgMode(), NULL, cRandom, &pStgChild); CheckErrorTest(STG_E_INVALIDPARAMETER, TEXT ("IStorage::OpenStorage inv dwReserved"), pStgChild); } // Attempt OpenStorage with uninitialized SNB, should fail, but no GP // fault should occur. if(S_OK == hr) { snbTest = (OLECHAR **) new OLECHAR [sizeof(OLECHAR *) * 2]; if(NULL == snbTest) { hr = E_OUTOFMEMORY; } else { *snbTest = (OLECHAR*)0xBAADF00D; } DH_HRCHECK (hr, TEXT("new OLECHAR")); } if (S_OK == hr) { pStgChild = NULL; hr = pStgRoot->OpenStorage( poszChildStgName, NULL, pTestChanceDF->GetStgMode(), snbTest, 0, &pStgChild); CheckErrorTest(STG_E_INVALIDPARAMETER, TEXT ("IStorage::OpenStorage inv snb"), pStgChild); } // Attempt OpenStorage with SNB with no name in block, although it has // space for two names, set name list to NULL if(S_OK == hr) { *snbTest = NULL; } if (S_OK == hr) { pStgChild = NULL; hr = pStgRoot->OpenStorage( poszChildStgName, NULL, pTestChanceDF->GetStgMode(), snbTest, 0, &pStgChild); CheckErrorTest(STG_E_INVALIDPARAMETER, TEXT ("IStorage::OpenStorage empty snb"), pStgChild); } // Allocate space for long name and fill name with X's, make next SNB // element NULL, and make a call to IStorage::OpenStorage with too long a // name in SNB if(S_OK == hr && NULL != snbTest) { *snbTest = (OLECHAR *) new OLECHAR [MAX_STG_NAME_LEN*4]; if (NULL == *snbTest) { hr = E_OUTOFMEMORY; } DH_HRCHECK (hr, TEXT("new OLECHAR")); } if(S_OK == hr && NULL != snbTest) { snbTemp = snbTest; ocsSNBChar = *snbTemp; for (i=0; i<( MAX_STG_NAME_LEN*4 -1); i++) { ocsSNBChar[i] = 'X'; } ocsSNBChar[i] = '\0'; // Assign second element as NULL snbTemp++; *snbTemp = NULL; } if (S_OK == hr) { pStgChild = NULL; hr = pStgRoot->OpenStorage( poszChildStgName, NULL, pTestChanceDF->GetStgMode(), snbTest, 0, &pStgChild); CheckErrorTest(STG_E_INVALIDPARAMETER, TEXT ("IStorage::OpenStorage long snb"), pStgChild); } // ----------- flatfile change --------------- } // ----------- flatfile change --------------- // Close the root docfile if (NULL != pVirtualDFRoot) { hr2 = pVirtualDFRoot->Close(); DH_HRCHECK (hr2, TEXT("VirtualCtrNode::Close")); hr = FirstError (hr, hr2); } // if something did not pass, mark test (hr) as E_FAIL if (FALSE == fPass) { hr = FirstError (hr, E_FAIL); } // if everything goes well, log test as passed else failed. if ((S_OK == hr) && (TRUE == fPass)) { DH_LOG((LOG_PASS, TEXT("Test variation APITEST_203 passed.")) ); } else { DH_LOG(( LOG_FAIL, TEXT("Test variation APITEST_203 failed; hr=%#lx; fPass=%d."), hr, fPass)); } // Cleanup CleanupTestDocfile (&pVirtualDFRoot, &pTestVirtualDF, &pTestChanceDF, S_OK == hr); // Delete temp strings if(NULL != ptszChildStgName) { delete []ptszChildStgName; ptszChildStgName = NULL; } if(NULL != poszChildStgName) { delete []poszChildStgName; poszChildStgName = NULL; } // Free SNB if(NULL != snbTest) { if(NULL != *snbTest) { delete [] *snbTest; *snbTest = NULL; } delete [] snbTest; snbTest = NULL; } // Stop logging the test DH_TRACE((DH_LVL_ALWAYS, TEXT("Test variation APITEST_203 finished")) ); return hr; } //---------------------------------------------------------------------------- // // Test: APITEST_204 // // Synopsis: Attempts various illegit operations on the IStream interface, // verifies proper return codes. // // Arguments:[argc] // [argv] // // Returns: HRESULT // // History: 18-June-1996 NarindK Created. // // Notes: This test runs in direct, transacted, and transacted deny write // modes // // New Test Notes: // 1. Old File: IASTREAM.CXX // 2. Old name of test : IllegitAPIStream test // New Name of test : APITEST_204 // 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:APITEST-204 // /dfRootMode:dirReadWriteShEx // b. stgbase /seed:2 /dfdepth:0-0 /dfstg:0-0 /dfstm:0-0 /t:APITEST-204 // /dfRootMode:xactReadWriteShEx // c. stgbase /seed:2 /dfdepth:0-0 /dfstg:0-0 /dfstm:0-0 /t:APITEST-204 // /dfRootMode:xactReadWriteShDenyW // // BUGNOTE: Conversion: APITEST_204 //----------------------------------------------------------------------------- HRESULT APITEST_204(int argc, char *argv[]) { HRESULT hr = S_OK; HRESULT hr2 = S_OK; ChanceDF *pTestChanceDF = NULL; VirtualDF *pTestVirtualDF = NULL; VirtualCtrNode *pVirtualDFRoot = NULL; LPTSTR ptszChildStmName = NULL; LPOLESTR poszChildStmName = NULL; LPSTORAGE pStgRoot = NULL; LPSTORAGE pStgChild = NULL; LPSTREAM pStmChild = NULL; LPSTREAM pStmChild2 = NULL; ULONG ulRef = 0; DG_STRING *pdgu = NULL; DG_INTEGER *pdgi = NULL; ULONG cRandom = 0; ULONG cMin = 1; ULONG cMax = 999; BOOL fPass = TRUE; DH_FUNCENTRY(NULL, DH_LVL_DFLIB, _TEXT("APITEST_204")); DH_TRACE((DH_LVL_ALWAYS, TEXT("Test variation APITEST_204 started.")) ); DH_TRACE((DH_LVL_ALWAYS, TEXT("Attempt illegitimate operations on IStream interface."))); // 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 APITEST_204, Access mode: %lx"), pTestChanceDF->GetRootMode())); } // Get IStorage pointer if (S_OK == hr) { pStgRoot = pVirtualDFRoot->GetIStoragePointer(); DH_ASSERT (NULL != pStgRoot); if (NULL == pStgRoot) { hr = E_FAIL; } } // Get DG_STRING pointer if (S_OK == hr) { pdgu = pTestVirtualDF->GetDataGenUnicode(); DH_ASSERT (NULL != pdgu); if (NULL == pdgu) { hr = E_FAIL; } } // Generate random name for stream if(S_OK == hr) { hr = GenerateRandomName(pdgu,MINLENGTH,MAXLENGTH, &ptszChildStmName); DH_HRCHECK(hr, TEXT("GenerateRandomName")) ; } if(S_OK == hr) { // Convert name to OLECHAR hr = TStringToOleString(ptszChildStmName, &poszChildStmName); DH_HRCHECK(hr, TEXT("TStringToOleString")) ; } // Attempt CreateStream with grfmode=-1 if (S_OK == hr) { hr = pStgRoot->CreateStream( poszChildStmName, (DWORD) -1, 0, 0, &pStmChild); CheckErrorTest(STG_E_INVALIDFLAG, TEXT ("IStorage::CreateStream inv grfMode"), pStmChild); } // Get DG_INTEGER pointer if (S_OK == hr) { pdgi = pTestVirtualDF->GetDataGenInteger(); DH_ASSERT (NULL != pdgi); if (NULL == pdgi) { hr = E_FAIL; } } if (S_OK == hr) { hr = pdgi->Generate(&cRandom, cMin, cMax); DH_HRCHECK(hr, TEXT("dgi::Generate")) ; } // Call CreateStorage with random data in dwReserved1 if (S_OK == hr) { hr = pStgRoot->CreateStream( poszChildStmName, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, cRandom, 0, &pStmChild); CheckErrorTest(STG_E_INVALIDPARAMETER, TEXT ("IStorage::CreateStream inv dwReserved1"), pStmChild); } // Call CreateStream with random data in dwReserved2 if (S_OK == hr) { hr = pStgRoot->CreateStream( poszChildStmName, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, cRandom, &pStmChild); CheckErrorTest(STG_E_INVALIDPARAMETER, TEXT ("IStorage::CreateStream inv dwReserved2"), pStmChild); } // Call CreateStorage with NULL 5th ppstm parameter if (S_OK == hr) { hr = pStgRoot->CreateStream( poszChildStmName, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, NULL); CheckErrorTest2(STG_E_INVALIDPOINTER, TEXT ("IStorage::CreateStream NULL ppstm")); } // ----------- flatfile change --------------- if(!StorageIsFlat()) { // ----------- flatfile change --------------- // Create a storage with poszChildStmName and later on try to instantiate // child stream with that same name poszChildStmName if (S_OK == hr) { hr = pStgRoot->CreateStorage( poszChildStmName, STGM_READWRITE | STGM_SHARE_EXCLUSIVE | STGM_CREATE, 0, 0, &pStgChild); DH_HRCHECK (hr, TEXT("IStorage::CreateStorage")); DH_ASSERT (NULL != pStgChild); } // BUGBUG: Use Random commit modes... if (S_OK == hr) { hr = pVirtualDFRoot->Commit(STGC_DEFAULT); DH_HRCHECK (hr, TEXT("VirtualCtrNode::Commit")); } // Close storage... if (NULL != pStgChild) { ulRef = pStgChild->Release(); DH_ASSERT (0 == ulRef); } // ----------- flatfile change --------------- } // ----------- flatfile change --------------- // Now try opening storage with name with which above storage was created // i.e. poszChildStmName if (S_OK == hr) { pStmChild = NULL; hr = pStgRoot->OpenStream( poszChildStmName, NULL, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &pStmChild); CheckErrorTest(STG_E_FILENOTFOUND, TEXT ("IStorage::CreateStream inv name"), pStmChild); } // ----------- flatfile change --------------- if(!StorageIsFlat()) { // ----------- flatfile change --------------- //Destroy the storage element of this root storage having name poszChildStm //Name if(S_OK == hr) { hr = pStgRoot->DestroyElement(poszChildStmName); DH_HRCHECK(hr, TEXT("IStorage::DestroyElement")) ; } // ----------- flatfile change --------------- } // ----------- flatfile change --------------- // Create a valid stream with name poszChildStmName if (S_OK == hr) { pStmChild = NULL; hr = pStgRoot->CreateStream( poszChildStmName, STGM_READWRITE | STGM_SHARE_EXCLUSIVE | STGM_FAILIFTHERE, 0, 0, &pStmChild); DH_HRCHECK (hr, TEXT("IStorage::CreateStream")); DH_ASSERT (NULL != pStmChild); } // BUGBUG: Use Random commit modes... if (S_OK == hr) { hr = pVirtualDFRoot->Commit(STGC_DEFAULT); DH_HRCHECK (hr, TEXT("IStorage::Commit")); } // Attempt second instance of IStream to be instantiated. if (S_OK == hr) { pStmChild2 = NULL; hr = pStgRoot->OpenStream( poszChildStmName, NULL, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &pStmChild2); CheckErrorTest(STG_E_ACCESSDENIED, TEXT ("IStorage::OpenStream 2nd time"), pStmChild2); } // Release the stream if(NULL != pStmChild) { ulRef = pStmChild->Release(); DH_ASSERT (0 == ulRef); } // Now attempt opening the stream with grfMode = -1 if (S_OK == hr) { pStmChild = NULL; hr = pStgRoot->OpenStream( poszChildStmName, NULL, (DWORD) -1, 0, &pStmChild); CheckErrorTest(STG_E_INVALIDFLAG, TEXT ("IStorage::OpenStream inv grfMode"), pStmChild); } // Now attempt opening the stream with name as "" if (S_OK == hr) { pStmChild = NULL; hr = pStgRoot->OpenStream( (OLECHAR *) " ", NULL, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &pStmChild); CheckErrorTest(STG_E_FILENOTFOUND, TEXT ("IStorage::OpenStream inv name"), pStmChild); } // Now attempt opening the stream with name as NULL if (S_OK == hr) { pStmChild = NULL; hr = pStgRoot->OpenStream( NULL, NULL, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &pStmChild); CheckErrorTest(STG_E_INVALIDNAME, TEXT ("IStorage::OpenStream NULL name"), pStmChild); } // Now attempt opening the stream with random data in pReserved1 . For test // we just put pStgRoot for pReserved1 variable. if (S_OK == hr) { pStmChild = NULL; hr = pStgRoot->OpenStream( poszChildStmName, pStgRoot, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &pStmChild); CheckErrorTest(STG_E_INVALIDPARAMETER, TEXT ("IStorage::OpenStream inv dwReserved1"), pStmChild); } // Now attempt opening the stream with random data in dwReserved2 if (S_OK == hr) { pStmChild = NULL; hr = pStgRoot->OpenStream( poszChildStmName, NULL, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, cRandom, &pStmChild); CheckErrorTest(STG_E_INVALIDPARAMETER, TEXT ("IStorage::OpenStream inv dwReserved2"), pStmChild); } // Now attempt opening the stream with NULL ppstm (5th parameter) if (S_OK == hr) { hr = pStgRoot->OpenStream( poszChildStmName, NULL, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, NULL); CheckErrorTest2(STG_E_INVALIDPOINTER, TEXT ("IStorage::OpenStream NULL ppstm")); } // Now attempt opening the stream normally if (S_OK == hr) { pStmChild = NULL; hr = pStgRoot->OpenStream( poszChildStmName, NULL, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &pStmChild); DH_HRCHECK (hr, TEXT("IStorage::OpenStream")); DH_ASSERT (NULL != pStmChild); } // Release the stream if(NULL != pStmChild) { ulRef = pStmChild->Release(); DH_ASSERT (0 == ulRef); pStmChild = NULL; } // Release the root docfile // Close the root docfile if (NULL != pVirtualDFRoot) { hr2 = pVirtualDFRoot->Close(); DH_HRCHECK (hr2, TEXT("VirtualCtrNode::Close")); hr = FirstError (hr, hr2); } // if something did not pass, mark test (hr) as E_FAIL if (FALSE == fPass) { hr = FirstError (hr, E_FAIL); } // if everything goes well, log test as passed else failed. if ((S_OK == hr) && (TRUE == fPass)) { DH_LOG((LOG_PASS, TEXT("Test variation APITEST_204 passed.")) ); } else { DH_LOG((LOG_FAIL, TEXT("Test variation APITEST_204 failed; hr=%#lx; fPass=%d."), hr, fPass)); } // Cleanup CleanupTestDocfile (&pVirtualDFRoot, &pTestVirtualDF, &pTestChanceDF, S_OK == hr); // Delete temp string if(NULL != ptszChildStmName) { delete []ptszChildStmName; ptszChildStmName = NULL; } if(NULL != poszChildStmName) { delete []poszChildStmName; poszChildStmName = NULL; } // Stop logging the test DH_TRACE((DH_LVL_ALWAYS, TEXT("Test variation APITEST_204 finished")) ); return hr; } #else // Stub out calls to these. HRESULT APITEST_200(int argc, char *argv[]) {return E_NOTIMPL;} HRESULT APITEST_201(int argc, char *argv[]) {return E_NOTIMPL;} HRESULT APITEST_202(int argc, char *argv[]) {return E_NOTIMPL;} HRESULT APITEST_203(int argc, char *argv[]) {return E_NOTIMPL;} HRESULT APITEST_204(int argc, char *argv[]) {return E_NOTIMPL;} #endif // _OLE_NSS_