diff options
Diffstat (limited to 'private/oleutest/perform/cairole/tests/bmp_stg.cxx')
| -rw-r--r-- | private/oleutest/perform/cairole/tests/bmp_stg.cxx | 471 |
1 files changed, 471 insertions, 0 deletions
diff --git a/private/oleutest/perform/cairole/tests/bmp_stg.cxx b/private/oleutest/perform/cairole/tests/bmp_stg.cxx new file mode 100644 index 000000000..acfdf9e5d --- /dev/null +++ b/private/oleutest/perform/cairole/tests/bmp_stg.cxx @@ -0,0 +1,471 @@ +//+------------------------------------------------------------------------ +// +// Microsoft Windows +// Copyright (C) Microsoft Corporation, 1993. +// +// File: bmp_stg.cxx +// +// Contents: Generic Storage parser based test +// +// Classes: CStorageParserTest, CStorageParser +// +// Functions: +// +// History: 15-June-94 t-vadims Created +// +//-------------------------------------------------------------------------- + +#include <headers.cxx> +#pragma hdrstop + +#include <valid.h> +#include <tchar.h> +#include <bmp_stg.hxx> + +//+------------------------------------------------------------------------ +// +// Class: CStorageParserTest +// +// Functions: +// +// History: 15-June-94 t-vadims Created +// +//-------------------------------------------------------------------------- + +SCODE CStorageParserTest::SetParserObject () +{ + m_pParser = new CStorageParser; + return S_OK; +} + + +SCODE CStorageParserTest::DeleteParserObject () +{ + delete m_pParser; + return S_OK; +} + + +TCHAR* CStorageParserTest::Name () +{ + return TEXT("StorageParserTest"); +} + + +TCHAR *CStorageParserTest::SectionHeader() +{ + return TEXT("Storage test from log"); +} + + + +//+------------------------------------------------------------------------ +// +// Class: CStorageParser +// +// Functions: +// +// History: 15-June-94 t-vadims Created +// +//-------------------------------------------------------------------------- + +#define STATE_OFFSET 10 // location of "In"/"Out" in log string +#define NAME_OFFSET 14 // location of command name in log string + +#define MAX_NAME 50 + +#define DEF_ARRAYSIZE 10 + + +//+------------------------------------------------------------------- +// +// Member: CStorageParser::Setup, public +// +// Synopsis: Makes all neccessary initializations. +// +// History: 16-June-94 t-vadims Created +// +//-------------------------------------------------------------------- +SCODE CStorageParser::Setup (CTestInput *pInput) +{ + SCODE sc; + + + sc = CoGetMalloc(MEMCTX_TASK, &m_piMalloc); + if (FAILED(sc)) + return sc; + + m_iStreamCount = 0; + m_iStreamArraySize = DEF_ARRAYSIZE; + m_aulStreamID = (ULONG *)m_piMalloc->Alloc(m_iStreamArraySize * + sizeof(ULONG)); + m_apStreams = (LPSTREAM *)m_piMalloc->Alloc(m_iStreamArraySize * + sizeof(LPSTREAM)); + + m_iStorageCount = 0; + m_iStorageArraySize = DEF_ARRAYSIZE; + m_aulStorageID = (ULONG *)m_piMalloc->Alloc(m_iStorageArraySize * + sizeof(ULONG)); + m_apStorages = (LPSTORAGE *)m_piMalloc->Alloc(m_iStorageArraySize * + sizeof(LPSTORAGE)); + + m_iInstrCount = 0; + m_iInstrArraySize = DEF_ARRAYSIZE; + m_apInstrData = (LPINSTRDATA *)m_piMalloc->Alloc(m_iInstrArraySize * + sizeof(LPINSTRDATA)); + + + m_bGotFirstPart = FALSE; + + if (m_apInstrData == NULL || m_aulStorageID == NULL || + m_apStorages == NULL || m_aulStreamID == NULL || + m_apStreams == NULL ) + { + Cleanup(); + Log(TEXT("Setup can't allocate memory"), E_OUTOFMEMORY); + return E_OUTOFMEMORY; + } + + return S_OK; +} + +//+------------------------------------------------------------------- +// +// Member: CStorageParser::Cleanup, public +// +// Synopsis: Makes all neccessary cleanup +// +// History: 16-June-94 t-vadims Created +// +//-------------------------------------------------------------------- +SCODE CStorageParser::Cleanup () +{ + /* do any neccessary clean up */ + if(m_piMalloc) + { + if (m_aulStreamID) + m_piMalloc->Free(m_aulStreamID); + if (m_apStreams) + m_piMalloc->Free(m_apStreams); + if (m_aulStorageID) + m_piMalloc->Free(m_aulStorageID); + if (m_apStorages) + m_piMalloc->Free(m_apStorages); + + + for (ULONG i = 0; i < m_iInstrCount; i++) + delete m_apInstrData[i]; + + if (m_apInstrData) + m_piMalloc->Free(m_apInstrData); + + m_piMalloc->Release(); + m_piMalloc = NULL; + } + return S_OK; +} + + +//+------------------------------------------------------------------- +// +// Member: CStorageParser::AddInstruction, public +// +// Synopsis: Parse new instruction and add it to array if it is valid +// +// Return: ID of instruction +// +// History: 16-June-94 t-vadims Created +// +//-------------------------------------------------------------------- +ULONG CStorageParser::AddInstruction(LPTSTR pszFirstPart, LPTSTR pszSecondPart) +{ + ULONG ulInstrID; + SCODE sc; + + TCHAR szInstrName[MAX_NAME]; + TCHAR szSecondName[MAX_NAME]; + + if (_tcsncmp(pszFirstPart + STATE_OFFSET, TEXT("In"), 2) != 0) + return INVALID_INSTRUCTION; + + if (_tcsncmp(pszSecondPart + STATE_OFFSET, TEXT("Out"), 3) != 0) + return INVALID_INSTRUCTION; + + + // check if the same instruction name; + GetInstructionName(szInstrName, pszFirstPart); + GetInstructionName(szSecondName, pszSecondPart); + + if(_tcscmp(szInstrName, szSecondName) != 0) + return INVALID_INSTRUCTION; + + + // determine the instruction + ulInstrID = INVALID_INSTRUCTION; + for (ULONG i = 0; i < m_iMaxInstruction; i++) + if (_tcscmp(szInstrName, m_aInstructions[i].szLogName) == 0) + { + ulInstrID = i; + break; + } + + if(ulInstrID == INVALID_INSTRUCTION) + return INVALID_INSTRUCTION; + + // fill appropriate structure fields + SInstrData *pInstrData = new SInstrData; + pInstrData->ulInstrID = ulInstrID; + + sc = (this->*m_aInstructions[ulInstrID].Parse)(pInstrData, + pszFirstPart, + pszSecondPart); + + if (FAILED(sc)) + { + delete pInstrData; + return INVALID_INSTRUCTION; + } + + return AddNewInstrData(pInstrData); +} + +//+------------------------------------------------------------------- +// +// Member: CStorageParser::IgnoreInstruction, private +// +// Synopsis: Check if this instruction should be ignored. +// +// History: 16-June-94 t-vadims Created +// +//-------------------------------------------------------------------- +BOOL CStorageParser::IgnoreInstruction(LPTSTR pszInstr) +{ + TCHAR szName[MAX_NAME]; + + // We Ignore those instructions that are completely implemented + // in terms of other instructions that are also logged. + + GetInstructionName(szName, pszInstr); + + if (_tcscmp (szName, TEXT("CExposedStream::QueryInterface")) == 0 || + _tcscmp (szName, TEXT("CExposedDocFile::QueryInterface")) == 0 || + _tcscmp (szName, TEXT("CExposedStream::CopyTo")) == 0 || + _tcscmp (szName, TEXT("CExposedDocFile::MoveElementTo")) == 0 || + _tcscmp (szName, TEXT("CExposedDocFile::CopyTo")) == 0 || + _tcscmp (szName, TEXT("ExposedDocFile::CopyTo")) == 0 + ) + { + return TRUE; + } + + return FALSE; +} + +//+------------------------------------------------------------------- +// +// Member: CStorageParser::ParseNewInstruction, public +// +// Synopsis: Parse new line of file, and return its id. +// +// History: 16-June-94 t-vadims Created +// +//-------------------------------------------------------------------- +ULONG CStorageParser::ParseNewInstruction(LPTSTR pszInstr) +{ + ULONG ulID; + + if (IgnoreInstruction(pszInstr)) + return NOT_INSTRUCTION; + + if (m_bGotFirstPart) + { + // out part of instruction. We can now add it. + ulID = AddInstruction(m_szBuffer, pszInstr); + m_bGotFirstPart = FALSE; + } + else + { + // save In part of instruction, and fake CTimerBase into + // thinking that this wasn't an instruction. + _tcscpy(m_szBuffer, pszInstr); + ulID = NOT_INSTRUCTION; + m_bGotFirstPart = TRUE; + } + + return ulID; +} + +//+------------------------------------------------------------------- +// +// Member: CStorageParser::ExecuteInstruction, public +// +// Synopsis: Execute instruction with given id. +// +// Return: time taken to execute it. +// +// History: 16-June-94 t-vadims Created +// +//-------------------------------------------------------------------- +ULONG CStorageParser::ExecuteInstruction(ULONG ulID) +{ + SInstrData *pInstrData = m_apInstrData[ulID]; + + return (this->*m_aInstructions[pInstrData->ulInstrID].Execute)(pInstrData); +} + + +//+------------------------------------------------------------------- +// +// Member: CStorageParser::InstructionName, public +// +// Synopsis: Return name of instruction. +// +// History: 16-June-94 t-vadims Created +// +//-------------------------------------------------------------------- +TCHAR * CStorageParser::InstructionName(ULONG ulID) +{ + SInstrData *pInstrData = m_apInstrData[ulID]; + + if (m_aInstructions[pInstrData->ulInstrID].GetName != NULL) + return (this->*m_aInstructions[pInstrData->ulInstrID].GetName)(pInstrData); + else + return m_aInstructions[pInstrData->ulInstrID].szPrintName; +} + + +//+------------------------------------------------------------------- +// +// Member: CStorageParser::GetInstructionName, public +// +// Synopsis: Extract instruction name from the instruction. +// +// History: 16-June-94 t-vadims Created +// +//-------------------------------------------------------------------- +SCODE CStorageParser::GetInstructionName (LPTSTR pszName, LPTSTR pszInstruction) +{ + _stscanf(pszInstruction + NAME_OFFSET, TEXT("%[^(]"), pszName); + return S_OK; +} + +//+------------------------------------------------------------------- +// +// Member: CStorageParser::AddNewInstrData, public +// +// Synopsis: Adds new instruction to instrData array. +// +// History: 16-June-94 t-vadims Created +// +//-------------------------------------------------------------------- +ULONG CStorageParser::AddNewInstrData (LPINSTRDATA pInstrData) +{ + if (m_iInstrCount >= m_iInstrArraySize) + { + m_iInstrArraySize *= 2; + m_apInstrData = (LPINSTRDATA *)m_piMalloc->Realloc(m_apInstrData, + m_iInstrArraySize * sizeof(LPINSTRDATA)); + } + + m_apInstrData[m_iInstrCount] = pInstrData; + + return m_iInstrCount++; +} + +//+------------------------------------------------------------------- +// +// Member: CStorageParser::FindStorageID, public +// +// Synopsis: finds or creates new storage, based on ID. +// +// History: 16-June-94 t-vadims Created +// +//-------------------------------------------------------------------- +ULONG CStorageParser::FindStorageID (ULONG ulStgID) +{ + for (ULONG i = 0; i < m_iStorageCount; i++) + if (m_aulStorageID[i] == ulStgID) + return i; + + if (m_iStorageCount >= m_iStorageArraySize) + { + m_iStorageArraySize *= 2; + m_aulStorageID = (ULONG *)m_piMalloc->Realloc(m_aulStorageID, + m_iStorageArraySize * sizeof(ULONG)); + + m_apStorages = (LPSTORAGE *)m_piMalloc->Realloc(m_apStorages, + m_iStorageArraySize * sizeof(LPSTORAGE)); + + } + m_aulStorageID[m_iStorageCount] = ulStgID; + m_apStorages[m_iStorageCount] = NULL; + + return m_iStorageCount++; +} + + +//+------------------------------------------------------------------- +// +// Member: CStorageParser::FindStreamID, public +// +// Synopsis: finds or creates new stream, based on ID. +// +// History: 16-June-94 t-vadims Created +// +//-------------------------------------------------------------------- +ULONG CStorageParser::FindStreamID (ULONG ulStreamID) +{ + for (ULONG i = 0; i < m_iStreamCount; i++) + if (m_aulStreamID[i] == ulStreamID) + return i; + + if (m_iStreamCount >= m_iStreamArraySize) + { + m_iStreamArraySize *=2; + m_aulStreamID = (ULONG *)m_piMalloc->Realloc(m_aulStreamID, + m_iStreamArraySize * sizeof(ULONG)); + + m_apStreams = (LPSTREAM *)m_piMalloc->Realloc(m_apStreams, + m_iStreamArraySize * sizeof(LPSTREAM)); + + } + m_aulStreamID[m_iStreamCount] = ulStreamID; + m_apStreams[m_iStreamCount] = NULL; + + return m_iStreamCount++; +} + +//+------------------------------------------------------------------- +// +// Members: CStorageParser::CheckThisStorageID, public +// CStorageParser::CheckThisStreamID, public +// +// Synopsis: Check if storage/stream with given id can be dereferenced. +// (must be non null). +// +// History: 16-June-94 t-vadims Created +// +//-------------------------------------------------------------------- + +SCODE CStorageParser::CheckThisStorageID(ULONG ulStorageID) +{ + if(m_apStorages[ulStorageID] == NULL || + ! IsValidInterface(m_apStorages[ulStorageID])) + { + Log(TEXT("Trying to dereference an unassigned Storage"), E_FAIL); + return E_FAIL; + } + return S_OK; +} + + +SCODE CStorageParser::CheckThisStreamID(ULONG ulStreamID) +{ + if(m_apStreams[ulStreamID] == NULL || + ! IsValidInterface(m_apStreams[ulStreamID])) + { + Log(TEXT("Trying to dereference an unassigned Stream"), E_FAIL); + return E_FAIL; + } + return S_OK; +} |