You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
367 lines
8.5 KiB
367 lines
8.5 KiB
//+------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
// Copyright (C) Microsoft Corporation, 1993.
|
|
//
|
|
// File: bm_rot.cxx
|
|
//
|
|
// Contents: Ole running object table test (ROT)
|
|
//
|
|
// Classes: CROTTest
|
|
//
|
|
// History: 9-July-93 t-martig Created
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
#include <headers.cxx>
|
|
#pragma hdrstop
|
|
|
|
#include <bm_rot.hxx>
|
|
#include <cact.hxx> // CTestAct
|
|
|
|
|
|
// function used by CTestAct. need not do anything for our usage.
|
|
void GlobalRefs(BOOL fAdd)
|
|
{
|
|
}
|
|
|
|
|
|
TCHAR *CROTTest::Name ()
|
|
{
|
|
return TEXT("ROT");
|
|
}
|
|
|
|
|
|
SCODE CROTTest::Setup (CTestInput *pInput)
|
|
{
|
|
IClassFactory *pICF = NULL;
|
|
IPersistFile *pIPF = NULL;
|
|
SCODE sc = S_OK, scRet = S_OK;
|
|
|
|
|
|
CTestBase::Setup(pInput);
|
|
|
|
// get the iteration count from the ini file
|
|
m_ulIterations = pInput->GetIterations(Name());
|
|
m_ulEntries = 1;
|
|
|
|
// for each class ctx, get the classid, and init internal state
|
|
for (ULONG iCtx=0; iCtx<CNT_CLSCTX; iCtx++)
|
|
{
|
|
// Get ClsID for this Ctx from the .ini file
|
|
sc = pInput->GetGUID(&m_ClsID[iCtx], Name(), apszClsIDName[iCtx]);
|
|
if (FAILED(sc))
|
|
{
|
|
Log (TEXT("Setup - GetClassID failed."), sc);
|
|
return sc;
|
|
}
|
|
|
|
INIT_RESULTS(m_ulGetROTTime[iCtx]);
|
|
INIT_RESULTS(m_ulReleaseTime[iCtx]);
|
|
INIT_RESULTS(m_ulRegisterTime[iCtx]);
|
|
INIT_RESULTS(m_ulRevokeTime[iCtx]);
|
|
INIT_RESULTS(m_ulNoteChangeTime[iCtx]);
|
|
INIT_RESULTS(m_ulGetChangeTime[iCtx]);
|
|
INIT_RESULTS(m_ulIsRunningTime[iCtx]);
|
|
INIT_RESULTS(m_ulGetObjectTime[iCtx]);
|
|
INIT_RESULTS(m_ulEnumRunningTime[iCtx]);
|
|
}
|
|
|
|
|
|
sc = InitCOM();
|
|
if (FAILED(sc))
|
|
{
|
|
Log (TEXT("Setup - CoInitialize failed."), sc);
|
|
return sc;
|
|
}
|
|
|
|
|
|
// for each class ctx, create a persistent instance on disk
|
|
for (iCtx=0; iCtx<CNT_CLSCTX; iCtx++)
|
|
{
|
|
m_punkObj[iCtx] = NULL;
|
|
m_pmkObj[iCtx] = NULL;
|
|
|
|
if (dwaClsCtx[iCtx] == CLSCTX_INPROC_SERVER)
|
|
{
|
|
// create an inprocess instance
|
|
m_punkObj[iCtx] = (IPersistFile *) new CTestAct(m_ClsID[iCtx]);
|
|
sc = (m_punkObj[iCtx] != NULL) ? S_OK : E_OUTOFMEMORY;
|
|
}
|
|
else
|
|
{
|
|
// Create an instance
|
|
sc = CoCreateInstance(m_ClsID[iCtx], NULL, dwaClsCtx[iCtx],
|
|
IID_IUnknown, (void **)&m_punkObj[iCtx]);
|
|
}
|
|
|
|
if (SUCCEEDED(sc))
|
|
{
|
|
// Create a moniker
|
|
sc = CreateFileMoniker(apszPerstName[iCtx], &m_pmkObj[iCtx]);
|
|
|
|
if (SUCCEEDED(sc))
|
|
{
|
|
// get the IPersistFile interface
|
|
IPersistFile *pIPF = NULL;
|
|
|
|
sc = m_punkObj[iCtx]->QueryInterface(IID_IPersistFile,
|
|
(void **)&pIPF);
|
|
|
|
if (SUCCEEDED(sc))
|
|
{
|
|
// save the class instance in the file.
|
|
// NOTE: we assume the server's implementation of
|
|
// this method does not do any ROT operations. We
|
|
// know this to be true of CTestAct.
|
|
|
|
sc = pIPF->Save(apszPerstName[iCtx], FALSE);
|
|
pIPF->Release();
|
|
|
|
if (FAILED(sc))
|
|
{
|
|
Log (TEXT("Setup - pIPF->Save failed."), sc);
|
|
scRet = sc;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Log (TEXT("Setup - QueryInterface failed"), sc);
|
|
scRet = sc;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Log (TEXT("Setup - CreateFileMoniker failed"), sc);
|
|
scRet = sc;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Log (TEXT("Setup - CreateInstance failed"), sc);
|
|
scRet = sc;
|
|
}
|
|
}
|
|
|
|
if (FAILED(scRet))
|
|
{
|
|
Cleanup();
|
|
}
|
|
|
|
return scRet;
|
|
}
|
|
|
|
|
|
SCODE CROTTest::Cleanup ()
|
|
{
|
|
CHAR szPerstName[80];
|
|
|
|
// delete the persistent instances
|
|
for (ULONG iCtx=0; iCtx<CNT_CLSCTX; iCtx++)
|
|
{
|
|
// delete files
|
|
wcstombs(szPerstName, apszPerstName[iCtx],
|
|
wcslen(apszPerstName[iCtx])+1);
|
|
_unlink (szPerstName);
|
|
|
|
if (m_punkObj[iCtx])
|
|
m_punkObj[iCtx]->Release();
|
|
|
|
if (m_pmkObj[iCtx])
|
|
m_pmkObj[iCtx]->Release();
|
|
}
|
|
|
|
|
|
UninitCOM();
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
SCODE CROTTest::Run ()
|
|
{
|
|
IRunningObjectTable *pROT = NULL;
|
|
CStopWatch sw;
|
|
SCODE sc;
|
|
|
|
|
|
// do the server side ROT operations.
|
|
// this makes sense only for inprocess objects.
|
|
|
|
ULONG iCtx=0;
|
|
{
|
|
// for each iteration
|
|
for (ULONG iIter=0; iIter<m_ulIterations; iIter++)
|
|
{
|
|
sw.Reset();
|
|
sc = GetRunningObjectTable(NULL, &pROT);
|
|
m_ulGetROTTime[iCtx][iIter] = sw.Read();
|
|
if (Log (TEXT("GetRunningObjectTable"), sc))
|
|
{
|
|
m_ulGetROTTime[iCtx][iIter] = NOTAVAIL;
|
|
}
|
|
|
|
DWORD dwRegister = 0;
|
|
|
|
sw.Reset();
|
|
sc = pROT->Register(0, m_punkObj[iCtx], m_pmkObj[iCtx], &dwRegister);
|
|
m_ulRegisterTime[iCtx][iIter] = sw.Read();
|
|
if (Log (TEXT("pROT->Register"), sc))
|
|
{
|
|
m_ulRegisterTime[iCtx][iIter] = NOTAVAIL;
|
|
}
|
|
|
|
|
|
FILETIME ft;
|
|
SYSTEMTIME st;
|
|
|
|
GetSystemTime(&st);
|
|
SystemTimeToFileTime(&st, &ft);
|
|
|
|
sw.Reset();
|
|
sc = pROT->NoteChangeTime(dwRegister, &ft);
|
|
m_ulNoteChangeTime[iCtx][iIter]=sw.Read ();
|
|
if (Log (TEXT("pROT->NoteChangeTime"), sc))
|
|
{
|
|
m_ulNoteChangeTime[iCtx][iIter] = NOTAVAIL;
|
|
}
|
|
|
|
|
|
sw.Reset();
|
|
sc = pROT->Revoke(dwRegister);
|
|
m_ulRevokeTime[iCtx][iIter] = sw.Read();
|
|
if (Log (TEXT("pROT->Revoke"), sc))
|
|
{
|
|
m_ulRevokeTime[iCtx][iIter] = NOTAVAIL;
|
|
}
|
|
|
|
|
|
sw.Reset();
|
|
pROT->Release();
|
|
m_ulReleaseTime[iCtx][iIter]=sw.Read ();
|
|
pROT = NULL;
|
|
if (Log (TEXT("pROT->Release"), sc))
|
|
{
|
|
m_ulReleaseTime[iCtx][iIter] = NOTAVAIL;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// do the client side ROT operations
|
|
// this makes sense for both class contexts
|
|
|
|
pROT = NULL;
|
|
sc = GetRunningObjectTable(NULL, &pROT);
|
|
if (Log (TEXT("GetRunningObjectTable"), sc))
|
|
{
|
|
return sc;
|
|
}
|
|
|
|
|
|
for (iCtx=0; iCtx<CNT_CLSCTX; iCtx++)
|
|
{
|
|
// put the object into the loaded state. this will cause it to
|
|
// register itself in the ROT.
|
|
IPersistFile *pIPF = NULL;
|
|
|
|
sc = m_punkObj[iCtx]->QueryInterface(IID_IPersistFile, (void **)&pIPF);
|
|
if (SUCCEEDED(sc))
|
|
{
|
|
pIPF->Load(apszPerstName[iCtx], STGM_READ | STGM_SHARE_DENY_NONE);
|
|
pIPF->Release();
|
|
}
|
|
|
|
// for each iteration
|
|
for (ULONG iIter=0; iIter<m_ulIterations; iIter++)
|
|
{
|
|
IEnumMoniker *pEnumMk = NULL;
|
|
|
|
sw.Reset();
|
|
sc = pROT->EnumRunning(&pEnumMk);
|
|
m_ulEnumRunningTime[iCtx][iIter] = sw.Read();
|
|
if (Log (TEXT("pROT->EnumRunning"), sc))
|
|
{
|
|
m_ulEnumRunningTime[iCtx][iIter] = NOTAVAIL;
|
|
}
|
|
|
|
if (pEnumMk)
|
|
{
|
|
pEnumMk->Release();
|
|
}
|
|
|
|
|
|
sw.Reset();
|
|
sc = pROT->IsRunning(m_pmkObj[iCtx]);
|
|
m_ulIsRunningTime[iCtx][iIter] = sw.Read();
|
|
if (Log (TEXT("pROT->IsRunning"), sc))
|
|
{
|
|
m_ulIsRunningTime[iCtx][iIter] = NOTAVAIL;
|
|
}
|
|
|
|
|
|
FILETIME ft;
|
|
|
|
sw.Reset();
|
|
sc = pROT->GetTimeOfLastChange(m_pmkObj[iCtx], &ft);
|
|
m_ulGetChangeTime[iCtx][iIter]=sw.Read ();
|
|
if (Log (TEXT("pROT->GetTimeOfLastChange"), sc))
|
|
{
|
|
m_ulGetChangeTime[iCtx][iIter] = NOTAVAIL;
|
|
}
|
|
|
|
|
|
IUnknown *pUnk = NULL;
|
|
|
|
sw.Reset();
|
|
sc = pROT->GetObject(m_pmkObj[iCtx], &pUnk);
|
|
m_ulGetObjectTime[iCtx][iIter]=sw.Read ();
|
|
if (Log (TEXT("pROT->GetObject"), sc))
|
|
{
|
|
m_ulGetObjectTime[iCtx][iIter] = NOTAVAIL;
|
|
}
|
|
|
|
if (pUnk)
|
|
{
|
|
pUnk->Release();
|
|
}
|
|
}
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
|
|
SCODE CROTTest::Report (CTestOutput &output)
|
|
{
|
|
output.WriteSectionHeader (Name(), TEXT("RunningObjectTable"), *m_pInput);
|
|
|
|
// write out the server side results
|
|
ULONG iCtx=0;
|
|
output.WriteString(TEXT("\nServer Side\n\n"));
|
|
output.WriteResults(TEXT("GetRunningObjTbl"), m_ulIterations, m_ulGetROTTime[iCtx]);
|
|
output.WriteResults(TEXT("Register "), m_ulIterations, m_ulRegisterTime[iCtx]);
|
|
output.WriteResults(TEXT("NoteChangeTime "), m_ulIterations, m_ulNoteChangeTime[iCtx]);
|
|
output.WriteResults(TEXT("Revoke "), m_ulIterations, m_ulRevokeTime[iCtx]);
|
|
output.WriteResults(TEXT("pROT->Release "), m_ulIterations, m_ulReleaseTime[iCtx]);
|
|
|
|
|
|
// write out the client side results
|
|
output.WriteString(TEXT("\nClient Side\n"));
|
|
|
|
// for each clsctx, write the results
|
|
for (iCtx=0; iCtx<CNT_CLSCTX; iCtx++)
|
|
{
|
|
output.WriteString(TEXT("\n"));
|
|
output.WriteClassID(&m_ClsID[iCtx]);
|
|
output.WriteString(apszClsCtx[iCtx]);
|
|
output.WriteString(TEXT("\n"));
|
|
|
|
output.WriteResults(TEXT("EnumRunning "), m_ulIterations, m_ulEnumRunningTime[iCtx]);
|
|
output.WriteResults(TEXT("IsRunning "), m_ulIterations, m_ulIsRunningTime[iCtx]);
|
|
output.WriteResults(TEXT("GetChangeTime "), m_ulIterations, m_ulGetChangeTime[iCtx]);
|
|
output.WriteResults(TEXT("GetObject "), m_ulIterations, m_ulGetObjectTime[iCtx]);
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|