5635 lines
162 KiB
C++
5635 lines
162 KiB
C++
// tmarsh.cxx : various tests related to marshalling...
|
||
//
|
||
#include <windows.h>
|
||
#include <ole2.h>
|
||
#include <stdio.h>
|
||
|
||
#include "tmarshal.h"
|
||
#include "tunk.h"
|
||
#include <iballs.h>
|
||
#include <icube.h>
|
||
#include <iloop.h>
|
||
#include <stream.hxx> // CStreamOnFile
|
||
#include <tstmain.hxx> // fQuiet
|
||
|
||
// BUGBUG: these should be in a public place somewhere.
|
||
DEFINE_OLEGUID(CLSID_Balls, 0x0000013a, 1, 8);
|
||
DEFINE_OLEGUID(CLSID_Cubes, 0x0000013b, 1, 8);
|
||
DEFINE_OLEGUID(CLSID_LoopSrv, 0x0000013c, 1, 8);
|
||
DEFINE_OLEGUID(CLSID_QI, 0x00000140, 0, 8);
|
||
DEFINE_OLEGUID(CLSID_QIHANDLER1, 0x00000141, 0, 8);
|
||
|
||
DEFINE_OLEGUID(IID_IInternalUnknown,0x00000021, 0, 0);
|
||
DEFINE_OLEGUID(IID_IStdIdentity, 0x0000001b, 0, 0);
|
||
DEFINE_OLEGUID(CLSID_OLEPSFACTORY, 0x00000320, 0, 0);
|
||
|
||
const GUID CLSID_LoopSrv =
|
||
{0x0000013c,0x0001,0x0008,{0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x46}};
|
||
|
||
// testsrv.exe
|
||
const GUID CLSID_TestEmbed =
|
||
{0x99999999,0x0000,0x0008,{0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x47}};
|
||
|
||
const GUID CLSID_Async =
|
||
{0x00000401,0x0000,0x0000,{0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x46}};
|
||
|
||
const GUID CLSID_QI =
|
||
{0x00000140,0x0000,0x0008,{0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x46}};
|
||
|
||
const GUID CLSID_QIHANDLER1 =
|
||
{0x00000141,0x0000,0x0008,{0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x46}};
|
||
|
||
//const GUID IID_IMultiQI =
|
||
// {0x00000020,0x0000,0x0000,{0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x46}};
|
||
|
||
const GUID IID_IInternalUnknown =
|
||
{0x00000021,0x0000,0x0000,{0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x46}};
|
||
|
||
const GUID IID_IStdIdentity =
|
||
{0x0000001b,0x0000,0x0000,{0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x46}};
|
||
|
||
const GUID CLSID_OLEPSFACTORY =
|
||
{0x00000320,0x0000,0x0000,{0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x46}};
|
||
|
||
extern "C" const GUID CLSID_TestEmbed;
|
||
|
||
|
||
// external functions
|
||
STDAPI_(LPSTREAM) CreateMemStm(DWORD cb, LPHANDLE phdl);
|
||
HRESULT VerifyOBJREFFormat(IStream *pStm, DWORD mshlflags);
|
||
DWORD _stdcall RundownClient(void *param);
|
||
|
||
// APIs exported by OLE32 but not in the header files.
|
||
STDAPI CoGetIIDFromMarshaledInterface(IStream *pStm, IID *piid);
|
||
|
||
|
||
// function prototypes - TRUE return means the test passed
|
||
BOOL TestMarshalFormat(void);
|
||
BOOL TestGetIIDFromMI(void);
|
||
BOOL TestLocalInterfaceNormal(void);
|
||
BOOL TestUnmarshalGUIDNULL(void);
|
||
BOOL TestUnmarshalDifferentIID(void);
|
||
BOOL TestUniqueQIPointer(void);
|
||
BOOL TestLocalInterfaceTableStrong(void);
|
||
BOOL TestLocalInterfaceTableWeak(void);
|
||
BOOL TestRemoteInterfaceNormal(void);
|
||
BOOL TestRemoteInterfaceTableStrong(void);
|
||
BOOL TestNoPing(void);
|
||
BOOL TestEcho(void);
|
||
BOOL TestMiddleMan(void);
|
||
BOOL TestLoop(void);
|
||
BOOL TestLockObjectExternal(void);
|
||
BOOL TestDisconnectObject(void);
|
||
BOOL TestHandler(void);
|
||
BOOL TestReleaseMarshalData(void);
|
||
BOOL TestCustomMarshalNormal(void);
|
||
BOOL TestCustomMarshalTable(void);
|
||
BOOL TestGetStandardMarshal(void);
|
||
BOOL TestLocalInterfaceDiffMachine(void);
|
||
BOOL TestRemoteInterfaceDiffMachine(void);
|
||
BOOL TestExpiredOXIDs(void);
|
||
BOOL TestNonNDRProxy(void);
|
||
BOOL TestTIDAndLID(void);
|
||
BOOL TestMarshalSizeMax(void);
|
||
BOOL TestMarshalStorage(void);
|
||
BOOL TestMultiQINormal(void);
|
||
BOOL TestMultiQIHandler(void);
|
||
BOOL TestCrossThread(void);
|
||
BOOL TestPSClsid(void);
|
||
BOOL TestPSClsid2(void);
|
||
|
||
BOOL TestAsync(void);
|
||
BOOL TestRundown(void);
|
||
BOOL TestAggregate(void);
|
||
BOOL TestCreateRemoteHandler(void);
|
||
BOOL TestStorageInterfaceDiffMachine(void);
|
||
|
||
|
||
WCHAR *pwszFileName[] = {L"c:\\mshlfile.1",
|
||
L"c:\\mshlfile.2",
|
||
L"c:\\mshlfile.3"};
|
||
|
||
|
||
|
||
|
||
// internal subroutines
|
||
void VerifyRHRefCnt(IUnknown *punk, ULONG ulExpectedRefCnt);
|
||
void VerifyObjRefCnt(IUnknown *punk, ULONG ulExpectedRefCnt);
|
||
|
||
TCHAR g_szIniFile[MAX_PATH];
|
||
|
||
|
||
// ----------------------------------------------------------------------
|
||
//
|
||
// TestMarshal - main test driver
|
||
//
|
||
// ----------------------------------------------------------------------
|
||
BOOL GetProfileValue(TCHAR *pszKeyName, int nDefault)
|
||
{
|
||
return (GetPrivateProfileInt(TEXT("Marshal Test"),
|
||
pszKeyName,
|
||
nDefault,
|
||
g_szIniFile));
|
||
}
|
||
|
||
// ----------------------------------------------------------------------
|
||
//
|
||
// TestMarshal - main test driver
|
||
//
|
||
// ----------------------------------------------------------------------
|
||
BOOL TestMarshal(void)
|
||
{
|
||
BOOL RetVal = TRUE;
|
||
|
||
// Get file name of .ini file, TMARSHAL.INI in the current directory
|
||
GetCurrentDirectory (MAX_PATH, g_szIniFile);
|
||
lstrcat(g_szIniFile, TEXT("\\TMARSHAL.INI"));
|
||
|
||
|
||
if (GetProfileValue(TEXT("Format"),1))
|
||
RetVal &= TestMarshalFormat();
|
||
|
||
if (GetProfileValue(TEXT("GetIIDFromMI"),1))
|
||
RetVal &= TestGetIIDFromMI();
|
||
|
||
if (GetProfileValue(TEXT("MarshalSizeMax"),1))
|
||
RetVal &= TestMarshalSizeMax();
|
||
|
||
if (GetProfileValue(TEXT("GetStandardMarshal"),1))
|
||
RetVal &= TestGetStandardMarshal();
|
||
|
||
if (GetProfileValue(TEXT("LocalInterfaceNormal"),1))
|
||
RetVal &= TestLocalInterfaceNormal();
|
||
|
||
if (GetProfileValue(TEXT("UniqueQIPointer"),1))
|
||
RetVal &= TestUniqueQIPointer();
|
||
|
||
if (GetProfileValue(TEXT("LocalInterfaceTableStrong"),1))
|
||
RetVal &= TestLocalInterfaceTableStrong();
|
||
|
||
if (GetProfileValue(TEXT("LocalInterfaceTableWeak"),1))
|
||
RetVal &= TestLocalInterfaceTableWeak();
|
||
|
||
if (GetProfileValue(TEXT("RemoteInterfaceNormal"),1))
|
||
RetVal &= TestRemoteInterfaceNormal();
|
||
|
||
if (GetProfileValue(TEXT("UnmarshalGUIDNULL"),1))
|
||
RetVal &= TestUnmarshalGUIDNULL();
|
||
|
||
if (GetProfileValue(TEXT("UnmarshalDifferentIID"),1))
|
||
RetVal &= TestUnmarshalDifferentIID();
|
||
|
||
if (GetProfileValue(TEXT("RemoteInterfaceTableStrong"),1))
|
||
RetVal &= TestRemoteInterfaceTableStrong();
|
||
|
||
if (GetProfileValue(TEXT("CrossThread"),1))
|
||
RetVal &= TestCrossThread();
|
||
|
||
if (GetProfileValue(TEXT("CustomMarshalNormal"),1))
|
||
RetVal &= TestCustomMarshalNormal();
|
||
|
||
if (GetProfileValue(TEXT("CustomMarshalTable"),1))
|
||
RetVal &= TestCustomMarshalTable();
|
||
|
||
if (GetProfileValue(TEXT("Echo"),1))
|
||
RetVal &= TestEcho();
|
||
|
||
if (GetProfileValue(TEXT("Loop"),1))
|
||
RetVal &= TestLoop();
|
||
|
||
if (GetProfileValue(TEXT("LockObjectExternal"),1))
|
||
RetVal &= TestLockObjectExternal();
|
||
|
||
if (GetProfileValue(TEXT("DisconnectObject"),1))
|
||
RetVal &= TestDisconnectObject();
|
||
|
||
if (GetProfileValue(TEXT("ReleaseMarshalData"),1))
|
||
RetVal &= TestReleaseMarshalData();
|
||
|
||
if (GetProfileValue(TEXT("MultiQINormal"),1))
|
||
RetVal &= TestMultiQINormal();
|
||
|
||
if (GetProfileValue(TEXT("MultiQIHandler"),1))
|
||
RetVal &= TestMultiQIHandler();
|
||
|
||
if (GetProfileValue(TEXT("Handler"),1))
|
||
RetVal &= TestHandler();
|
||
|
||
if (GetProfileValue(TEXT("MiddleMan"),1))
|
||
RetVal &= TestMiddleMan();
|
||
|
||
if (GetProfileValue(TEXT("MarshalStorage"),1))
|
||
RetVal &= TestMarshalStorage();
|
||
|
||
if (GetProfileValue(TEXT("LocalDiffMachine"),1))
|
||
RetVal &= TestLocalInterfaceDiffMachine();
|
||
|
||
if (GetProfileValue(TEXT("RemoteDiffMachine"),1))
|
||
RetVal &= TestRemoteInterfaceDiffMachine();
|
||
|
||
if (GetProfileValue(TEXT("ExpiredOXIDs"),1))
|
||
RetVal &= TestExpiredOXIDs();
|
||
|
||
if (GetProfileValue(TEXT("NonNDRProxy"),1))
|
||
RetVal &= TestNonNDRProxy();
|
||
|
||
if (GetProfileValue(TEXT("TIDAndLID"),1))
|
||
RetVal &= TestTIDAndLID();
|
||
|
||
if (GetProfileValue(TEXT("NoPing"),1))
|
||
RetVal &= TestNoPing();
|
||
|
||
if (GetProfileValue(TEXT("PSClsid"),1))
|
||
RetVal &= TestPSClsid();
|
||
|
||
if (GetProfileValue(TEXT("PSClsid2"),1))
|
||
RetVal &= TestPSClsid2();
|
||
|
||
// -------------------------------------------------------------------
|
||
|
||
if (GetProfileValue(TEXT("Rundown"),0))
|
||
RetVal &= TestRundown();
|
||
|
||
if (GetProfileValue(TEXT("Async"),0))
|
||
RetVal &= TestAsync();
|
||
|
||
if (GetProfileValue(TEXT("StorageDiffMachine"),0))
|
||
RetVal &= TestStorageInterfaceDiffMachine();
|
||
|
||
if (GetProfileValue(TEXT("Aggregate"),0))
|
||
RetVal &= TestAggregate();
|
||
|
||
if (GetProfileValue(TEXT("CreateRemoteHandler"),0))
|
||
RetVal &= TestCreateRemoteHandler();
|
||
|
||
return RetVal;
|
||
}
|
||
|
||
// ----------------------------------------------------------------------
|
||
//
|
||
// subroutine to verify that the RH RefCnt is as expected.
|
||
//
|
||
// ----------------------------------------------------------------------
|
||
|
||
typedef IMarshal * (* PFNDBG_FINDRH)(IUnknown *punk);
|
||
PFNDBG_FINDRH gpfnFindRH = NULL;
|
||
|
||
HMODULE ghOle32Dll = NULL;
|
||
BOOL gfTriedToLoad = FALSE;
|
||
|
||
|
||
void LoadProc()
|
||
{
|
||
if (!gfTriedToLoad)
|
||
{
|
||
gfTriedToLoad = TRUE;
|
||
|
||
ghOle32Dll = LoadLibrary(TEXT("OLE32.DLL"));
|
||
if (ghOle32Dll)
|
||
{
|
||
gpfnFindRH = (PFNDBG_FINDRH) GetProcAddress(ghOle32Dll,
|
||
"Dbg_FindRemoteHdlr");
|
||
}
|
||
}
|
||
}
|
||
|
||
void FreeProc()
|
||
{
|
||
if (ghOle32Dll)
|
||
{
|
||
FreeLibrary(ghOle32Dll);
|
||
}
|
||
}
|
||
|
||
// ----------------------------------------------------------------------
|
||
//
|
||
// subroutine to verify that the RH RefCnt is as expected.
|
||
//
|
||
// ----------------------------------------------------------------------
|
||
|
||
void VerifyRHRefCnt(IUnknown *punk, ULONG ulExpectedRefCnt)
|
||
{
|
||
if (gpfnFindRH == NULL)
|
||
{
|
||
LoadProc();
|
||
}
|
||
|
||
if (gpfnFindRH)
|
||
{
|
||
// this function is internal to COMPOBJ marshalling.
|
||
IMarshal *pIM = (gpfnFindRH)(punk);
|
||
if (pIM == NULL)
|
||
{
|
||
if (ulExpectedRefCnt != 0)
|
||
printf ("ERROR: RH RefCnt 0, expected=%x\n", ulExpectedRefCnt);
|
||
return;
|
||
}
|
||
|
||
ULONG ulRefCnt = pIM->Release();
|
||
if (ulRefCnt != ulExpectedRefCnt)
|
||
{
|
||
printf ("ERROR: RH RefCnt=%x, expected=%x\n", ulRefCnt, ulExpectedRefCnt);
|
||
}
|
||
}
|
||
}
|
||
|
||
// ----------------------------------------------------------------------
|
||
//
|
||
// subroutine to verify that the Object RefCnt is as expected.
|
||
//
|
||
// ----------------------------------------------------------------------
|
||
|
||
void VerifyObjRefCnt(IUnknown *punk, ULONG ulExpectedRefCnt)
|
||
{
|
||
if (ulExpectedRefCnt == 0)
|
||
return; // cant verify this
|
||
|
||
//#if DBG==1
|
||
// this function is internal to COMPOBJ marshalling.
|
||
punk->AddRef();
|
||
ULONG ulRefCnt = punk->Release();
|
||
if (ulRefCnt != ulExpectedRefCnt)
|
||
{
|
||
printf ("ERROR: Object RefCnt=%x, expected=%x\n", ulRefCnt, ulExpectedRefCnt);
|
||
}
|
||
//#endif
|
||
}
|
||
|
||
|
||
// ----------------------------------------------------------------------
|
||
//
|
||
// MarshalAndRead
|
||
//
|
||
// ----------------------------------------------------------------------
|
||
HRESULT MarshalAndRead(IUnknown *punkIn, BYTE *pbuf, ULONG *pulSize)
|
||
{
|
||
BOOL RetVal = TRUE;
|
||
HRESULT hres;
|
||
|
||
ULARGE_INTEGER ulSeekEnd;
|
||
LARGE_INTEGER lSeekStart;
|
||
LISet32(lSeekStart, 0);
|
||
|
||
IStream *pStm = CreateMemStm(600, NULL);
|
||
TEST_FAILED_EXIT((pStm == NULL), "CreateMemStm failed\n")
|
||
VerifyObjRefCnt((IUnknown *)pStm, 1);
|
||
|
||
hres = CoMarshalInterface(pStm, IID_IUnknown, punkIn, 0, NULL, MSHLFLAGS_NORMAL);
|
||
TEST_FAILED_EXIT(FAILED(hres), "CoMarshalInterface failed\n")
|
||
OUTPUT (" - CoMarshalInterface OK\n");
|
||
|
||
// get current seek position
|
||
hres = pStm->Seek(lSeekStart, STREAM_SEEK_CUR, &ulSeekEnd);
|
||
TEST_FAILED_EXIT(FAILED(hres), "Seek on shared stream failed\n")
|
||
OUTPUT (" - Seek Current OK\n");
|
||
|
||
// go back to begining
|
||
hres = pStm->Seek(lSeekStart, STREAM_SEEK_SET, NULL);
|
||
TEST_FAILED_EXIT(FAILED(hres), "Seek on shared stream failed\n")
|
||
OUTPUT (" - Seek Start OK\n");
|
||
|
||
// read in the data
|
||
hres = pStm->Read(pbuf ,ulSeekEnd.LowPart, pulSize);
|
||
TEST_FAILED_EXIT(FAILED(hres), "Read on stream failed\n")
|
||
OUTPUT (" - Read OK\n");
|
||
|
||
Cleanup:
|
||
|
||
// release the stream
|
||
pStm->Release();
|
||
|
||
if (RetVal == TRUE)
|
||
return S_OK;
|
||
else
|
||
return hres;
|
||
}
|
||
|
||
// ----------------------------------------------------------------------
|
||
//
|
||
// GetTestUnk - return an inproc IUnknown ptr.
|
||
//
|
||
// ----------------------------------------------------------------------
|
||
IUnknown *GetTestUnk()
|
||
{
|
||
IUnknown *punkIn = (IUnknown *)(IParseDisplayName *) new CTestUnk();
|
||
return punkIn;
|
||
}
|
||
|
||
|
||
// ----------------------------------------------------------------------
|
||
//
|
||
// RunThread - runs a thread and waits for it to complete
|
||
//
|
||
// ----------------------------------------------------------------------
|
||
void RunThread(void *param, HANDLE hEvent, LPTHREAD_START_ROUTINE pfn)
|
||
{
|
||
DWORD dwThrdId;
|
||
HANDLE hThrd = CreateThread(NULL, 0, pfn, param, 0, &dwThrdId);
|
||
|
||
if (hThrd)
|
||
{
|
||
if (gInitFlag == COINIT_APARTMENTTHREADED)
|
||
{
|
||
// enter a message pump to accept incoming calls from the
|
||
// other thread.
|
||
|
||
MSG msg;
|
||
while (GetMessage(&msg, NULL, 0, 0))
|
||
{
|
||
DispatchMessage(&msg);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
// wait for the other thread to run to completion
|
||
WaitForSingleObject(hEvent, 0xffffffff);
|
||
}
|
||
|
||
// close the thread handle
|
||
CloseHandle(hThrd);
|
||
}
|
||
}
|
||
|
||
|
||
// ----------------------------------------------------------------------
|
||
//
|
||
// TestAsync
|
||
//
|
||
// ----------------------------------------------------------------------
|
||
BOOL TestAsync(void)
|
||
{
|
||
BOOL RetVal = TRUE;
|
||
HRESULT hRes = S_OK;
|
||
ULONG ulRefCnt = 0;
|
||
IUnknown *pUnkSrv = NULL;
|
||
IAdviseSink *pAdvSnk = NULL;
|
||
|
||
OUTPUT ("Starting TestAsync\n");
|
||
|
||
// create our interface to pass to the remote object.
|
||
hRes = CoCreateInstance(CLSID_Async, NULL, CLSCTX_LOCAL_SERVER,
|
||
IID_IUnknown, (void **)&pUnkSrv);
|
||
TEST_FAILED_EXIT(FAILED(hRes), "CoCreateInstance First failed\n")
|
||
|
||
OUTPUT (" - QI for IAdviseSink\n");
|
||
hRes = pUnkSrv->QueryInterface(IID_IAdviseSink, (void **)&pAdvSnk);
|
||
TEST_FAILED_EXIT(FAILED(hRes), "QI for IAdviseSink failed\n")
|
||
|
||
// now call on the IAdviseSink Interface
|
||
pAdvSnk->OnSave();
|
||
|
||
Sleep(30);
|
||
|
||
// release the interface
|
||
pAdvSnk->Release();
|
||
pAdvSnk = NULL;
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
Cleanup:
|
||
|
||
OUTPUT (" - Test Complete. Doing Cleanup\n");
|
||
|
||
// Dump interfaces we are done with
|
||
if (pAdvSnk)
|
||
{
|
||
ulRefCnt = pAdvSnk->Release();
|
||
TEST_FAILED(ulRefCnt != 1, "pAdvSnk RefCnt not zero\n");
|
||
}
|
||
|
||
if (pUnkSrv)
|
||
{
|
||
ulRefCnt = pUnkSrv->Release();
|
||
TEST_FAILED(ulRefCnt != 0, "PunkSrv RefCnt not zero\n");
|
||
}
|
||
|
||
return TestResult(RetVal, "TestAsync");
|
||
}
|
||
|
||
|
||
// ----------------------------------------------------------------------
|
||
//
|
||
// test marshal format
|
||
//
|
||
// ----------------------------------------------------------------------
|
||
BOOL TestMarshalFormat(void)
|
||
{
|
||
BOOL RetVal = TRUE;
|
||
BOOL fSame = TRUE;
|
||
HRESULT hres;
|
||
ULONG ulRefCnt = 0;
|
||
IUnknown *punkIn = NULL;
|
||
BYTE buf1[600];
|
||
BYTE buf2[600];
|
||
ULONG ulSize1 = sizeof(buf1);
|
||
ULONG ulSize2 = sizeof(buf2);
|
||
|
||
OUTPUT ("Starting TestMarshalFormat\n");
|
||
|
||
punkIn = GetTestUnk();
|
||
TEST_FAILED_EXIT((punkIn == NULL), "new CTestUnk failed\n")
|
||
VerifyObjRefCnt(punkIn, 1);
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
hres = MarshalAndRead(punkIn, buf1, &ulSize1);
|
||
TEST_FAILED_EXIT(FAILED(hres), "MarshalAndRead failed\n")
|
||
OUTPUT (" - First MarshalAndRead OK\n");
|
||
|
||
hres = MarshalAndRead(punkIn, buf2, &ulSize2);
|
||
TEST_FAILED_EXIT(FAILED(hres), "MarshalAndRead failed\n")
|
||
OUTPUT (" - Second MarshalAndRead OK\n");
|
||
|
||
TEST_FAILED_EXIT((ulSize1 != ulSize2), "Buffer Sizes Differ\n")
|
||
fSame = !memcmp(buf1, buf2, ulSize1);
|
||
|
||
TEST_FAILED_EXIT(!fSame, "Buffer Contents Differ\n")
|
||
OUTPUT (" - Buffers Compare OK\n");
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
Cleanup:
|
||
|
||
OUTPUT (" - Test Complete. Doing Cleanup\n");
|
||
|
||
CoDisconnectObject(punkIn,0);
|
||
|
||
if (punkIn)
|
||
{
|
||
ulRefCnt = punkIn->Release();
|
||
TEST_FAILED(ulRefCnt != 0, "punkIn RefCnt not zero\n");
|
||
}
|
||
|
||
return TestResult(RetVal, "TestMarshalFormat");
|
||
}
|
||
|
||
|
||
// ----------------------------------------------------------------------
|
||
//
|
||
// test CoGetMarshalSizeMax
|
||
//
|
||
// ----------------------------------------------------------------------
|
||
BOOL TestMarshalSizeMax(void)
|
||
{
|
||
BOOL RetVal = TRUE;
|
||
HRESULT hres;
|
||
ULONG ulRefCnt = 0;
|
||
IUnknown *punkIn = NULL;
|
||
ULONG ulSize = 0;
|
||
|
||
OUTPUT ("Starting TestMarshalSizeMax\n");
|
||
|
||
punkIn = GetTestUnk();
|
||
TEST_FAILED_EXIT((punkIn == NULL), "new CTestUnk failed\n")
|
||
VerifyObjRefCnt(punkIn, 1);
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
hres = CoGetMarshalSizeMax(&ulSize, IID_IUnknown, punkIn, 0, NULL, MSHLFLAGS_NORMAL);
|
||
TEST_FAILED_EXIT(FAILED(hres), "CoGetMarshalSizeMax failed\n")
|
||
VerifyRHRefCnt(punkIn, 0);
|
||
OUTPUT (" - CoGetMarshalSizeMax OK\n");
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
Cleanup:
|
||
|
||
OUTPUT (" - Test Complete. Doing Cleanup\n");
|
||
if (punkIn)
|
||
{
|
||
punkIn->Release();
|
||
punkIn = NULL;
|
||
}
|
||
|
||
return TestResult(RetVal, "TestMarshalSizeMax");
|
||
}
|
||
|
||
|
||
// ----------------------------------------------------------------------
|
||
//
|
||
// test LOCAL interface MSHLFLAGS_NORMAL
|
||
//
|
||
// ----------------------------------------------------------------------
|
||
|
||
BOOL TestLocalInterfaceNormal(void)
|
||
{
|
||
BOOL RetVal = TRUE;
|
||
HRESULT hres;
|
||
LPSTREAM pStm = NULL;
|
||
ULONG ulRefCnt = 0;
|
||
IUnknown *punkIn = NULL;
|
||
IUnknown *punkOut = NULL;
|
||
IUnknown *punkOut2 = NULL;
|
||
|
||
LARGE_INTEGER large_int;
|
||
LISet32(large_int, 0);
|
||
|
||
OUTPUT ("Starting TestLocalInterfaceNormal\n");
|
||
|
||
punkIn = GetTestUnk();
|
||
TEST_FAILED_EXIT((punkIn == NULL), "new CTestUnk failed\n")
|
||
VerifyObjRefCnt(punkIn, 1);
|
||
|
||
pStm = CreateMemStm(600, NULL);
|
||
TEST_FAILED_EXIT((pStm == NULL), "CreateMemStm failed\n")
|
||
VerifyObjRefCnt((IUnknown *)pStm, 1);
|
||
|
||
// ----------------------------------------------------------------------
|
||
hres = CoMarshalInterface(pStm, IID_IUnknown, punkIn, 0, NULL, MSHLFLAGS_NORMAL);
|
||
TEST_FAILED_EXIT(FAILED(hres), "CoMarshalInterface failed\n")
|
||
VerifyRHRefCnt(punkIn, 1);
|
||
OUTPUT (" - CoMarshalInterface OK\n");
|
||
|
||
hres = pStm->Seek(large_int, STREAM_SEEK_SET, NULL);
|
||
TEST_FAILED_EXIT(FAILED(hres), "Seek on shared stream failed\n")
|
||
|
||
// since we are unmarshalling in the same process, the RH should go away.
|
||
hres = CoUnmarshalInterface(pStm, IID_IUnknown, (LPVOID FAR*)&punkOut);
|
||
TEST_FAILED_EXIT(FAILED(hres), "CoUnmarshalInterface failed\n")
|
||
VerifyRHRefCnt(punkIn, 0);
|
||
VerifyObjRefCnt(punkIn, 2);
|
||
|
||
// make sure the interface pointers are identical
|
||
if (punkIn != punkOut)
|
||
TEST_FAILED_EXIT(TRUE, "Interface ptrs dont match...1st Local Unmarshal\n")
|
||
OUTPUT (" - CoUnmarshalInterface OK\n");
|
||
|
||
// release it and make sure it does not go away - refcnt > 0
|
||
ulRefCnt = punkOut->Release();
|
||
TEST_FAILED_EXIT(ulRefCnt == 0, "punkOut RefCnt is zero");
|
||
punkOut = NULL;
|
||
OUTPUT (" - Release OK\n");
|
||
|
||
// the RH should have gone away, and we should have only the original
|
||
// refcnt from creation left on the object.
|
||
VerifyObjRefCnt(punkIn, 1);
|
||
|
||
// ----------------------------------------------------------------------
|
||
#if 0
|
||
// this test disabled for DCOM since we no longer write into the stream
|
||
// to mark the thing as having been unmarshaled. This lets unmarshals
|
||
// work with read-only streams.
|
||
|
||
|
||
// test unmarshalling twice. this should fail since we did marshal
|
||
// flags normal and already unmarshalled it once.
|
||
|
||
hres = pStm->Seek(large_int, STREAM_SEEK_SET, NULL);
|
||
TEST_FAILED_EXIT(FAILED(hres), "Seek on shared stream failed\n")
|
||
|
||
hres = CoUnmarshalInterface(pStm, IID_IUnknown, (LPVOID FAR*)&punkOut2);
|
||
TEST_FAILED_EXIT(SUCCEEDED(hres), "CoUnmarshalInterface second time succeeded but should have failed\n")
|
||
OUTPUT (" - Second CoUnmarshalInterface OK\n");
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
// CoReleaseMarshalData should fail because Unmarshall already called it.
|
||
hres = pStm->Seek(large_int, STREAM_SEEK_SET, NULL);
|
||
TEST_FAILED_EXIT(FAILED(hres), "Seek on shared stream failed\n")
|
||
|
||
hres = CoReleaseMarshalData(pStm);
|
||
TEST_FAILED_EXIT(SUCCEEDED(hres), "CoReleaseMarshalData succeeded but should have failed.\n")
|
||
OUTPUT (" - CoReleaseMarshalData OK\n");
|
||
|
||
#endif
|
||
// ----------------------------------------------------------------------
|
||
|
||
// marshal again and try CoRelease without having first done an
|
||
// unmarshal. this should work.
|
||
hres = pStm->Seek(large_int, STREAM_SEEK_SET, NULL);
|
||
TEST_FAILED_EXIT(FAILED(hres), "Seek on shared stream failed\n")
|
||
|
||
hres = CoMarshalInterface(pStm, IID_IUnknown, punkIn, 0, NULL, MSHLFLAGS_NORMAL);
|
||
TEST_FAILED_EXIT(FAILED(hres), "CoMarshalInterface failed\n")
|
||
OUTPUT (" - CoMarshalInterface OK\n");
|
||
VerifyRHRefCnt(punkIn, 1);
|
||
|
||
hres = pStm->Seek(large_int, STREAM_SEEK_SET, NULL);
|
||
TEST_FAILED_EXIT(FAILED(hres), "Seek on shared stream failed\n")
|
||
|
||
hres = CoReleaseMarshalData(pStm);
|
||
TEST_FAILED_EXIT(FAILED(hres), "CoReleaseMarshalData failed.\n")
|
||
VerifyRHRefCnt(punkIn, 0);
|
||
VerifyObjRefCnt(punkIn, 1);
|
||
OUTPUT (" - CoReleaseMarshalData OK\n");
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
// release the object and try to unmarshal it again. Should fail
|
||
// since the object has gone away.
|
||
|
||
ulRefCnt = punkIn->Release();
|
||
TEST_FAILED_EXIT(ulRefCnt != 0, "punkOut RefCnt not zero\n");
|
||
punkIn = NULL;
|
||
|
||
// go back to start of stream
|
||
hres = pStm->Seek(large_int, STREAM_SEEK_SET, NULL);
|
||
TEST_FAILED_EXIT(FAILED(hres), "Seek on shared stream failed\n")
|
||
|
||
hres = CoUnmarshalInterface(pStm, IID_IUnknown, (LPVOID FAR*)&punkOut);
|
||
TEST_FAILED_EXIT(SUCCEEDED(hres), "CoUnmarshalInterface should have failed\n")
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
Cleanup:
|
||
|
||
OUTPUT (" - Test Complete. Doing Cleanup\n");
|
||
|
||
// Dump interfaces we are done with
|
||
if (pStm)
|
||
{
|
||
ulRefCnt = pStm->Release();
|
||
TEST_FAILED(ulRefCnt != 0, "Stream RefCnt not zero\n");
|
||
}
|
||
|
||
if (punkOut)
|
||
{
|
||
ulRefCnt = punkOut->Release();
|
||
TEST_FAILED(ulRefCnt != 0, "punkOut RefCnt not zero\n");
|
||
}
|
||
|
||
if (punkOut2)
|
||
{
|
||
ulRefCnt = punkOut2->Release();
|
||
TEST_FAILED(ulRefCnt != 0, "punkOut2 RefCnt not zero\n");
|
||
}
|
||
|
||
if (punkIn)
|
||
{
|
||
ulRefCnt = punkIn->Release();
|
||
TEST_FAILED(ulRefCnt != 0, "punkIn RefCnt not zero\n");
|
||
}
|
||
|
||
return TestResult(RetVal, "TestLocalInterfaceNormal");
|
||
}
|
||
|
||
|
||
// ----------------------------------------------------------------------
|
||
//
|
||
// test LOCAL interface MSHLFLAGS_NORMAL when the object returns a
|
||
// differnt interface pointer on each subsequent QI for the same
|
||
// interface
|
||
//
|
||
// ----------------------------------------------------------------------
|
||
BOOL TestUniqueQIPointer(void)
|
||
{
|
||
BOOL RetVal = TRUE;
|
||
HRESULT hres;
|
||
LPSTREAM pStm = NULL;
|
||
ULONG ulRefCnt = 0;
|
||
IUnknown *punkIn = NULL;
|
||
IUnknown *punkOut = NULL;
|
||
ICube *pCubeIn = NULL;
|
||
ICube *pCubeOut = NULL;
|
||
|
||
LARGE_INTEGER large_int;
|
||
LISet32(large_int, 0);
|
||
|
||
OUTPUT ("Starting TestUniqueQIPointer\n");
|
||
|
||
punkIn = GetTestUnk();
|
||
TEST_FAILED_EXIT((punkIn == NULL), "new CTestUnk failed\n")
|
||
VerifyObjRefCnt(punkIn, 1);
|
||
|
||
hres = punkIn->QueryInterface(IID_ICube, (void **)&pCubeIn);
|
||
TEST_FAILED_EXIT((pCubeIn == NULL), "QI for IID_ICube failed\n")
|
||
VerifyObjRefCnt(punkIn, 2);
|
||
|
||
pStm = CreateMemStm(600, NULL);
|
||
TEST_FAILED_EXIT((pStm == NULL), "CreateMemStm failed\n")
|
||
VerifyObjRefCnt((IUnknown *)pStm, 1);
|
||
|
||
// ----------------------------------------------------------------------
|
||
hres = CoMarshalInterface(pStm, IID_ICube, pCubeIn, 0, NULL, MSHLFLAGS_NORMAL);
|
||
TEST_FAILED_EXIT(FAILED(hres), "CoMarshalInterface failed\n")
|
||
VerifyRHRefCnt(pCubeIn, 1);
|
||
OUTPUT (" - CoMarshalInterface OK\n");
|
||
|
||
hres = pStm->Seek(large_int, STREAM_SEEK_SET, NULL);
|
||
TEST_FAILED_EXIT(FAILED(hres), "Seek on shared stream failed\n")
|
||
|
||
// since we are unmarshalling in the same process, the RH should go away.
|
||
hres = CoUnmarshalInterface(pStm, IID_ICube, (LPVOID FAR*)&pCubeOut);
|
||
TEST_FAILED_EXIT(FAILED(hres), "CoUnmarshalInterface failed\n")
|
||
VerifyRHRefCnt(pCubeIn, 0);
|
||
VerifyRHRefCnt(pCubeOut, 0);
|
||
VerifyRHRefCnt(punkIn, 0);
|
||
|
||
VerifyObjRefCnt(pCubeIn, 1);
|
||
VerifyObjRefCnt(pCubeOut, 1);
|
||
VerifyObjRefCnt(punkIn, 3);
|
||
|
||
// make sure the Ctrl Unknown interface pointers are identical
|
||
hres = pCubeOut->QueryInterface(IID_IUnknown, (void **)&punkOut);
|
||
TEST_FAILED_EXIT((punkOut == NULL), "QI for IID_IUnknown failed\n")
|
||
VerifyObjRefCnt(punkOut, 4);
|
||
|
||
if (punkIn != punkOut)
|
||
TEST_FAILED_EXIT(TRUE, "Interface ptrs dont match...1st Local Unmarshal\n")
|
||
OUTPUT (" - CoUnmarshalInterface OK\n");
|
||
|
||
// attempt a call on the in interface pointer.
|
||
hres = pCubeIn->MoveCube(0,0);
|
||
TEST_FAILED_EXIT(FAILED(hres), "pCubeIn->MoveCube failed\n")
|
||
|
||
// release the in-pointer
|
||
ulRefCnt = pCubeIn->Release();
|
||
TEST_FAILED(ulRefCnt != 0, "pCubeIn RefCnt not zero\n");
|
||
pCubeIn = NULL;
|
||
|
||
// now call on the out interface pointer
|
||
hres = pCubeOut->MoveCube(0,0);
|
||
TEST_FAILED_EXIT(FAILED(hres), "pCubeOut->MoveCube failed\n")
|
||
|
||
// release the out-pointer
|
||
ulRefCnt = pCubeOut->Release();
|
||
TEST_FAILED(ulRefCnt != 0, "pCubeOut RefCnt not zero\n");
|
||
pCubeOut = NULL;
|
||
|
||
|
||
Cleanup:
|
||
|
||
OUTPUT (" - Test Complete. Doing Cleanup\n");
|
||
|
||
// Dump interfaces we are done with
|
||
if (pStm)
|
||
{
|
||
ulRefCnt = pStm->Release();
|
||
TEST_FAILED(ulRefCnt != 0, "Stream RefCnt not zero\n");
|
||
}
|
||
|
||
if (pCubeIn)
|
||
{
|
||
ulRefCnt = pCubeIn->Release();
|
||
TEST_FAILED(ulRefCnt != 0, "pCubeIn RefCnt not zero\n");
|
||
}
|
||
|
||
if (pCubeOut)
|
||
{
|
||
ulRefCnt = pCubeOut->Release();
|
||
TEST_FAILED(ulRefCnt != 0, "pCubeOut RefCnt not zero\n");
|
||
}
|
||
|
||
if (punkOut)
|
||
{
|
||
ulRefCnt = punkOut->Release();
|
||
TEST_FAILED(ulRefCnt == 0, "punkOut RefCnt not zero\n");
|
||
}
|
||
|
||
if (punkIn)
|
||
{
|
||
ulRefCnt = punkIn->Release();
|
||
TEST_FAILED(ulRefCnt != 0, "punkIn RefCnt not zero\n");
|
||
}
|
||
|
||
return TestResult(RetVal, "TestUniqueQIPointer");
|
||
}
|
||
|
||
|
||
|
||
// ----------------------------------------------------------------------
|
||
//
|
||
// test LOCAL interface MSHLFLAGS_TABLESTRONG
|
||
//
|
||
// ----------------------------------------------------------------------
|
||
|
||
BOOL TestLocalInterfaceTableStrong(void)
|
||
{
|
||
BOOL RetVal = TRUE;
|
||
HRESULT hres;
|
||
LPSTREAM pStm = NULL;
|
||
ULONG ulRefCnt = 0;
|
||
IUnknown *punkIn = NULL;
|
||
IUnknown *punkOut = NULL;
|
||
IUnknown *punkOut2 = NULL;
|
||
|
||
LARGE_INTEGER large_int;
|
||
LISet32(large_int, 0);
|
||
|
||
OUTPUT ("Starting TestLocalInterfaceTableStrong\n");
|
||
|
||
punkIn = GetTestUnk();
|
||
TEST_FAILED_EXIT((punkIn == NULL), "new CTestUnk failed\n")
|
||
VerifyObjRefCnt(punkIn, 1);
|
||
|
||
pStm = CreateMemStm(600, NULL);
|
||
TEST_FAILED_EXIT((pStm == NULL), "CreateMemStm failed\n")
|
||
VerifyObjRefCnt((IUnknown *)pStm, 1);
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
hres = CoMarshalInterface(pStm, IID_IUnknown, punkIn, 0, NULL, MSHLFLAGS_TABLESTRONG);
|
||
TEST_FAILED_EXIT(FAILED(hres), "CoMarshalInterface failed\n")
|
||
VerifyRHRefCnt(punkIn, 1);
|
||
OUTPUT (" - CoMarshalInterface OK\n");
|
||
|
||
hres = pStm->Seek(large_int, STREAM_SEEK_SET, NULL);
|
||
TEST_FAILED_EXIT(FAILED(hres), "Seek on shared stream failed\n")
|
||
|
||
// unmarshalling should leave the RH intact, as it is marshalled for TABLE.
|
||
hres = CoUnmarshalInterface(pStm, IID_IUnknown, (LPVOID FAR*)&punkOut);
|
||
TEST_FAILED_EXIT(FAILED(hres), "CoUnmarshalInterface failed\n")
|
||
VerifyRHRefCnt(punkIn, 1);
|
||
|
||
// make sure the interface pointers are identical
|
||
if (punkIn != punkOut)
|
||
TEST_FAILED_EXIT(TRUE, "Interface ptrs dont match...1st Local Unmarshal\n")
|
||
OUTPUT (" - CoUnmarshalInterface OK\n");
|
||
|
||
// release it and make sure it does not go away - refcnt > 0
|
||
ulRefCnt = punkOut->Release();
|
||
TEST_FAILED_EXIT(ulRefCnt == 0, "punkOut RefCnt is zero");
|
||
punkOut = NULL;
|
||
VerifyRHRefCnt(punkIn, 1);
|
||
OUTPUT (" - Release OK\n");
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
// test unmarshalling twice - should work since we used flags table
|
||
hres = pStm->Seek(large_int, STREAM_SEEK_SET, NULL);
|
||
TEST_FAILED_EXIT(FAILED(hres), "Seek on shared stream failed\n")
|
||
|
||
hres = CoUnmarshalInterface(pStm, IID_IUnknown, (LPVOID FAR*)&punkOut2);
|
||
TEST_FAILED_EXIT(FAILED(hres), "CoUnmarshalInterface second time succeeded but should have failed\n")
|
||
VerifyRHRefCnt(punkIn, 1);
|
||
OUTPUT (" - Second CoUnmarshalInterface OK\n");
|
||
|
||
// release it and make sure it does not go away - refcnt > 0
|
||
ulRefCnt = punkOut2->Release();
|
||
TEST_FAILED_EXIT(ulRefCnt == 0, "punkOut2 RefCnt is zero");
|
||
punkOut2 = NULL;
|
||
VerifyRHRefCnt(punkIn, 1);
|
||
OUTPUT (" - Release OK\n");
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
// CoReleaseMarshalData should release the marshalled data TABLESTRONG
|
||
hres = pStm->Seek(large_int, STREAM_SEEK_SET, NULL);
|
||
TEST_FAILED_EXIT(FAILED(hres), "Seek on shared stream failed\n")
|
||
|
||
hres = CoReleaseMarshalData(pStm);
|
||
TEST_FAILED_EXIT(FAILED(hres), "CoReleaseMarshalData failed.\n")
|
||
VerifyRHRefCnt(punkIn, 0);
|
||
OUTPUT (" - CoReleaseMarshalData OK\n");
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
Cleanup:
|
||
|
||
OUTPUT (" - Test Complete. Doing Cleanup\n");
|
||
|
||
// Dump interfaces we are done with
|
||
if (pStm)
|
||
{
|
||
ulRefCnt = pStm->Release();
|
||
TEST_FAILED(ulRefCnt != 0, "Stream RefCnt not zero\n");
|
||
}
|
||
|
||
if (punkOut)
|
||
{
|
||
ulRefCnt = punkOut->Release();
|
||
TEST_FAILED(ulRefCnt != 0, "punkOut RefCnt not zero\n");
|
||
}
|
||
|
||
if (punkOut2)
|
||
{
|
||
ulRefCnt = punkOut2->Release();
|
||
TEST_FAILED(ulRefCnt != 0, "punkOut2 RefCnt not zero\n");
|
||
}
|
||
|
||
if (punkIn)
|
||
{
|
||
ulRefCnt = punkIn->Release();
|
||
TEST_FAILED(ulRefCnt != 0, "punkIn RefCnt not zero\n");
|
||
}
|
||
|
||
return TestResult(RetVal, "TestLocalInterfaceTableStrong");
|
||
}
|
||
|
||
|
||
// ----------------------------------------------------------------------
|
||
//
|
||
// test LOCAL interface MSHLFLAGS_TABLEWEAK
|
||
//
|
||
// ----------------------------------------------------------------------
|
||
|
||
BOOL TestLocalInterfaceTableWeak(void)
|
||
{
|
||
BOOL RetVal = TRUE;
|
||
HRESULT hres;
|
||
LPSTREAM pStm = NULL;
|
||
ULONG ulRefCnt = 0;
|
||
IUnknown *punkIn = NULL;
|
||
IUnknown *punkOut = NULL;
|
||
IUnknown *punkOut2 = NULL;
|
||
|
||
LARGE_INTEGER large_int;
|
||
LISet32(large_int, 0);
|
||
|
||
OUTPUT ("Starting TestLocalInterfaceTableWeak\n");
|
||
|
||
punkIn = GetTestUnk();
|
||
TEST_FAILED_EXIT((punkIn == NULL), "new CTestUnk failed\n")
|
||
VerifyObjRefCnt(punkIn, 1);
|
||
|
||
pStm = CreateMemStm(600, NULL);
|
||
TEST_FAILED_EXIT((pStm == NULL), "CreateMemStm failed\n")
|
||
VerifyObjRefCnt((IUnknown *)pStm, 1);
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
hres = CoMarshalInterface(pStm, IID_IParseDisplayName, punkIn, 0, NULL, MSHLFLAGS_TABLEWEAK);
|
||
TEST_FAILED_EXIT(FAILED(hres), "CoMarshalInterface failed\n")
|
||
VerifyRHRefCnt(punkIn, 1);
|
||
OUTPUT (" - CoMarshalInterface OK\n");
|
||
|
||
hres = pStm->Seek(large_int, STREAM_SEEK_SET, NULL);
|
||
TEST_FAILED_EXIT(FAILED(hres), "Seek on shared stream failed\n")
|
||
|
||
// unmarshalling should leave the RH intact, as it is marshalled for TABLE.
|
||
hres = CoUnmarshalInterface(pStm, IID_IParseDisplayName, (LPVOID FAR*)&punkOut);
|
||
TEST_FAILED_EXIT(FAILED(hres), "CoUnmarshalInterface failed\n")
|
||
VerifyRHRefCnt(punkIn, 1);
|
||
|
||
// make sure the interface pointers are identical
|
||
if (punkIn != punkOut)
|
||
TEST_FAILED_EXIT(TRUE, "Interface ptrs dont match...1st Local Unmarshal\n")
|
||
OUTPUT (" - CoUnmarshalInterface OK\n");
|
||
|
||
// release it and make sure it does not go away - refcnt > 0
|
||
ulRefCnt = punkOut->Release();
|
||
TEST_FAILED_EXIT(ulRefCnt == 0, "punkOut RefCnt is zero");
|
||
punkOut = NULL;
|
||
VerifyRHRefCnt(punkIn, 1);
|
||
OUTPUT (" - Release OK\n");
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
// test unmarshalling twice - should work since we used flags table
|
||
hres = pStm->Seek(large_int, STREAM_SEEK_SET, NULL);
|
||
TEST_FAILED_EXIT(FAILED(hres), "Seek on shared stream failed\n")
|
||
|
||
hres = CoUnmarshalInterface(pStm, IID_IParseDisplayName, (LPVOID FAR*)&punkOut2);
|
||
TEST_FAILED_EXIT(FAILED(hres), "CoUnmarshalInterface second time succeeded but should have failed\n")
|
||
VerifyRHRefCnt(punkIn, 1);
|
||
|
||
// make sure the interface pointers are identical
|
||
if (punkIn != punkOut2)
|
||
TEST_FAILED_EXIT(TRUE, "Interface ptrs dont match...2nd Local Unmarshal\n")
|
||
OUTPUT (" - Second CoUnmarshalInterface OK\n");
|
||
|
||
// release it and make sure it does not go away - refcnt > 0
|
||
ulRefCnt = punkOut2->Release();
|
||
TEST_FAILED_EXIT(ulRefCnt == 0, "punkOut2 RefCnt is zero");
|
||
punkOut2 = NULL;
|
||
VerifyRHRefCnt(punkIn, 1);
|
||
OUTPUT (" - Release OK\n");
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
// CoReleaseMarshalData should release the marshalled data TABLEWEAK
|
||
hres = pStm->Seek(large_int, STREAM_SEEK_SET, NULL);
|
||
TEST_FAILED_EXIT(FAILED(hres), "Seek on shared stream failed\n")
|
||
|
||
hres = CoReleaseMarshalData(pStm);
|
||
TEST_FAILED_EXIT(FAILED(hres), "CoReleaseMarshalData failed.\n")
|
||
VerifyRHRefCnt(punkIn, 0);
|
||
VerifyObjRefCnt(punkIn, 1);
|
||
OUTPUT (" - CoReleaseMarshalData OK\n");
|
||
|
||
|
||
ulRefCnt = punkIn->Release();
|
||
TEST_FAILED_EXIT(ulRefCnt != 0, "punkIn RefCnt is not zero");
|
||
punkIn = NULL;
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
Cleanup:
|
||
|
||
OUTPUT (" - Test Complete. Doing Cleanup\n");
|
||
|
||
// Dump interfaces we are done with
|
||
if (pStm)
|
||
{
|
||
ulRefCnt = pStm->Release();
|
||
TEST_FAILED(ulRefCnt != 0, "Stream RefCnt not zero\n");
|
||
}
|
||
|
||
if (punkOut)
|
||
{
|
||
ulRefCnt = punkOut->Release();
|
||
TEST_FAILED(ulRefCnt != 0, "punkOut RefCnt not zero\n");
|
||
}
|
||
|
||
if (punkOut2)
|
||
{
|
||
ulRefCnt = punkOut2->Release();
|
||
TEST_FAILED(ulRefCnt != 0, "punkOut2 RefCnt not zero\n");
|
||
}
|
||
|
||
if (punkIn)
|
||
{
|
||
ulRefCnt = punkIn->Release();
|
||
TEST_FAILED(ulRefCnt != 0, "punkIn RefCnt not zero\n");
|
||
}
|
||
|
||
return TestResult(RetVal, "TestLocalInterfaceTableWeak");
|
||
}
|
||
|
||
// ----------------------------------------------------------------------
|
||
//
|
||
// test calling CoUmarshalInterface with GUID_NULL
|
||
//
|
||
// ----------------------------------------------------------------------
|
||
|
||
// ----------------------------------------------------------------------
|
||
//
|
||
// Structure passed between apartments.
|
||
//
|
||
// ----------------------------------------------------------------------
|
||
typedef struct tagThreadUnmarshalInfo
|
||
{
|
||
HANDLE hEvent;
|
||
IStream *pStm;
|
||
IUnknown *pUnk;
|
||
IID iid;
|
||
DWORD dwInitFlag;
|
||
DWORD dwThreadId;
|
||
ULONG RelRefCnt;
|
||
HRESULT hr;
|
||
} ThreadUnmarshalInfo;
|
||
|
||
|
||
DWORD _stdcall ThreadTestUnmarshal(void *params)
|
||
{
|
||
ThreadUnmarshalInfo *pInfo = (ThreadUnmarshalInfo *)params;
|
||
BOOL RetVal = TRUE;
|
||
ULONG ulRefCnt= 0;
|
||
IUnknown *punkOut = NULL;
|
||
HRESULT hres;
|
||
|
||
hres = CoInitializeEx(NULL, pInfo->dwInitFlag);
|
||
|
||
hres = CoUnmarshalInterface(pInfo->pStm, pInfo->iid, (LPVOID FAR*)&punkOut);
|
||
TEST_FAILED(FAILED(hres), "CoUnmarshalInterface failed\n")
|
||
|
||
if (SUCCEEDED(hres))
|
||
{
|
||
// make sure the interface pointers are identical
|
||
if (pInfo->pUnk != NULL && pInfo->pUnk != punkOut)
|
||
{
|
||
TEST_FAILED(TRUE, "Interface ptrs are wrong\n")
|
||
}
|
||
else
|
||
{
|
||
OUTPUT (" - CoUnmarshalInterface OK.\n");
|
||
}
|
||
|
||
// release the interface
|
||
ulRefCnt = punkOut->Release();
|
||
punkOut = NULL;
|
||
TEST_FAILED(ulRefCnt != pInfo->RelRefCnt, "Released punkOut RefCnt is wrong\n");
|
||
|
||
OUTPUT (" - Release OK\n");
|
||
}
|
||
|
||
pInfo->hr = hres;
|
||
|
||
CoUninitialize();
|
||
|
||
// signal the other thread we are done.
|
||
// but only if we were called from a different thread
|
||
|
||
if (pInfo->dwThreadId != 0)
|
||
{
|
||
if (gInitFlag == COINIT_APARTMENTTHREADED)
|
||
{
|
||
PostThreadMessage(pInfo->dwThreadId, WM_QUIT, 0, 0);
|
||
}
|
||
else
|
||
{
|
||
SetEvent(pInfo->hEvent);
|
||
}
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
|
||
BOOL TestUnmarshalGUIDNULL(void)
|
||
{
|
||
BOOL RetVal = TRUE;
|
||
HRESULT hres;
|
||
LPSTREAM pStm = NULL;
|
||
IUnknown *punkIn = NULL;
|
||
ULONG ulRefCnt, i;
|
||
HANDLE hEvent = NULL;
|
||
ThreadUnmarshalInfo Info;
|
||
|
||
|
||
LARGE_INTEGER large_int;
|
||
LISet32(large_int, 0);
|
||
|
||
OUTPUT ("Starting TestUnmarshalGUIDNULL\n");
|
||
|
||
// Create a shared memory stream for the marshaled interface
|
||
pStm = CreateMemStm(600, NULL);
|
||
TEST_FAILED_EXIT((pStm == NULL), "CreateMemStm failed\n")
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
for (i=0; i<2; i++)
|
||
{
|
||
hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
|
||
TEST_FAILED_EXIT(hEvent == NULL, "CreateEvent failed\n")
|
||
|
||
punkIn = GetTestUnk();
|
||
TEST_FAILED_EXIT((punkIn == NULL), "new CTestUnk failed\n")
|
||
VerifyObjRefCnt(punkIn, 1);
|
||
|
||
// reset the stream ptr
|
||
hres = pStm->Seek(large_int, STREAM_SEEK_SET, NULL);
|
||
TEST_FAILED_EXIT(FAILED(hres), "Seek on shared stream failed\n")
|
||
|
||
// Marshal the interface into the stream
|
||
hres = CoMarshalInterface(pStm, IID_IParseDisplayName, punkIn,
|
||
0, 0, MSHLFLAGS_NORMAL);
|
||
TEST_FAILED_EXIT(FAILED(hres), "CoMarshalInterface failed\n")
|
||
VerifyRHRefCnt(punkIn, 1);
|
||
OUTPUT (" - CoMarshalInterface OK.\n");
|
||
|
||
// reset the stream ptr
|
||
hres = pStm->Seek(large_int, STREAM_SEEK_SET, NULL);
|
||
TEST_FAILED_EXIT(FAILED(hres), "Seek on shared stream failed\n")
|
||
|
||
Info.hEvent = hEvent;
|
||
Info.pStm = pStm;
|
||
Info.iid = GUID_NULL;
|
||
Info.dwInitFlag = gInitFlag;
|
||
Info.dwThreadId = 0;
|
||
|
||
if (i==0)
|
||
{
|
||
// first time, call on same thread, expect original ptr and
|
||
// non-zero refcnt after release
|
||
Info.pUnk = punkIn;
|
||
Info.RelRefCnt = 1;
|
||
|
||
ThreadTestUnmarshal(&Info);
|
||
}
|
||
else
|
||
{
|
||
// second time, call on different thread
|
||
if (gInitFlag == COINIT_APARTMENTTHREADED)
|
||
{
|
||
// apartment thread, expect differnt ptr and
|
||
// zero refcnt after release
|
||
|
||
Info.dwThreadId = GetCurrentThreadId();
|
||
Info.pUnk = 0;
|
||
Info.RelRefCnt = 0;
|
||
}
|
||
else
|
||
{
|
||
// multi-thread, expect same ptr and non-zero refcnt
|
||
// after release
|
||
|
||
Info.dwThreadId = GetCurrentThreadId();
|
||
Info.pUnk = punkIn;
|
||
Info.RelRefCnt = 1;
|
||
}
|
||
|
||
RunThread(&Info, hEvent, ThreadTestUnmarshal);
|
||
CloseHandle(hEvent);
|
||
}
|
||
|
||
// release the punkIn.
|
||
ulRefCnt = punkIn->Release();
|
||
TEST_FAILED(ulRefCnt != 0, "punkIn RefCnt not zero\n");
|
||
punkIn = NULL;
|
||
|
||
hres = Info.hr;
|
||
OUTPUT (" - Run Complete\n");
|
||
}
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
Cleanup:
|
||
|
||
OUTPUT (" - Test Complete. Doing Cleanup\n");
|
||
|
||
// Dump interfaces we are done with
|
||
if (pStm)
|
||
{
|
||
ulRefCnt = pStm->Release();
|
||
TEST_FAILED(ulRefCnt != 0, "Stream RefCnt not zero\n");
|
||
}
|
||
|
||
if (punkIn)
|
||
{
|
||
ulRefCnt = punkIn->Release();
|
||
TEST_FAILED(ulRefCnt != 0, "punkIn RefCnt not zero\n");
|
||
}
|
||
|
||
return TestResult(RetVal, "TestUnmarshalGUIDNULL");
|
||
}
|
||
|
||
// ----------------------------------------------------------------------
|
||
//
|
||
// test calling CoUmarshalInterface with an IID different from
|
||
// the IID that was marshaled.
|
||
//
|
||
// ----------------------------------------------------------------------
|
||
|
||
BOOL TestUnmarshalDifferentIID(void)
|
||
{
|
||
BOOL RetVal = TRUE;
|
||
HRESULT hres;
|
||
LPSTREAM pStm = NULL;
|
||
IUnknown *punkIn = NULL;
|
||
ULONG ulRefCnt, i;
|
||
HANDLE hEvent = NULL;
|
||
ThreadUnmarshalInfo Info;
|
||
|
||
LARGE_INTEGER large_int;
|
||
LISet32(large_int, 0);
|
||
|
||
OUTPUT ("Starting TestUnmarshalDifferentIID\n");
|
||
|
||
// Create a shared memory stream for the marshaled interface
|
||
pStm = CreateMemStm(600, NULL);
|
||
TEST_FAILED_EXIT((pStm == NULL), "CreateMemStm failed\n")
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
for (i=0; i<2; i++)
|
||
{
|
||
hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
|
||
TEST_FAILED_EXIT(hEvent == NULL, "CreateEvent failed\n")
|
||
|
||
punkIn = GetTestUnk();
|
||
TEST_FAILED_EXIT((punkIn == NULL), "new CTestUnk failed\n")
|
||
VerifyObjRefCnt(punkIn, 1);
|
||
|
||
// reset the stream ptr
|
||
hres = pStm->Seek(large_int, STREAM_SEEK_SET, NULL);
|
||
TEST_FAILED_EXIT(FAILED(hres), "Seek on shared stream failed\n")
|
||
|
||
// Marshal the interface into the stream
|
||
hres = CoMarshalInterface(pStm, IID_IParseDisplayName, punkIn,
|
||
0, 0, MSHLFLAGS_NORMAL);
|
||
TEST_FAILED_EXIT(FAILED(hres), "CoMarshalInterface failed\n")
|
||
VerifyRHRefCnt(punkIn, 1);
|
||
OUTPUT (" - CoMarshalInterface OK.\n");
|
||
|
||
// reset the stream ptr
|
||
hres = pStm->Seek(large_int, STREAM_SEEK_SET, NULL);
|
||
TEST_FAILED_EXIT(FAILED(hres), "Seek on shared stream failed\n")
|
||
|
||
Info.hEvent = hEvent;
|
||
Info.pStm = pStm;
|
||
Info.iid = IID_IOleWindow;
|
||
Info.pUnk = punkIn;
|
||
Info.dwInitFlag = gInitFlag;
|
||
Info.dwThreadId = 0;
|
||
|
||
if (i==0)
|
||
{
|
||
// first time, call on same thread, expect different ptr and
|
||
// non-zero refcnt after release
|
||
Info.pUnk = 0;
|
||
Info.RelRefCnt = 1;
|
||
|
||
ThreadTestUnmarshal(&Info);
|
||
}
|
||
else
|
||
{
|
||
if (gInitFlag == COINIT_APARTMENTTHREADED)
|
||
{
|
||
// apartment thread, expect differnt ptr and
|
||
// zero refcnt after release
|
||
|
||
Info.dwThreadId = GetCurrentThreadId();
|
||
Info.pUnk = 0;
|
||
Info.RelRefCnt = 0;
|
||
}
|
||
else
|
||
{
|
||
// multi-thread, expect same ptr and non-zero refcnt
|
||
// after release
|
||
|
||
Info.dwThreadId = GetCurrentThreadId();
|
||
Info.pUnk = 0;
|
||
Info.RelRefCnt = 1;
|
||
}
|
||
|
||
RunThread(&Info, hEvent, ThreadTestUnmarshal);
|
||
CloseHandle(hEvent);
|
||
}
|
||
|
||
// release the punkIn.
|
||
ulRefCnt = punkIn->Release();
|
||
TEST_FAILED(ulRefCnt != 0, "punkIn RefCnt not zero\n");
|
||
punkIn = NULL;
|
||
|
||
hres = Info.hr;
|
||
OUTPUT (" - Run Complete\n");
|
||
}
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
Cleanup:
|
||
|
||
OUTPUT (" - Test Complete. Doing Cleanup\n");
|
||
|
||
// Dump interfaces we are done with
|
||
if (pStm)
|
||
{
|
||
ulRefCnt = pStm->Release();
|
||
TEST_FAILED(ulRefCnt != 0, "Stream RefCnt not zero\n");
|
||
}
|
||
|
||
if (punkIn)
|
||
{
|
||
ulRefCnt = punkIn->Release();
|
||
TEST_FAILED(ulRefCnt != 0, "punkIn RefCnt not zero\n");
|
||
}
|
||
|
||
return TestResult(RetVal, "TestUnmarshalDifferentIID");
|
||
}
|
||
|
||
|
||
// ----------------------------------------------------------------------
|
||
//
|
||
// test REMOTE interface MSHLFLAGS_NORMAL
|
||
//
|
||
// ----------------------------------------------------------------------
|
||
|
||
BOOL TestRemoteInterfaceNormal(void)
|
||
{
|
||
BOOL RetVal = TRUE;
|
||
HRESULT hres;
|
||
LPSTREAM pStm = NULL;
|
||
LPCLASSFACTORY pICF = NULL;
|
||
ULONG ulRefCnt;
|
||
IUnknown *punkOut = NULL;
|
||
IUnknown *punkIn = NULL;
|
||
|
||
LARGE_INTEGER large_int;
|
||
LISet32(large_int, 0);
|
||
|
||
OUTPUT ("Starting TestRemoteInterfaceNormal\n");
|
||
|
||
// Create an IClassFactory Interface.
|
||
DWORD grfContext=CLSCTX_LOCAL_SERVER; // handler/server/local server
|
||
hres = CoGetClassObject(CLSID_Balls,
|
||
grfContext,
|
||
NULL, // pvReserved
|
||
IID_IClassFactory,
|
||
(void **)&pICF);
|
||
|
||
TEST_FAILED_EXIT(FAILED(hres), "CoGetClassObject failed\n")
|
||
TEST_FAILED_EXIT((pICF == NULL), "CoGetClassObject failed\n")
|
||
VerifyRHRefCnt((IUnknown *)pICF, 1);
|
||
OUTPUT (" - Aquired Remote Class Object.\n");
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
// note, since pICF is a class object, it has special super secret
|
||
// behaviour to make it go away. create an instance, release the
|
||
// class object, then release the instance.
|
||
|
||
hres = pICF->CreateInstance(NULL, IID_IUnknown, (void **)&punkIn);
|
||
TEST_FAILED_EXIT(FAILED(hres), "CreateInstance failed\n")
|
||
TEST_FAILED_EXIT((punkIn == NULL), "CreateInstance failed\n")
|
||
VerifyRHRefCnt(punkIn, 1);
|
||
OUTPUT (" - Created Instance.\n");
|
||
|
||
// release class object
|
||
ulRefCnt = pICF->Release();
|
||
TEST_FAILED(ulRefCnt != 0, "pICF RefCnt not zero\n");
|
||
// VerifyRHRefCnt((IUnknown *)pICF, 0);
|
||
pICF = NULL;
|
||
OUTPUT (" - Released Class Object.\n");
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
// Create a shared memory stream for the marshaled interface
|
||
pStm = CreateMemStm(600, NULL);
|
||
TEST_FAILED_EXIT((pStm == NULL), "CreateMemStm failed\n")
|
||
|
||
// Marshal the interface into the stream
|
||
hres = CoMarshalInterface(pStm, IID_IUnknown, punkIn, 0, NULL, MSHLFLAGS_NORMAL);
|
||
TEST_FAILED_EXIT(FAILED(hres), "CoMarshalInterface failed\n")
|
||
OUTPUT (" - CoMarshalInterface OK.\n");
|
||
VerifyRHRefCnt(punkIn, 1);
|
||
|
||
// unmarshal the interface. should get the same proxy back.
|
||
hres = pStm->Seek(large_int, STREAM_SEEK_SET, NULL);
|
||
TEST_FAILED_EXIT(FAILED(hres), "Seek on shared stream failed\n")
|
||
|
||
hres = CoUnmarshalInterface(pStm, IID_IUnknown, (LPVOID FAR*)&punkOut);
|
||
TEST_FAILED_EXIT(FAILED(hres), "CoUnmarshalInterface failed\n")
|
||
VerifyRHRefCnt(punkIn, 2);
|
||
|
||
// make sure the interface pointers are identical
|
||
if (punkIn != punkOut)
|
||
TEST_FAILED_EXIT(TRUE, "Interface ptrs dont match..1st Remote Unmarshal\n")
|
||
OUTPUT (" - CoUnmarshalInterface OK.\n");
|
||
|
||
|
||
// release the interface
|
||
ulRefCnt = punkOut->Release();
|
||
punkOut = NULL;
|
||
TEST_FAILED_EXIT(ulRefCnt == 0, "punkOut RefCnt is zero\n");
|
||
VerifyRHRefCnt(punkIn, 1);
|
||
OUTPUT (" - Release OK\n");
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
#if 0
|
||
// test unmarshalling twice. this should fail since we marshalled normal
|
||
hres = pStm->Seek(large_int, STREAM_SEEK_SET, NULL);
|
||
TEST_FAILED_EXIT(FAILED(hres), "Seek on shared stream failed\n")
|
||
|
||
hres = CoUnmarshalInterface(pStm, IID_IUnknown, (LPVOID FAR*)&punkOut);
|
||
TEST_FAILED_EXIT(SUCCEEDED(hres), "CoUnmarshalInterface succeeded but should have failed\n")
|
||
VerifyRHRefCnt(punkIn, 1);
|
||
OUTPUT (" - Second CoUnmarshalInterface OK.\n");
|
||
punkOut = NULL;
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
// CoReleaseMarshalData should FAIL since we already unmarshalled it
|
||
hres = pStm->Seek(large_int, STREAM_SEEK_SET, NULL);
|
||
TEST_FAILED_EXIT(FAILED(hres), "Seek on shared stream failed\n")
|
||
|
||
hres = CoReleaseMarshalData(pStm);
|
||
TEST_FAILED_EXIT(SUCCEEDED(hres), "CoReleaseMarshalData succeeded but should have failed.\n")
|
||
VerifyRHRefCnt(punkIn, 1);
|
||
OUTPUT (" - CoReleaseMarshalData OK\n");
|
||
|
||
#endif
|
||
// ----------------------------------------------------------------------
|
||
|
||
// marshal again and try CoRelease without having first done an
|
||
// unmarshal. this should work.
|
||
hres = pStm->Seek(large_int, STREAM_SEEK_SET, NULL);
|
||
TEST_FAILED_EXIT(FAILED(hres), "Seek on shared stream failed\n")
|
||
|
||
hres = CoMarshalInterface(pStm, IID_IUnknown, punkIn, 0, NULL, MSHLFLAGS_NORMAL);
|
||
TEST_FAILED_EXIT(FAILED(hres), "CoMarshalInterface failed\n")
|
||
VerifyRHRefCnt(punkIn, 1);
|
||
OUTPUT (" - CoMarshalInterface OK\n");
|
||
|
||
hres = pStm->Seek(large_int, STREAM_SEEK_SET, NULL);
|
||
TEST_FAILED_EXIT(FAILED(hres), "Seek on shared stream failed\n")
|
||
|
||
hres = CoReleaseMarshalData(pStm);
|
||
TEST_FAILED_EXIT(FAILED(hres), "CoReleaseMarshalData failed.\n")
|
||
VerifyRHRefCnt(punkIn, 1);
|
||
OUTPUT (" - CoReleaseMarshalData OK\n");
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
Cleanup:
|
||
|
||
OUTPUT (" - Test Complete. Doing Cleanup\n");
|
||
|
||
// Dump interfaces we are done with
|
||
if (pStm)
|
||
{
|
||
ulRefCnt = pStm->Release();
|
||
TEST_FAILED(ulRefCnt != 0, "Stream RefCnt not zero\n");
|
||
}
|
||
|
||
if (pICF)
|
||
{
|
||
ulRefCnt = pICF->Release();
|
||
TEST_FAILED(ulRefCnt != 0, "pICF RefCnt not zero\n");
|
||
}
|
||
|
||
if (punkOut)
|
||
{
|
||
ulRefCnt = punkOut->Release();
|
||
TEST_FAILED(ulRefCnt == 0, "punkOut RefCnt is zero\n");
|
||
}
|
||
|
||
if (punkIn)
|
||
{
|
||
ulRefCnt = punkIn->Release();
|
||
TEST_FAILED(ulRefCnt != 0, "punkIn RefCnt not zero\n");
|
||
}
|
||
|
||
return TestResult(RetVal, "TestRemoteInterfaceNormal");
|
||
}
|
||
|
||
|
||
// ----------------------------------------------------------------------
|
||
//
|
||
// test REMOTE interface MSHLFLAGS_TABLESTRONG
|
||
//
|
||
// ----------------------------------------------------------------------
|
||
|
||
BOOL TestRemoteInterfaceTableStrong(void)
|
||
{
|
||
BOOL RetVal = TRUE;
|
||
HRESULT hres;
|
||
LPSTREAM pStm = NULL;
|
||
LPCLASSFACTORY pICF = NULL;
|
||
ULONG ulRefCnt;
|
||
IUnknown *punkIn = NULL;
|
||
IUnknown *punkOut = NULL;
|
||
|
||
LARGE_INTEGER large_int;
|
||
LISet32(large_int, 0);
|
||
|
||
OUTPUT ("Starting TestRemoteInterfaceTableStrong\n");
|
||
|
||
// Create an IClassFactory Interface.
|
||
DWORD grfContext=CLSCTX_LOCAL_SERVER; // handler/server/local server
|
||
hres = CoGetClassObject(CLSID_Balls,
|
||
grfContext,
|
||
NULL, // pvReserved
|
||
IID_IClassFactory,
|
||
(void **)&pICF);
|
||
|
||
TEST_FAILED_EXIT(FAILED(hres), "CoGetClassObject failed\n")
|
||
TEST_FAILED_EXIT((pICF == NULL), "CoGetClassObject failed\n")
|
||
OUTPUT (" - Aquired Remote Class Object.\n");
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
// note, since pICF is a class object, it has special super secret
|
||
// behaviour to make it go away. create an instance, release the
|
||
// class object, then release the instance.
|
||
|
||
hres = pICF->CreateInstance(NULL, IID_IUnknown, (void **)&punkIn);
|
||
TEST_FAILED_EXIT(FAILED(hres), "CreateInstance failed\n")
|
||
TEST_FAILED_EXIT((punkIn == NULL), "CreateInstance failed\n")
|
||
OUTPUT (" - Created Instance.\n");
|
||
|
||
// release class object
|
||
ulRefCnt = pICF->Release();
|
||
TEST_FAILED(ulRefCnt != 0, "pICF RefCnt not zero\n");
|
||
pICF = NULL;
|
||
OUTPUT (" - Released Class Object.\n");
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
// Create a shared memory stream for the marshaled moniker
|
||
pStm = CreateMemStm(600, NULL);
|
||
TEST_FAILED_EXIT((pStm == NULL), "CreateMemStm failed\n")
|
||
|
||
// Marshal the interface into the stream
|
||
hres = CoMarshalInterface(pStm, IID_IUnknown, punkIn, 0, NULL, MSHLFLAGS_TABLESTRONG);
|
||
TEST_FAILED_EXIT(SUCCEEDED(hres), "CoMarshalInterface succeeded but should have failed\n")
|
||
OUTPUT (" - CoMarshalInterface OK.\n");
|
||
|
||
LISet32(large_int, 0);
|
||
hres = pStm->Seek(large_int, STREAM_SEEK_SET, NULL);
|
||
TEST_FAILED_EXIT(FAILED(hres), "Seek on shared stream failed\n")
|
||
|
||
#if 0
|
||
hres = CoUnmarshalInterface(pStm, IID_IUnknown, (LPVOID FAR*)&punkOut);
|
||
TEST_FAILED_EXIT(FAILED(hres), "CoUnmarshalInterface failed\n")
|
||
|
||
// make sure the interface pointers are identical
|
||
if (punkIn != punkOut)
|
||
TEST_FAILED_EXIT(TRUE, "Interface ptrs dont match..1st Remote Unmarshal\n")
|
||
OUTPUT (" - CoUnmarshalInterface OK.\n");
|
||
|
||
// release it
|
||
ulRefCnt = punkOut->Release();
|
||
TEST_FAILED_EXIT(ulRefCnt == 0, "punkOut RefCnt is zero\n");
|
||
punkOut = NULL;
|
||
OUTPUT (" - Release OK\n");
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
// test unmarshalling twice.
|
||
// this should work since we did marshal flags TABLE_STRONG
|
||
hres = pStm->Seek(large_int, STREAM_SEEK_SET, NULL);
|
||
TEST_FAILED_EXIT(FAILED(hres), "Seek on shared stream failed\n")
|
||
|
||
hres = CoUnmarshalInterface(pStm, IID_IUnknown, (LPVOID FAR*)&punkOut);
|
||
TEST_FAILED_EXIT(FAILED(hres), "CoUnmarshalInterface failed\n")
|
||
OUTPUT (" - Second CoUnmarshalInterface OK.\n");
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
// CoReleaseMarshalData should WORK for TABLESTRONG interfaces
|
||
hres = pStm->Seek(large_int, STREAM_SEEK_SET, NULL);
|
||
TEST_FAILED_EXIT(FAILED(hres), "Seek on shared stream failed\n")
|
||
|
||
hres = CoReleaseMarshalData(pStm);
|
||
TEST_FAILED_EXIT(FAILED(hres), "CoReleaseMarshalData failed.\n")
|
||
OUTPUT (" - CoReleaseMarshalData OK\n");
|
||
|
||
// ----------------------------------------------------------------------
|
||
#endif
|
||
Cleanup:
|
||
|
||
OUTPUT (" - Test Complete. Doing Cleanup\n");
|
||
|
||
// Dump interfaces we are done with
|
||
if (pStm)
|
||
{
|
||
ulRefCnt = pStm->Release();
|
||
TEST_FAILED(ulRefCnt != 0, "Stream RefCnt not zero\n");
|
||
}
|
||
|
||
if (punkOut)
|
||
{
|
||
ulRefCnt = punkOut->Release();
|
||
TEST_FAILED(ulRefCnt == 0, "punkOut RefCnt is zero\n");
|
||
}
|
||
|
||
if (punkIn)
|
||
{
|
||
// release instance
|
||
ulRefCnt = punkIn->Release();
|
||
TEST_FAILED(ulRefCnt != 0,"punkIn RefCnt not zero\n");
|
||
}
|
||
|
||
return TestResult(RetVal, "TestRemoteInterfaceTableStrong");
|
||
}
|
||
|
||
// ----------------------------------------------------------------------
|
||
//
|
||
// test CUSTOM interface MSHLFLAGS_NORMAL --- CODEWORK
|
||
//
|
||
// ----------------------------------------------------------------------
|
||
|
||
BOOL TestCustomMarshalNormal(void)
|
||
{
|
||
BOOL RetVal = TRUE;
|
||
|
||
return TestResult(RetVal, "TestCustomMarshalNormal");
|
||
}
|
||
|
||
|
||
// ----------------------------------------------------------------------
|
||
//
|
||
// test CUSTOM interface MSHLFLAGS_TABLESTRONG --- CODEWORK
|
||
//
|
||
// ----------------------------------------------------------------------
|
||
|
||
BOOL TestCustomMarshalTable(void)
|
||
{
|
||
BOOL RetVal = TRUE;
|
||
|
||
return TestResult(RetVal, "TestCustomMarshalTableStrong");
|
||
}
|
||
|
||
|
||
// ----------------------------------------------------------------------
|
||
//
|
||
// TestEcho
|
||
//
|
||
// test sending an interface to a remote server and getting the same
|
||
// interface back again. the test is done with once with a local
|
||
// interface and once with a remote interface.
|
||
//
|
||
// Local Interface Remote Interface
|
||
//
|
||
// 1. marshal [in] local marshal [in] remote proxy
|
||
// 2. unmarshal [in] remote unmarshal [in] local proxy
|
||
// 3. marshal [out] remote proxy marshal [out] local
|
||
// 4. unmarshal [in] local proxy unmarshal [out] remote
|
||
//
|
||
// ----------------------------------------------------------------------
|
||
|
||
BOOL TestEcho(void)
|
||
{
|
||
BOOL RetVal = TRUE;
|
||
HRESULT hres;
|
||
ULONG ulRefCnt;
|
||
LPCLASSFACTORY pICF = NULL;
|
||
IBalls *pIBalls = NULL;
|
||
IUnknown *punkIn = NULL;
|
||
IUnknown *punkIn2 = NULL;
|
||
IUnknown *punkOut = NULL;
|
||
|
||
LARGE_INTEGER large_int;
|
||
LISet32(large_int, 0);
|
||
|
||
OUTPUT ("Starting TestEcho\n");
|
||
|
||
// Create an IBall ClassFactory Interface.
|
||
DWORD grfContext=CLSCTX_LOCAL_SERVER; // handler/server/local server
|
||
hres = CoGetClassObject(CLSID_Balls,
|
||
grfContext,
|
||
NULL, // pvReserved
|
||
IID_IClassFactory,
|
||
(void **)&pICF);
|
||
|
||
TEST_FAILED_EXIT(FAILED(hres), "CoGetClassObject failed\n")
|
||
TEST_FAILED_EXIT((pICF == NULL), "CoGetClassObject failed\n")
|
||
OUTPUT (" - Aquired Remote Class Object.\n");
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
// note, since pICF is a class object, it has special super secret
|
||
// behaviour to make it go away. create an instance, release the
|
||
// class object, then release the instance.
|
||
|
||
hres = pICF->CreateInstance(NULL, IID_IBalls, (void **)&pIBalls);
|
||
TEST_FAILED_EXIT(FAILED(hres), "CreateInstance failed\n")
|
||
TEST_FAILED_EXIT((pIBalls == NULL), "CreateInstance failed\n")
|
||
OUTPUT (" - Created First Instance.\n");
|
||
|
||
hres = pICF->CreateInstance(NULL, IID_IUnknown, (void **)&punkIn2);
|
||
TEST_FAILED_EXIT(FAILED(hres), "CreateInstance failed\n")
|
||
TEST_FAILED_EXIT((punkIn2 == NULL), "CreateInstance failed\n")
|
||
OUTPUT (" - Created Second Instance.\n");
|
||
|
||
// release class object
|
||
ulRefCnt = pICF->Release();
|
||
TEST_FAILED(ulRefCnt != 0, "pICF RefCnt not zero\n");
|
||
pICF = NULL;
|
||
OUTPUT (" - Released Class Object.\n");
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
// create a local interface
|
||
punkIn = GetTestUnk();
|
||
TEST_FAILED_EXIT((punkIn == NULL), "new CTestUnk failed\n")
|
||
VerifyObjRefCnt(punkIn, 1);
|
||
|
||
// call a method that echos the local interface right back to us.
|
||
hres = pIBalls->Echo(punkIn, &punkOut);
|
||
TEST_FAILED_EXIT(FAILED(hres), "Echo on IBalls failed\n")
|
||
TEST_FAILED_EXIT((punkOut == NULL), "Echo on IBalls failed\n")
|
||
|
||
// make sure the interface pointers are identical
|
||
if (punkIn != punkOut)
|
||
TEST_FAILED_EXIT(TRUE, "Interface ptrs dont match..Echo\n")
|
||
|
||
VerifyObjRefCnt(punkIn, 2);
|
||
VerifyRHRefCnt(punkIn, 0);
|
||
OUTPUT (" - Echo OK.\n");
|
||
|
||
// release the out interface
|
||
ulRefCnt = punkOut->Release();
|
||
punkOut = NULL;
|
||
TEST_FAILED_EXIT(ulRefCnt != 1, "punkOut RefCnt is not 1\n");
|
||
OUTPUT (" - Released punkOut OK\n");
|
||
|
||
// release the In interface
|
||
ulRefCnt = punkIn->Release();
|
||
punkIn = NULL;
|
||
TEST_FAILED_EXIT(ulRefCnt != 0, "punkIn RefCnt is not zero\n");
|
||
OUTPUT (" - Released punkIn OK\n");
|
||
|
||
OUTPUT (" - Echo Local Interface OK\n");
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
// call a method that echos a remote interface right back to us.
|
||
hres = pIBalls->Echo(punkIn2, &punkOut);
|
||
TEST_FAILED_EXIT(FAILED(hres), "Echo on IBalls failed\n")
|
||
TEST_FAILED_EXIT((punkOut == NULL), "Echon on IBalls failed\n")
|
||
|
||
// make sure the interface pointers are identical
|
||
if (punkIn2 != punkOut)
|
||
TEST_FAILED_EXIT(TRUE, "Interface ptrs dont match..Echo\n")
|
||
|
||
VerifyObjRefCnt(punkIn2, 2);
|
||
VerifyRHRefCnt(punkIn2, 2);
|
||
OUTPUT (" - Echo OK.\n");
|
||
|
||
// release the out interface
|
||
ulRefCnt = punkOut->Release();
|
||
punkOut = NULL;
|
||
TEST_FAILED_EXIT(ulRefCnt != 1, "punkOut RefCnt is not 1\n");
|
||
OUTPUT (" - Released punkOut OK\n");
|
||
|
||
// release the In interface
|
||
ulRefCnt = punkIn2->Release();
|
||
punkIn2 = NULL;
|
||
TEST_FAILED_EXIT(ulRefCnt != 0, "punkIn2 RefCnt is not zero\n");
|
||
OUTPUT (" - Released punkIn2 OK\n");
|
||
|
||
OUTPUT (" - Echo Remote Interface OK\n");
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
// release the IBalls interface
|
||
ulRefCnt = pIBalls->Release();
|
||
TEST_FAILED_EXIT(ulRefCnt != 0, "pIBalls RefCnt is not zero\n");
|
||
pIBalls = NULL;
|
||
OUTPUT (" - Released IBalls OK\n");
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
Cleanup:
|
||
|
||
OUTPUT (" - Test Complete. Doing Cleanup\n");
|
||
|
||
// Dump interfaces we are done with
|
||
if (pICF)
|
||
{
|
||
ulRefCnt = pICF->Release();
|
||
TEST_FAILED(ulRefCnt != 0, "pICF RefCnt not zero\n");
|
||
}
|
||
|
||
if (punkOut)
|
||
{
|
||
ulRefCnt = punkOut->Release();
|
||
TEST_FAILED(ulRefCnt == 0, "punkOut RefCnt is zero\n");
|
||
}
|
||
|
||
if (punkIn)
|
||
{
|
||
ulRefCnt = punkIn->Release();
|
||
TEST_FAILED(ulRefCnt != 0, "punkIn RefCnt not zero\n");
|
||
}
|
||
|
||
if (pIBalls)
|
||
{
|
||
ulRefCnt = pIBalls->Release();
|
||
TEST_FAILED(ulRefCnt != 0, "pIBalls RefCnt not zero\n");
|
||
}
|
||
|
||
if (punkIn2)
|
||
{
|
||
ulRefCnt = punkIn2->Release();
|
||
TEST_FAILED(ulRefCnt != 0, "punkIn2 RefCnt not zero\n");
|
||
}
|
||
|
||
return TestResult(RetVal, "TestEcho");
|
||
}
|
||
|
||
|
||
|
||
// ----------------------------------------------------------------------
|
||
//
|
||
// TestMiddleMan
|
||
//
|
||
// test sending an remote interface to a second different process.
|
||
//
|
||
// 1. marshal [in] remote proxy
|
||
// 2. unmarshal [in] remote proxy
|
||
// 3. marshal [out] remote proxy
|
||
// 4. unmarshal [in] local proxy
|
||
//
|
||
// ----------------------------------------------------------------------
|
||
|
||
BOOL TestMiddleMan(void)
|
||
{
|
||
BOOL RetVal = TRUE;
|
||
HRESULT hres;
|
||
ULONG ulRefCnt;
|
||
LPCLASSFACTORY pICF = NULL;
|
||
IBalls *pIBalls = NULL;
|
||
ICube *pICubes = NULL;
|
||
IUnknown *punkIn = NULL;
|
||
IUnknown *punkOut = NULL;
|
||
|
||
LARGE_INTEGER large_int;
|
||
LISet32(large_int, 0);
|
||
|
||
OUTPUT ("Starting TestMiddleMan\n");
|
||
|
||
// Create an IBall ClassFactory Interface.
|
||
DWORD grfContext=CLSCTX_LOCAL_SERVER; // handler/server/local server
|
||
hres = CoGetClassObject(CLSID_Balls,
|
||
grfContext,
|
||
NULL, // pvReserved
|
||
IID_IClassFactory,
|
||
(void **)&pICF);
|
||
|
||
TEST_FAILED_EXIT(FAILED(hres), "CoGetClassObject Balls failed\n")
|
||
TEST_FAILED_EXIT((pICF == NULL), "CoGetClassObject Balls failed\n")
|
||
OUTPUT (" - Aquired Remote Balls Class Object.\n");
|
||
VerifyObjRefCnt(pICF, 1);
|
||
VerifyRHRefCnt(pICF, 1);
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
// note, since pICF is a class object, it has special super secret
|
||
// behaviour to make it go away. create an instance, release the
|
||
// class object, then release the instance.
|
||
|
||
hres = pICF->CreateInstance(NULL, IID_IBalls, (void **)&pIBalls);
|
||
TEST_FAILED_EXIT(FAILED(hres), "CreateInstance failed\n")
|
||
TEST_FAILED_EXIT((pIBalls == NULL), "CreateInstance failed\n")
|
||
OUTPUT (" - Created Balls Instance.\n");
|
||
|
||
VerifyObjRefCnt(pIBalls, 1);
|
||
VerifyRHRefCnt(pIBalls, 1);
|
||
|
||
// release class object
|
||
ulRefCnt = pICF->Release();
|
||
TEST_FAILED(ulRefCnt != 0, "pICF RefCnt not zero\n");
|
||
pICF = NULL;
|
||
OUTPUT (" - Released Balls Class Object.\n");
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
// Create an ICube ClassFactory Interface.
|
||
grfContext=CLSCTX_LOCAL_SERVER; // handler/server/local server
|
||
hres = CoGetClassObject(CLSID_Cubes,
|
||
grfContext,
|
||
NULL, // pvReserved
|
||
IID_IClassFactory,
|
||
(void **)&pICF);
|
||
|
||
TEST_FAILED_EXIT(FAILED(hres), "CoGetClassObject Cubes failed\n")
|
||
TEST_FAILED_EXIT((pICF == NULL), "CoGetClassObject Cubes failed\n")
|
||
OUTPUT (" - Aquired Remote Cubes Class Object.\n");
|
||
VerifyObjRefCnt(pICF, 1);
|
||
VerifyRHRefCnt(pICF, 1);
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
// note, since pICF is a class object, it has special super secret
|
||
// behaviour to make it go away. create an instance, release the
|
||
// class object, then release the instance.
|
||
|
||
hres = pICF->CreateInstance(NULL, IID_ICube, (void **)&pICubes);
|
||
TEST_FAILED_EXIT(FAILED(hres), "CreateInstance Cubes failed\n")
|
||
TEST_FAILED_EXIT((pICubes == NULL), "CreateInstance Cubes failed\n")
|
||
OUTPUT (" - Created Cubes Instance.\n");
|
||
|
||
VerifyObjRefCnt(pICubes, 1);
|
||
VerifyRHRefCnt(pICubes, 1);
|
||
|
||
// release class object
|
||
ulRefCnt = pICF->Release();
|
||
TEST_FAILED(ulRefCnt != 0, "pICF RefCnt not zero\n");
|
||
pICF = NULL;
|
||
OUTPUT (" - Released Cubes Class Object.\n");
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
// pass the remote cubes interface to the balls interface.
|
||
hres = pIBalls->IsContainedIn(pICubes);
|
||
TEST_FAILED_EXIT(FAILED(hres), "IsContainedIn failed\n")
|
||
VerifyObjRefCnt(pIBalls, 1);
|
||
VerifyRHRefCnt(pIBalls, 1);
|
||
VerifyObjRefCnt(pICubes, 1);
|
||
VerifyRHRefCnt(pICubes, 1);
|
||
OUTPUT (" - IsContainedIn OK.\n");
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
// pass the remote balls interface to the cubes interface.
|
||
hres = pICubes->Contains(pIBalls);
|
||
TEST_FAILED_EXIT(FAILED(hres), "Contains failed\n")
|
||
VerifyObjRefCnt(pIBalls, 1);
|
||
VerifyRHRefCnt(pIBalls, 1);
|
||
VerifyObjRefCnt(pICubes, 1);
|
||
VerifyRHRefCnt(pICubes, 1);
|
||
OUTPUT (" - Contains OK.\n");
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
// echo the remote ICubes interface to the remote IBalls interface
|
||
hres = pICubes->QueryInterface(IID_IUnknown, (void **)&punkIn);
|
||
TEST_FAILED_EXIT(FAILED(hres), "QueryInterface IUnknown failed\n")
|
||
VerifyRHRefCnt(pICubes, 2);
|
||
VerifyObjRefCnt(pICubes, 2);
|
||
OUTPUT (" - QueryInterface OK.\n");
|
||
|
||
hres = pIBalls->Echo(punkIn, &punkOut);
|
||
TEST_FAILED_EXIT(FAILED(hres), "Echo on IBalls failed\n")
|
||
TEST_FAILED_EXIT((punkOut == NULL), "Echo on IBalls failed\n")
|
||
|
||
// make sure the interface pointers are identical
|
||
if (punkIn != punkOut)
|
||
TEST_FAILED_EXIT(TRUE, "Interface ptrs dont match..Echo\n")
|
||
|
||
VerifyObjRefCnt(punkIn, 3);
|
||
VerifyRHRefCnt(punkIn, 3);
|
||
OUTPUT (" - Echo OK.\n");
|
||
|
||
// release the out interface
|
||
ulRefCnt = punkOut->Release();
|
||
punkOut = NULL;
|
||
TEST_FAILED(ulRefCnt != 2, "punkOut RefCnt is not 2\n");
|
||
OUTPUT (" - Released punkOut OK\n");
|
||
|
||
// release the In interface
|
||
ulRefCnt = punkIn->Release();
|
||
punkIn = NULL;
|
||
TEST_FAILED(ulRefCnt != 1, "punkIn RefCnt is not 1\n");
|
||
OUTPUT (" - Released punkIn OK\n");
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
// release the ICubes interface
|
||
ulRefCnt = pICubes->Release();
|
||
TEST_FAILED(ulRefCnt != 0, "pICubes RefCnt is not zero\n");
|
||
pICubes = NULL;
|
||
OUTPUT (" - Released ICubes OK\n");
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
// release the IBalls interface
|
||
ulRefCnt = pIBalls->Release();
|
||
TEST_FAILED(ulRefCnt != 0, "pIBalls RefCnt is not zero\n");
|
||
pIBalls = NULL;
|
||
OUTPUT (" - Released IBalls OK\n");
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
|
||
Cleanup:
|
||
|
||
OUTPUT (" - Test Complete. Doing Cleanup\n");
|
||
|
||
// Dump interfaces we are done with
|
||
if (pICF)
|
||
{
|
||
ulRefCnt = pICF->Release();
|
||
TEST_FAILED(ulRefCnt != 0, "pICF RefCnt not zero\n");
|
||
}
|
||
|
||
if (pIBalls)
|
||
{
|
||
ulRefCnt = pIBalls->Release();
|
||
TEST_FAILED(ulRefCnt != 0, "pIBalls RefCnt not zero\n");
|
||
}
|
||
|
||
if (pICubes)
|
||
{
|
||
ulRefCnt = pICubes->Release();
|
||
TEST_FAILED(ulRefCnt != 0, "pICubes RefCnt not zero\n");
|
||
}
|
||
|
||
return TestResult(RetVal, "TestMiddleMan");
|
||
}
|
||
|
||
|
||
// ----------------------------------------------------------------------
|
||
//
|
||
// TestLoop
|
||
//
|
||
// tests A calling B calling A calling B etc n times, to see if Rpc
|
||
// can handle this.
|
||
//
|
||
// ----------------------------------------------------------------------
|
||
|
||
BOOL TestLoop(void)
|
||
{
|
||
BOOL RetVal = TRUE;
|
||
HRESULT hRes = S_OK;
|
||
ILoop *pLocalLoop = NULL;
|
||
ILoop *pRemoteLoop = NULL;
|
||
|
||
OUTPUT ("Starting TestLoop\n");
|
||
|
||
// create our interface to pass to the remote object.
|
||
hRes = CoCreateInstance(CLSID_LoopSrv, NULL, CLSCTX_LOCAL_SERVER,
|
||
IID_ILoop, (void **)&pLocalLoop);
|
||
TEST_FAILED_EXIT(FAILED(hRes), "CoCreateInstance First failed\n")
|
||
|
||
// create the remote object
|
||
hRes = CoCreateInstance(CLSID_LoopSrv, NULL, CLSCTX_LOCAL_SERVER,
|
||
IID_ILoop, (void **)&pRemoteLoop);
|
||
TEST_FAILED_EXIT(FAILED(hRes), "CoCreateInstance Second failed\n")
|
||
|
||
// initialize the two instances
|
||
OUTPUT (" - Initializing Instances\n");
|
||
hRes = pLocalLoop->Init(pRemoteLoop);
|
||
TEST_FAILED_EXIT(FAILED(hRes), "Initialize First failed\n")
|
||
hRes = pRemoteLoop->Init(pLocalLoop);
|
||
TEST_FAILED_EXIT(FAILED(hRes), "Initialize Second failed\n")
|
||
|
||
// now start the test
|
||
OUTPUT (" - Running LoopTest\n");
|
||
hRes = pLocalLoop->Loop(10);
|
||
TEST_FAILED(FAILED(hRes), "Loop failed\n")
|
||
|
||
// uninitialize the two instances
|
||
OUTPUT (" - Uninitializing Instances\n");
|
||
hRes = pLocalLoop->Uninit();
|
||
TEST_FAILED_EXIT(FAILED(hRes), "Uninitialize First failed\n")
|
||
hRes = pRemoteLoop->Uninit();
|
||
TEST_FAILED_EXIT(FAILED(hRes), "Uninitialize Second failed\n")
|
||
|
||
Cleanup:
|
||
|
||
// release the two instances
|
||
OUTPUT (" - Releasing Instances\n");
|
||
|
||
if (pRemoteLoop)
|
||
pRemoteLoop->Release();
|
||
|
||
if (pLocalLoop)
|
||
pLocalLoop->Release();
|
||
|
||
return TestResult(RetVal, "TestLoop");
|
||
}
|
||
|
||
// ----------------------------------------------------------------------
|
||
//
|
||
// TestMultiQINormal
|
||
//
|
||
// tests IMultiQI interface on Normal proxies
|
||
//
|
||
// ----------------------------------------------------------------------
|
||
|
||
ULONG cMisc = 4;
|
||
const IID *iidMisc[] = {
|
||
&IID_IParseDisplayName, &IID_IPersistStorage,
|
||
&IID_IPersistFile, &IID_IStorage,
|
||
&IID_IOleContainer, &IID_IOleItemContainer,
|
||
&IID_IOleInPlaceSite, &IID_IOleInPlaceActiveObject,
|
||
&IID_IOleInPlaceObject, &IID_IOleInPlaceUIWindow,
|
||
&IID_IOleInPlaceFrame, &IID_IOleWindow};
|
||
|
||
MULTI_QI arMQI[20];
|
||
MULTI_QI *pMQIResStart = arMQI;
|
||
|
||
BOOL TestMultiQINormal(void)
|
||
{
|
||
BOOL RetVal = TRUE;
|
||
HRESULT hRes = S_OK;
|
||
IUnknown *pUnk = NULL;
|
||
IUnknown *pUnk2 = NULL;
|
||
IMultiQI *pMQI = NULL;
|
||
ULONG i = 0, j=0, cRefs = 0;
|
||
MULTI_QI *pMQIRes = NULL;
|
||
|
||
// ----------------------------------------------------------------------
|
||
ULONG cSupported = 4;
|
||
const IID *iidSupported[] = {&IID_IUnknown, &IID_IMultiQI,
|
||
&IID_IClientSecurity, &IID_IMarshal,
|
||
&IID_IStdIdentity, &IID_IProxyManager};
|
||
|
||
ULONG cUnSupported = 2;
|
||
const IID *iidUnSupported[] = {&IID_IInternalUnknown,
|
||
&IID_IServerSecurity};
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
OUTPUT ("Starting TestMultiQINormal\n");
|
||
|
||
// create our interface to pass to the remote object.
|
||
hRes = CoCreateInstance(CLSID_QI, NULL, CLSCTX_LOCAL_SERVER,
|
||
IID_IUnknown, (void **)&pUnk);
|
||
TEST_FAILED_EXIT(FAILED(hRes), "CoCreateInstance QISRV failed\n")
|
||
|
||
VerifyObjRefCnt(pUnk, 1);
|
||
VerifyRHRefCnt(pUnk, 1);
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
OUTPUT ("\n - NormalQI for supported interfaces\n");
|
||
|
||
// loop through all the supported interfaces doing a normal QI.
|
||
|
||
for (i=0; i<cSupported; i++)
|
||
{
|
||
hRes = pUnk->QueryInterface(*iidSupported[i], (void **)&pUnk2);
|
||
TEST_FAILED(FAILED(hRes), "QueryInterface on supported interfaces failed\n")
|
||
if (SUCCEEDED(hRes))
|
||
{
|
||
// release the interface
|
||
VerifyObjRefCnt(pUnk, 2);
|
||
VerifyRHRefCnt(pUnk, 2);
|
||
|
||
OUTPUT (" - QI for supported interface OK\n");
|
||
pUnk2->Release();
|
||
}
|
||
}
|
||
|
||
|
||
OUTPUT ("\n - NormalQI for unsupported interfaces\n");
|
||
|
||
// loop through all the unsupported interfaces doing a normal QI.
|
||
|
||
for (i=0; i<cUnSupported; i++)
|
||
{
|
||
hRes = pUnk->QueryInterface(*iidUnSupported[i], (void **)&pUnk2);
|
||
TEST_FAILED(SUCCEEDED(hRes), "QueryInterface on unsupported interface succeeded but should have failed\n")
|
||
|
||
if (SUCCEEDED(hRes))
|
||
{
|
||
// release the interface
|
||
pUnk2->Release();
|
||
}
|
||
else
|
||
{
|
||
VerifyObjRefCnt(pUnk, 1);
|
||
VerifyRHRefCnt(pUnk, 1);
|
||
|
||
OUTPUT (" - QI for unsupported interface OK.\n");
|
||
}
|
||
}
|
||
|
||
// should be back to normal (IUnknown)
|
||
VerifyObjRefCnt(pUnk, 1);
|
||
VerifyRHRefCnt(pUnk, 1);
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
hRes = pUnk->QueryInterface(IID_IMultiQI, (void **)&pMQI);
|
||
TEST_FAILED_EXIT(FAILED(hRes), "QI for IMultiQI failed\n")
|
||
VerifyObjRefCnt(pUnk, 2);
|
||
VerifyRHRefCnt(pUnk, 2);
|
||
|
||
|
||
OUTPUT ("\n - MultiQI for supported interfaces\n");
|
||
|
||
// now issue a MultiQI for the supported interfaces
|
||
pMQIRes = pMQIResStart;
|
||
for (i=0; i<cSupported; i++, pMQIRes++)
|
||
{
|
||
pMQIRes->pIID = iidSupported[i];
|
||
pMQIRes->pItf = NULL;
|
||
}
|
||
|
||
pMQIRes = pMQIResStart;
|
||
hRes = pMQI->QueryMultipleInterfaces(cSupported, pMQIRes);
|
||
TEST_FAILED(hRes != S_OK, "QueryMultipleInterfaces should have return S_OK\n")
|
||
VerifyObjRefCnt(pUnk, 2 + cSupported);
|
||
VerifyRHRefCnt(pUnk, 2 + cSupported);
|
||
|
||
for (i=0; i<cSupported; i++, pMQIRes++)
|
||
{
|
||
TEST_FAILED(pMQIRes->pItf == NULL, "QueryMultipleInterfaces on supported interfaces returned NULL\n")
|
||
TEST_FAILED(FAILED(pMQIRes->hr), "QueryMultipleInterfaces on supported interfaces failed\n")
|
||
|
||
if (pMQIRes->pItf != NULL)
|
||
{
|
||
OUTPUT (" - MultiQI for supported interface OK\n");
|
||
pMQIRes->pItf->Release();
|
||
|
||
VerifyObjRefCnt(pUnk, 2 + cSupported - (i+1));
|
||
VerifyRHRefCnt(pUnk, 2 + cSupported - (i+1));
|
||
}
|
||
}
|
||
|
||
// should be back to normal (IUnknown + IMultiQI)
|
||
VerifyObjRefCnt(pUnk, 2);
|
||
VerifyRHRefCnt(pUnk, 2);
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
OUTPUT ("\n - MultiQI for unsupported interfaces\n");
|
||
|
||
// now issue a MultiQI for the unsupported interfaces
|
||
pMQIRes = pMQIResStart;
|
||
for (i=0; i<cUnSupported; i++, pMQIRes++)
|
||
{
|
||
pMQIRes->pIID = iidUnSupported[i];
|
||
pMQIRes->pItf = NULL;
|
||
}
|
||
|
||
pMQIRes = pMQIResStart;
|
||
hRes = pMQI->QueryMultipleInterfaces(cUnSupported, pMQIRes);
|
||
TEST_FAILED(hRes != E_NOINTERFACE, "QueryMultipleInterfaces should have return E_NOINTERFACES\n")
|
||
VerifyObjRefCnt(pUnk, 2);
|
||
VerifyRHRefCnt(pUnk, 2);
|
||
|
||
for (i=0; i<cUnSupported; i++, pMQIRes++)
|
||
{
|
||
TEST_FAILED(pMQIRes->pItf != NULL, "QueryMultipleInterfaces on supported interfaces returned NULL\n")
|
||
TEST_FAILED(SUCCEEDED(pMQIRes->hr), "QueryMultipleInterfaces on supported interfaces failed\n")
|
||
|
||
if (pMQIRes->pItf != NULL)
|
||
{
|
||
pMQIRes->pItf->Release();
|
||
}
|
||
else
|
||
{
|
||
OUTPUT (" - MultiQI for unsupported interface OK\n");
|
||
}
|
||
}
|
||
|
||
// should back to normal refcnts (IUnknown + IMultiQI)
|
||
VerifyObjRefCnt(pUnk, 2);
|
||
VerifyRHRefCnt(pUnk, 2);
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
// repeat this test twice, first time goes remote for the misc interfaces,
|
||
// second time finds them already instantiated.
|
||
|
||
for (j=0; j<2; j++)
|
||
{
|
||
OUTPUT ("\n - MultiQI for combination of interfaces\n");
|
||
|
||
pMQIRes = pMQIResStart;
|
||
for (i=0; i<cMisc; i++, pMQIRes++)
|
||
{
|
||
pMQIRes->pIID = iidMisc[i];
|
||
pMQIRes->pItf = NULL;
|
||
}
|
||
|
||
for (i=0; i<cSupported; i++, pMQIRes++)
|
||
{
|
||
pMQIRes->pIID = iidSupported[i];
|
||
pMQIRes->pItf = NULL;
|
||
}
|
||
|
||
for (i=0; i<cUnSupported; i++, pMQIRes++)
|
||
{
|
||
pMQIRes->pIID = iidUnSupported[i];
|
||
pMQIRes->pItf = NULL;
|
||
}
|
||
|
||
pMQIRes = pMQIResStart;
|
||
hRes = pMQI->QueryMultipleInterfaces(cSupported + cUnSupported + cMisc, pMQIRes);
|
||
TEST_FAILED(hRes != S_FALSE, "QueryMultipleInterfaces should have return S_FALSE\n")
|
||
VerifyObjRefCnt(pUnk, 2 + cSupported + cMisc);
|
||
VerifyRHRefCnt(pUnk, 2 + cSupported + cMisc);
|
||
|
||
for (i=0; i<cMisc; i++, pMQIRes++)
|
||
{
|
||
TEST_FAILED(pMQIRes->pItf == NULL, "QueryMultipleInterfaces on supported interfaces returned NULL\n")
|
||
TEST_FAILED(FAILED(pMQIRes->hr), "QueryMultipleInterfaces on supported interfaces failed\n")
|
||
|
||
if (pMQIRes->pItf != NULL)
|
||
{
|
||
OUTPUT (" - MultiQI for supported remote interface OK\n");
|
||
pMQIRes->pItf->Release();
|
||
|
||
VerifyObjRefCnt(pUnk, 2 + cSupported + cMisc - (i+1));
|
||
VerifyRHRefCnt(pUnk, 2 + cSupported + cMisc - (i+1));
|
||
}
|
||
}
|
||
|
||
for (i=0; i<cSupported; i++, pMQIRes++)
|
||
{
|
||
TEST_FAILED(pMQIRes->pItf == NULL, "QueryMultipleInterfaces on supported interfaces returned NULL\n")
|
||
TEST_FAILED(FAILED(pMQIRes->hr), "QueryMultipleInterfaces on supported interfaces failed\n")
|
||
|
||
if (pMQIRes->pItf != NULL)
|
||
{
|
||
OUTPUT (" - MultiQI for supported local interface OK\n");
|
||
pMQIRes->pItf->Release();
|
||
|
||
VerifyObjRefCnt(pUnk, 2 + cSupported - (i+1));
|
||
VerifyRHRefCnt(pUnk, 2 + cSupported - (i+1));
|
||
}
|
||
}
|
||
|
||
for (i=0; i<cUnSupported; i++, pMQIRes++)
|
||
{
|
||
TEST_FAILED(pMQIRes->pItf != NULL, "QueryMultipleInterfaces on supported interfaces returned NULL\n")
|
||
TEST_FAILED(SUCCEEDED(pMQIRes->hr), "QueryMultipleInterfaces on supported interfaces failed\n")
|
||
|
||
if (pMQIRes->pItf != NULL)
|
||
{
|
||
pMQIRes->pItf->Release();
|
||
}
|
||
else
|
||
{
|
||
OUTPUT (" - MultiQI for unsupported local interface OK\n");
|
||
}
|
||
}
|
||
|
||
// should back to normal refcnts (IUnknown + IMultiQI)
|
||
VerifyObjRefCnt(pUnk, 2);
|
||
VerifyRHRefCnt(pUnk, 2);
|
||
|
||
} // for (j=...)
|
||
|
||
// ----------------------------------------------------------------------
|
||
Cleanup:
|
||
|
||
// release the two instances
|
||
OUTPUT (" - Releasing Instances\n");
|
||
|
||
if (pMQI)
|
||
{
|
||
pMQI->Release();
|
||
}
|
||
|
||
if (pUnk)
|
||
{
|
||
cRefs = pUnk->Release();
|
||
TEST_FAILED(cRefs != 0, "Last release not zero\n");
|
||
}
|
||
|
||
return TestResult(RetVal, "TestMultiQINormal");
|
||
}
|
||
|
||
// ----------------------------------------------------------------------
|
||
//
|
||
// TestMultiQIHandler
|
||
//
|
||
// tests IMultiQI interface on Handlers
|
||
//
|
||
// ----------------------------------------------------------------------
|
||
BOOL TestMultiQIHandler(void)
|
||
{
|
||
BOOL RetVal = TRUE;
|
||
HRESULT hRes = S_OK;
|
||
IUnknown *pUnk = NULL;
|
||
IUnknown *pUnk2 = NULL;
|
||
ULONG i = 0;
|
||
MULTI_QI *pMQIRes = NULL;
|
||
|
||
// ----------------------------------------------------------------------
|
||
ULONG cSupported = 4;
|
||
const IID *iidSupported[] = {&IID_IUnknown, &IID_IMarshal,
|
||
&IID_IStdIdentity, &IID_IProxyManager};
|
||
|
||
ULONG cUnSupported = 4;
|
||
const IID *iidUnSupported[] = {&IID_IInternalUnknown, &IID_IClientSecurity,
|
||
&IID_IServerSecurity, &IID_IMultiQI};
|
||
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
OUTPUT ("Starting TestMultiQIHandler\n");
|
||
|
||
// create our interface to pass to the remote object.
|
||
hRes = CoCreateInstance(CLSID_QIHANDLER1, NULL, CLSCTX_LOCAL_SERVER,
|
||
IID_IUnknown, (void **)&pUnk);
|
||
TEST_FAILED_EXIT(FAILED(hRes), "CoCreateInstance QIHANDLER1 failed\n")
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
OUTPUT ("\n - NormalQI for supported interfaces\n");
|
||
|
||
// loop through all the supported interfaces doing a normal QI.
|
||
|
||
for (i=0; i<cSupported; i++)
|
||
{
|
||
hRes = pUnk->QueryInterface(*iidSupported[i], (void **)&pUnk2);
|
||
TEST_FAILED(FAILED(hRes), "QueryInterface on supported interfaces failed\n")
|
||
if (SUCCEEDED(hRes))
|
||
{
|
||
// release the interface
|
||
OUTPUT (" - QI for supported interface OK\n");
|
||
pUnk2->Release();
|
||
}
|
||
}
|
||
|
||
OUTPUT ("\n - NormalQI for unsupported interfaces\n");
|
||
|
||
// loop through all the unsupported interfaces doing a normal QI.
|
||
|
||
for (i=0; i<cUnSupported; i++)
|
||
{
|
||
hRes = pUnk->QueryInterface(*iidUnSupported[i], (void **)&pUnk2);
|
||
TEST_FAILED(SUCCEEDED(hRes), "QueryInterface on unsupported interface succeeded but should have failed\n")
|
||
|
||
if (SUCCEEDED(hRes))
|
||
{
|
||
// release the interface
|
||
pUnk2->Release();
|
||
}
|
||
else
|
||
{
|
||
OUTPUT (" - QI for unsupported interface OK.\n");
|
||
}
|
||
}
|
||
// ----------------------------------------------------------------------
|
||
Cleanup:
|
||
|
||
// release the two instances
|
||
OUTPUT (" - Releasing Instances\n");
|
||
|
||
if (pUnk)
|
||
pUnk->Release();
|
||
|
||
return TestResult(RetVal, "TestMultiQIHandler");
|
||
}
|
||
|
||
|
||
// ----------------------------------------------------------------------
|
||
//
|
||
// TestHandler
|
||
//
|
||
// tests activating a server that has a handler
|
||
//
|
||
// ----------------------------------------------------------------------
|
||
|
||
BOOL TestHandler(void)
|
||
{
|
||
BOOL RetVal = TRUE;
|
||
ULONG cRefs = 0;
|
||
HRESULT hRes = S_OK;
|
||
IUnknown *pUnkSrv = NULL;
|
||
IUnknown *pUnkHdl = NULL;
|
||
IRunnableObject *pIRO = NULL;
|
||
IOleObject *pIOO = NULL;
|
||
IDropTarget *pIDT = NULL;
|
||
|
||
|
||
OUTPUT ("Starting TestHandler\n");
|
||
|
||
// create our interface to pass to the remote object.
|
||
hRes = CoCreateInstance(CLSID_TestEmbed, NULL, CLSCTX_LOCAL_SERVER,
|
||
IID_IUnknown, (void **)&pUnkSrv);
|
||
TEST_FAILED_EXIT(FAILED(hRes), "CoCreateInstance LOCAL_SERVER failed\n")
|
||
VerifyObjRefCnt(pUnkSrv, 1);
|
||
OUTPUT (" - CoCreateInstance LOCAL_SERVER succeeded\n");
|
||
|
||
OUTPUT (" - QI for IRunnableObject\n");
|
||
hRes = pUnkSrv->QueryInterface(IID_IRunnableObject, (void **)&pIRO);
|
||
TEST_FAILED(SUCCEEDED(hRes), "QI for IRO on LOCAL_SERVER succeeded\n")
|
||
|
||
if (pIRO)
|
||
{
|
||
pIRO->Release();
|
||
pIRO = NULL;
|
||
}
|
||
|
||
OUTPUT (" - Releasing Instance\n");
|
||
if (pUnkSrv)
|
||
{
|
||
cRefs = pUnkSrv->Release();
|
||
TEST_FAILED(cRefs != 0, "REFCNT wrong on Release\n")
|
||
pUnkSrv = NULL;
|
||
}
|
||
OUTPUT (" - LOCAL_SERVER case complete\n");
|
||
|
||
// ----------------------------------------------------------------------
|
||
// create the remote object
|
||
|
||
hRes = CoCreateInstance(CLSID_TestEmbed, NULL, CLSCTX_INPROC_HANDLER,
|
||
IID_IUnknown, (void **)&pUnkHdl);
|
||
TEST_FAILED_EXIT(FAILED(hRes), "CoCreateInstance INPROC_HANDLER failed\n")
|
||
VerifyObjRefCnt(pUnkHdl, 1);
|
||
VerifyRHRefCnt(pUnkHdl, 1);
|
||
OUTPUT (" - CoCreateInstance INPROC_HANDLER succeeded\n");
|
||
|
||
// ----------------------------------------------------------------------
|
||
// query for some unsupported interface to ensure OLE handles QI
|
||
// when not yet connected to the server.
|
||
|
||
OUTPUT (" - QI for IDropTarget\n");
|
||
hRes = pUnkHdl->QueryInterface(IID_IDropTarget, (void **)&pIDT);
|
||
VerifyObjRefCnt(pUnkHdl, 1);
|
||
VerifyRHRefCnt(pUnkHdl, 1);
|
||
TEST_FAILED_EXIT(SUCCEEDED(hRes),
|
||
"QI for IDropTarget on INPROC_HANDLER worked but should have failed!\n")
|
||
|
||
// the return value from failed QI on a handler that was never connected
|
||
// must be E_NOINTERFACE
|
||
TEST_FAILED_EXIT(hRes != E_NOINTERFACE,
|
||
"QI for IDropTarget on INPROC_HANDLER did not return E_NOINTERFACE!\n")
|
||
|
||
OUTPUT (" - Query for remote Interface before connected OK.\n");
|
||
|
||
// ----------------------------------------------------------------------
|
||
// run the remote server
|
||
|
||
OUTPUT (" - QI for IRunnableObject\n");
|
||
hRes = pUnkHdl->QueryInterface(IID_IRunnableObject, (void **)&pIRO);
|
||
VerifyObjRefCnt(pUnkHdl, 2);
|
||
VerifyRHRefCnt(pUnkHdl, 2);
|
||
TEST_FAILED_EXIT(FAILED(hRes), "QI for IRO on INPROC_HANDLER failed\n")
|
||
|
||
hRes = pIRO->Run(NULL);
|
||
VerifyObjRefCnt(pUnkHdl, 2);
|
||
VerifyRHRefCnt(pUnkHdl, 2);
|
||
TEST_FAILED(FAILED(hRes), "IRO->Run on INPROC_HANDLER failed\n")
|
||
OUTPUT (" - INPROC_HANDLER run OK\n");
|
||
|
||
// ----------------------------------------------------------------------
|
||
// test stoping the server
|
||
|
||
OUTPUT (" - Stop the Server\n");
|
||
hRes = pUnkHdl->QueryInterface(IID_IOleObject, (void **)&pIOO);
|
||
VerifyObjRefCnt(pUnkHdl, 3);
|
||
VerifyRHRefCnt(pUnkHdl, 3);
|
||
|
||
TEST_FAILED_EXIT(FAILED(hRes), "QI for IOleObject on INPROC_HANDLER failed\n")
|
||
|
||
hRes = pIOO->Close(OLECLOSE_NOSAVE);
|
||
VerifyObjRefCnt(pUnkHdl, 3);
|
||
VerifyRHRefCnt(pUnkHdl, 3);
|
||
|
||
TEST_FAILED(FAILED(hRes), "IOO->Close on INPROC_HANDLER failed\n")
|
||
pIOO->Release();
|
||
pIOO = NULL;
|
||
VerifyObjRefCnt(pUnkHdl, 2);
|
||
VerifyRHRefCnt(pUnkHdl, 2);
|
||
OUTPUT (" - INPROC_HANDLER Close OK\n");
|
||
|
||
// ----------------------------------------------------------------------
|
||
// query again for some unsupported interface to ensure OLE handles QI
|
||
// when disconnected from the server.
|
||
|
||
OUTPUT (" - QI for IDropTarget\n");
|
||
hRes = pUnkHdl->QueryInterface(IID_IDropTarget, (void **)&pIDT);
|
||
VerifyObjRefCnt(pUnkHdl, 2);
|
||
VerifyRHRefCnt(pUnkHdl, 2);
|
||
TEST_FAILED_EXIT(SUCCEEDED(hRes),
|
||
"QI for IDropTarget on disconnected INPROC_HANDLER worked but should have failed!\n")
|
||
|
||
// the return value from failed QI on a handler that has been disconnected
|
||
// must be CO_O_OBJNOTCONNECTED
|
||
|
||
TEST_FAILED_EXIT(hRes != CO_E_OBJNOTCONNECTED,
|
||
"QI for IDropTarget on INPROC_HANDLER did not return CO_E_OBJNOTCONNECTED!\n")
|
||
|
||
OUTPUT (" - Query for remote Interface after disconnected OK.\n");
|
||
|
||
// ----------------------------------------------------------------------
|
||
// test restarting the server
|
||
|
||
Sleep(500);
|
||
OUTPUT (" - Run the Server Again\n");
|
||
hRes = pIRO->Run(NULL);
|
||
VerifyObjRefCnt(pUnkHdl, 2);
|
||
VerifyRHRefCnt(pUnkHdl, 2);
|
||
|
||
TEST_FAILED(FAILED(hRes), "Second IRO->Run on INPROC_HANDLER failed\n")
|
||
OUTPUT (" - Second INPROC_HANDLER Run OK\n");
|
||
|
||
// ----------------------------------------------------------------------
|
||
// test stoping the server
|
||
|
||
OUTPUT (" - Stop the Server\n");
|
||
hRes = pUnkHdl->QueryInterface(IID_IOleObject, (void **)&pIOO);
|
||
VerifyObjRefCnt(pUnkHdl, 3);
|
||
VerifyRHRefCnt(pUnkHdl, 3);
|
||
|
||
TEST_FAILED_EXIT(FAILED(hRes), "QI for IOleObject on INPROC_HANDLER failed\n")
|
||
|
||
hRes = pIOO->Close(OLECLOSE_NOSAVE);
|
||
VerifyObjRefCnt(pUnkHdl, 3);
|
||
VerifyRHRefCnt(pUnkHdl, 3);
|
||
|
||
TEST_FAILED(FAILED(hRes), "IOO->Close on INPROC_HANDLER failed\n")
|
||
pIOO->Release();
|
||
pIOO = NULL;
|
||
VerifyObjRefCnt(pUnkHdl, 2);
|
||
VerifyRHRefCnt(pUnkHdl, 2);
|
||
OUTPUT (" - INPROC_HANDLER Close OK\n");
|
||
|
||
// ----------------------------------------------------------------------
|
||
// test using weak references
|
||
|
||
OUTPUT (" - Call OleSetContainedObject TRUE\n");
|
||
hRes = OleSetContainedObject(pUnkHdl, 1);
|
||
TEST_FAILED(FAILED(hRes), "1st OleSetContainedObject on pUnkHdl failed\n")
|
||
OUTPUT (" - OleSetContainedObject OK\n");
|
||
|
||
Sleep(500);
|
||
OUTPUT (" - Run the Server Again\n");
|
||
hRes = pIRO->Run(NULL);
|
||
VerifyObjRefCnt(pUnkHdl, 2);
|
||
VerifyRHRefCnt(pUnkHdl, 2);
|
||
|
||
TEST_FAILED(FAILED(hRes), "Third IRO->Run on INPROC_HANDLER failed\n")
|
||
OUTPUT (" - Third INPROC_HANDLER Run OK\n");
|
||
|
||
// try making the references strong again
|
||
OUTPUT (" - Call OleSetContainedObject FALSE\n");
|
||
hRes = OleSetContainedObject(pUnkHdl, 0);
|
||
TEST_FAILED(FAILED(hRes), "2nd OleSetContainedObject on pUnkHdl failed\n")
|
||
OUTPUT (" - OleSetContainedObject OK\n");
|
||
|
||
// try making the references weak again
|
||
OUTPUT (" - Call OleSetContainedObject TRUE\n");
|
||
hRes = OleSetContainedObject(pUnkHdl, 1);
|
||
TEST_FAILED(FAILED(hRes), "3rd OleSetContainedObject on pUnkHdl failed\n")
|
||
OUTPUT (" - OleSetContainedObject OK\n");
|
||
|
||
// ----------------------------------------------------------------------
|
||
// cleanup
|
||
|
||
pIRO->Release();
|
||
pIRO = NULL;
|
||
VerifyObjRefCnt(pUnkHdl, 1);
|
||
VerifyRHRefCnt(pUnkHdl, 1);
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
OUTPUT (" - Releasing Instance\n");
|
||
if (pUnkHdl)
|
||
{
|
||
cRefs = pUnkHdl->Release();
|
||
TEST_FAILED(cRefs != 0, "REFCNT wrong on Release\n")
|
||
pUnkHdl = NULL;
|
||
}
|
||
OUTPUT (" - INPROC_HANDLER case complete\n");
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
Cleanup:
|
||
|
||
// release the two instances
|
||
OUTPUT (" - Test Complete. Doing Cleanup\n");
|
||
|
||
if (pIDT)
|
||
{
|
||
pIDT->Release();
|
||
}
|
||
|
||
if (pIRO)
|
||
{
|
||
pIRO->Release();
|
||
}
|
||
|
||
if (pIOO)
|
||
{
|
||
pIOO->Release();
|
||
}
|
||
|
||
if (pUnkSrv)
|
||
{
|
||
pUnkSrv->Release();
|
||
}
|
||
|
||
if (pUnkHdl)
|
||
{
|
||
pUnkHdl->Release();
|
||
}
|
||
|
||
return TestResult(RetVal, "TestHandler");
|
||
}
|
||
|
||
// ----------------------------------------------------------------------
|
||
//
|
||
// TestGetStandardMarshal
|
||
//
|
||
// test CoGetStandardMarshal API
|
||
//
|
||
// ----------------------------------------------------------------------
|
||
|
||
BOOL TestGetStandardMarshal(void)
|
||
{
|
||
BOOL RetVal = TRUE;
|
||
HRESULT hres;
|
||
ULONG ulRefCnt;
|
||
IMarshal *pIM = NULL, *pIM2 = NULL;
|
||
IStream *pStm;
|
||
IUnknown *punkIn = NULL;
|
||
IUnknown *punkOut = NULL;
|
||
|
||
|
||
LARGE_INTEGER large_int;
|
||
LISet32(large_int, 0);
|
||
|
||
OUTPUT ("Starting TestGetStandardMarshal\n");
|
||
|
||
punkIn = GetTestUnk();
|
||
TEST_FAILED_EXIT((punkIn == NULL), "new CTestUnk failed\n")
|
||
VerifyObjRefCnt(punkIn, 1);
|
||
|
||
pStm = CreateMemStm(600, NULL);
|
||
TEST_FAILED_EXIT((pStm == NULL), "CreateMemStm failed\n")
|
||
VerifyObjRefCnt((IUnknown *)pStm, 1);
|
||
|
||
// ----------------------------------------------------------------------
|
||
hres = CoGetStandardMarshal(IID_IUnknown, punkIn, 0, NULL, MSHLFLAGS_NORMAL, &pIM);
|
||
TEST_FAILED_EXIT(FAILED(hres), "CoGetStandardMarshal failed\n")
|
||
VerifyRHRefCnt(punkIn, 1);
|
||
|
||
hres = CoGetStandardMarshal(IID_IUnknown, punkIn, 0, NULL, MSHLFLAGS_NORMAL, &pIM2);
|
||
TEST_FAILED_EXIT(FAILED(hres), "second CoGetStandardMarshal failed\n")
|
||
VerifyRHRefCnt(punkIn, 2);
|
||
|
||
TEST_FAILED((pIM != pIM2), "CoGetStandardMarshal returned two different interfaces.\n")
|
||
ulRefCnt = pIM2->Release();
|
||
TEST_FAILED_EXIT(ulRefCnt != 1, "pIM2 RefCnt is wrong");
|
||
pIM2 = NULL;
|
||
|
||
hres = CoGetStandardMarshal(IID_IUnknown, NULL, 0, NULL, MSHLFLAGS_NORMAL, &pIM2);
|
||
TEST_FAILED_EXIT(FAILED(hres), "third CoGetStandardMarshal failed\n")
|
||
VerifyRHRefCnt(punkIn, 1);
|
||
|
||
OUTPUT (" - CoGetStandardMarshal OK\n");
|
||
|
||
// ----------------------------------------------------------------------
|
||
hres = pIM->MarshalInterface(pStm, IID_IUnknown, punkIn, 0, NULL, MSHLFLAGS_NORMAL);
|
||
TEST_FAILED_EXIT(FAILED(hres), "MarshalInterface failed\n")
|
||
|
||
hres = pStm->Seek(large_int, STREAM_SEEK_SET, NULL);
|
||
TEST_FAILED_EXIT(FAILED(hres), "Seek on shared stream failed\n")
|
||
|
||
// since we are unmarshalling in the same process, the RH should go away.
|
||
hres = pIM->UnmarshalInterface(pStm, IID_IUnknown, (LPVOID FAR*)&punkOut);
|
||
TEST_FAILED_EXIT(FAILED(hres), "UnmarshalInterface failed\n")
|
||
VerifyRHRefCnt(punkIn, 1);
|
||
|
||
// make sure the interface pointers are identical
|
||
if (punkIn != punkOut)
|
||
TEST_FAILED_EXIT(TRUE, "Interface ptrs dont match...1st Local Unmarshal\n")
|
||
OUTPUT (" - UnmarshalInterface OK\n");
|
||
|
||
// release interface and make sure it does not go away - refcnt > 0
|
||
ulRefCnt = punkOut->Release();
|
||
TEST_FAILED_EXIT(ulRefCnt == 0, "punkOut RefCnt is zero");
|
||
punkOut = NULL;
|
||
OUTPUT (" - Release OK\n");
|
||
|
||
|
||
// ----------------------------------------------------------------------
|
||
hres = pStm->Seek(large_int, STREAM_SEEK_SET, NULL);
|
||
TEST_FAILED_EXIT(FAILED(hres), "Seek on shared stream failed\n")
|
||
|
||
hres = pIM->MarshalInterface(pStm, IID_IUnknown, punkIn, 0, NULL, MSHLFLAGS_NORMAL);
|
||
TEST_FAILED_EXIT(FAILED(hres), "MarshalInterface failed\n")
|
||
|
||
hres = pStm->Seek(large_int, STREAM_SEEK_SET, NULL);
|
||
TEST_FAILED_EXIT(FAILED(hres), "Seek on shared stream failed\n")
|
||
|
||
// since we are unmarshalling in the same process, the RH should go away.
|
||
hres = pIM2->UnmarshalInterface(pStm, IID_IUnknown, (LPVOID FAR*)&punkOut);
|
||
TEST_FAILED_EXIT(FAILED(hres), "UnmarshalInterface failed\n")
|
||
VerifyRHRefCnt(punkIn, 1);
|
||
|
||
// make sure the interface pointers are identical
|
||
if (punkIn != punkOut)
|
||
TEST_FAILED_EXIT(TRUE, "Interface ptrs dont match...1st Local Unmarshal\n")
|
||
OUTPUT (" - Second UnmarshalInterface OK\n");
|
||
|
||
// release interface and make sure it does not go away - refcnt > 0
|
||
ulRefCnt = punkOut->Release();
|
||
TEST_FAILED_EXIT(ulRefCnt == 0, "punkOut RefCnt is zero");
|
||
punkOut = NULL;
|
||
OUTPUT (" - Release OK\n");
|
||
|
||
ulRefCnt = pIM2->Release();
|
||
TEST_FAILED_EXIT(ulRefCnt == 0, "pIM2 RefCnt is zero");
|
||
pIM2 = NULL;
|
||
OUTPUT (" - Release OK\n");
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
// release the marshalled data
|
||
hres = pStm->Seek(large_int, STREAM_SEEK_SET, NULL);
|
||
TEST_FAILED_EXIT(FAILED(hres), "Seek on shared stream failed\n")
|
||
|
||
hres = pIM->MarshalInterface(pStm, IID_IUnknown, punkIn, 0, NULL, MSHLFLAGS_NORMAL);
|
||
TEST_FAILED_EXIT(FAILED(hres), "MarshalInterface failed\n")
|
||
|
||
hres = pStm->Seek(large_int, STREAM_SEEK_SET, NULL);
|
||
TEST_FAILED_EXIT(FAILED(hres), "Seek on shared stream failed\n")
|
||
|
||
hres = pIM->ReleaseMarshalData(pStm);
|
||
TEST_FAILED_EXIT(FAILED(hres), "Release Marshal Data failed\n.");
|
||
OUTPUT (" - ReleaseMarshalData OK\n");
|
||
|
||
|
||
// the RH should go away, and we should have only the original
|
||
// refcnt from creation left on the object.
|
||
ulRefCnt = pIM->Release();
|
||
TEST_FAILED_EXIT(ulRefCnt != 0, "pIM RefCnt not zero");
|
||
pIM = NULL;
|
||
|
||
// release the original object
|
||
ulRefCnt = punkIn->Release();
|
||
TEST_FAILED_EXIT(ulRefCnt != 0, "punkIn RefCnt not zero");
|
||
punkIn = NULL;
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
Cleanup:
|
||
|
||
OUTPUT (" - Test Complete. Doing Cleanup\n");
|
||
|
||
// Dump interfaces we are done with
|
||
if (pStm)
|
||
{
|
||
ulRefCnt = pStm->Release();
|
||
TEST_FAILED(ulRefCnt != 0, "Stream RefCnt not zero\n");
|
||
}
|
||
|
||
if (punkOut)
|
||
{
|
||
ulRefCnt = punkOut->Release();
|
||
TEST_FAILED(ulRefCnt != 0, "punkOut RefCnt not zero\n");
|
||
}
|
||
|
||
if (punkIn)
|
||
{
|
||
ulRefCnt = punkIn->Release();
|
||
TEST_FAILED(ulRefCnt != 0, "punkIn RefCnt not zero\n");
|
||
}
|
||
|
||
return TestResult(RetVal, "TestGetStandardMarshal");
|
||
}
|
||
|
||
|
||
|
||
// ----------------------------------------------------------------------
|
||
//
|
||
// TestLockObjectExternal
|
||
//
|
||
// test CoLockObjectExternal API
|
||
//
|
||
// ----------------------------------------------------------------------
|
||
|
||
BOOL TestLockObjectExternal(void)
|
||
{
|
||
BOOL RetVal = TRUE;
|
||
HRESULT hres;
|
||
ULONG ulRefCnt;
|
||
IUnknown *punkIn = NULL;
|
||
IStream *pStm = NULL;
|
||
|
||
OUTPUT ("Starting TestLockObjectExternal\n");
|
||
|
||
punkIn = GetTestUnk();
|
||
TEST_FAILED_EXIT((punkIn == NULL), "new CTestUnk failed\n")
|
||
VerifyObjRefCnt(punkIn, 1);
|
||
|
||
|
||
// ----------------------------------------------------------------------
|
||
// test calling it once, then releasing it once
|
||
|
||
hres = CoLockObjectExternal(punkIn, TRUE, FALSE);
|
||
TEST_FAILED_EXIT(FAILED(hres), "CoLockObjectExternal failed.\n")
|
||
VerifyRHRefCnt(punkIn, 1);
|
||
VerifyObjRefCnt(punkIn, 2);
|
||
OUTPUT (" - CoLockObjectExternal TRUE OK\n");
|
||
|
||
hres = CoLockObjectExternal(punkIn, FALSE, FALSE);
|
||
TEST_FAILED_EXIT(FAILED(hres), "second CoLockObjectExternal failed\n")
|
||
VerifyRHRefCnt(punkIn, 0);
|
||
VerifyObjRefCnt(punkIn, 1);
|
||
OUTPUT (" - CoLockObjectExternal FALSE OK\n");
|
||
|
||
// ----------------------------------------------------------------------
|
||
// test calling it twice, then releasing it twice
|
||
|
||
// the first AddRef inc's the StrongCnt, the RH, and the real object.
|
||
hres = CoLockObjectExternal(punkIn, TRUE, FALSE);
|
||
TEST_FAILED_EXIT(FAILED(hres), "CoLockObjectExternal failed.\n")
|
||
VerifyRHRefCnt(punkIn, 1);
|
||
VerifyObjRefCnt(punkIn, 2);
|
||
OUTPUT (" - CoLockObjectExternal TRUE OK\n");
|
||
|
||
// the second AddRef inc's the StrongCnt and the RH, but not the
|
||
// real object.
|
||
hres = CoLockObjectExternal(punkIn, TRUE, FALSE);
|
||
TEST_FAILED_EXIT(FAILED(hres), "CoLockObjectExternal failed.\n")
|
||
VerifyRHRefCnt(punkIn, 2);
|
||
VerifyObjRefCnt(punkIn, 2);
|
||
OUTPUT (" - CoLockObjectExternal TRUE OK\n");
|
||
|
||
// the second release Dec's the StrongCnt and the RH, but not the
|
||
// real object.
|
||
hres = CoLockObjectExternal(punkIn, FALSE, FALSE);
|
||
TEST_FAILED_EXIT(FAILED(hres), "second CoLockObjectExternal failed\n")
|
||
VerifyRHRefCnt(punkIn, 1);
|
||
VerifyObjRefCnt(punkIn, 2);
|
||
OUTPUT (" - CoLockObjectExternal FALSE OK\n");
|
||
|
||
// the last Release dec's the StrongCnt, the RH, and the real object.
|
||
hres = CoLockObjectExternal(punkIn, FALSE, FALSE);
|
||
TEST_FAILED_EXIT(FAILED(hres), "second CoLockObjectExternal failed\n")
|
||
VerifyRHRefCnt(punkIn, 0);
|
||
VerifyObjRefCnt(punkIn, 1);
|
||
OUTPUT (" - CoLockObjectExternal FALSE OK\n");
|
||
|
||
// ----------------------------------------------------------------------
|
||
// test calling it once, then releasing the punkIn and ensuring
|
||
// the object is still alive.
|
||
|
||
hres = CoLockObjectExternal(punkIn, TRUE, FALSE);
|
||
TEST_FAILED_EXIT(FAILED(hres), "CoLockObjectExternal failed.\n")
|
||
VerifyRHRefCnt(punkIn, 1);
|
||
VerifyObjRefCnt(punkIn, 2);
|
||
OUTPUT (" - CoLockObjectExternal TRUE OK\n");
|
||
|
||
ulRefCnt = punkIn->Release();
|
||
TEST_FAILED(ulRefCnt != 1, "Release returned incorrect value.\n");
|
||
VerifyRHRefCnt(punkIn, 1);
|
||
OUTPUT (" - punkIn->Release OK\n");
|
||
|
||
hres = CoLockObjectExternal(punkIn, FALSE, FALSE);
|
||
TEST_FAILED_EXIT(FAILED(hres), "second CoLockObjectExternal failed\n")
|
||
punkIn = NULL;
|
||
OUTPUT (" - CoLockObjectExternal FALSE OK\n");
|
||
|
||
// ----------------------------------------------------------------------
|
||
// test calling marshal interface, followed by CLOE(F,T). This
|
||
// should disconnect the object. This is bizarre backward compatibility
|
||
// semantics that some LOTUS apps do rely on.
|
||
|
||
punkIn = GetTestUnk();
|
||
TEST_FAILED_EXIT((punkIn == NULL), "new CTestUnk failed\n")
|
||
VerifyObjRefCnt(punkIn, 1);
|
||
|
||
pStm = CreateMemStm(600, NULL);
|
||
TEST_FAILED_EXIT((pStm == NULL), "CreateMemStm failed\n")
|
||
VerifyObjRefCnt((IUnknown *)pStm, 1);
|
||
|
||
hres = CoMarshalInterface(pStm, IID_IUnknown, punkIn, 0, NULL,
|
||
MSHLFLAGS_TABLESTRONG);
|
||
TEST_FAILED_EXIT(FAILED(hres), "CoMarshalInterface failed\n")
|
||
VerifyRHRefCnt(punkIn, 1);
|
||
OUTPUT (" - CoMarshalInterface TABLE_STRONG OK\n");
|
||
|
||
hres = CoLockObjectExternal(punkIn, FALSE, TRUE);
|
||
TEST_FAILED_EXIT(FAILED(hres), "CoLockObjectExternal(F,T) failed\n")
|
||
VerifyObjRefCnt(punkIn, 1);
|
||
VerifyRHRefCnt(punkIn, 0);
|
||
OUTPUT (" - CoLockObjectExternal FALSE TRUE OK\n");
|
||
|
||
|
||
hres = CoMarshalInterface(pStm, IID_IUnknown, punkIn, 0, NULL,
|
||
MSHLFLAGS_NORMAL);
|
||
TEST_FAILED_EXIT(FAILED(hres), "CoMarshalInterface failed\n")
|
||
VerifyRHRefCnt(punkIn, 1);
|
||
OUTPUT (" - CoMarshalInterface NORMAL OK\n");
|
||
|
||
hres = CoLockObjectExternal(punkIn, FALSE, TRUE);
|
||
TEST_FAILED_EXIT(FAILED(hres), "CoLockObjectExternal(F,T) failed\n")
|
||
VerifyObjRefCnt(punkIn, 1);
|
||
VerifyRHRefCnt(punkIn, 0);
|
||
OUTPUT (" - CoLockObjectExternal FALSE TRUE OK\n");
|
||
|
||
|
||
hres = CoMarshalInterface(pStm, IID_IUnknown, punkIn, 0, NULL,
|
||
MSHLFLAGS_TABLEWEAK);
|
||
TEST_FAILED_EXIT(FAILED(hres), "CoMarshalInterface failed\n")
|
||
VerifyRHRefCnt(punkIn, 1);
|
||
OUTPUT (" - CoMarshalInterface TABLEWEAK OK\n");
|
||
|
||
// BUGBUG: refcnts seem to be wrong on the following call:
|
||
|
||
hres = CoLockObjectExternal(punkIn, FALSE, TRUE);
|
||
TEST_FAILED_EXIT(FAILED(hres), "CoLockObjectExternal(F,T) failed\n")
|
||
VerifyObjRefCnt(punkIn, 1);
|
||
VerifyRHRefCnt(punkIn, 0);
|
||
OUTPUT (" - CoLockObjectExternal FALSE TRUE OK\n");
|
||
|
||
punkIn->Release();
|
||
punkIn = NULL;
|
||
|
||
Cleanup:
|
||
|
||
OUTPUT (" - Test Complete. Doing Cleanup\n");
|
||
|
||
// Dump interfaces we are done with
|
||
if (punkIn)
|
||
{
|
||
ulRefCnt = punkIn->Release();
|
||
TEST_FAILED(ulRefCnt != 0, "punkIn RefCnt not zero\n");
|
||
}
|
||
|
||
if (pStm)
|
||
{
|
||
pStm->Release();
|
||
}
|
||
|
||
return TestResult(RetVal, "TestLockObjectExternal");
|
||
}
|
||
|
||
|
||
// ----------------------------------------------------------------------
|
||
//
|
||
// TestReleaseMarshalData
|
||
//
|
||
// test CoReleaseMarshalData API
|
||
//
|
||
// ----------------------------------------------------------------------
|
||
|
||
BOOL TestReleaseMarshalData(void)
|
||
{
|
||
BOOL RetVal = TRUE;
|
||
HRESULT hres;
|
||
ULONG cRefs;
|
||
IUnknown *punkIn = NULL;
|
||
IStream *pStm = NULL;
|
||
LARGE_INTEGER large_int;
|
||
|
||
|
||
OUTPUT ("Starting TestReleaseMarshalData\n");
|
||
|
||
punkIn = GetTestUnk();
|
||
TEST_FAILED_EXIT((punkIn == NULL), "new CTestUnk failed\n")
|
||
VerifyObjRefCnt(punkIn, 1);
|
||
|
||
// Create a shared memory stream for the marshaled object
|
||
pStm = CreateMemStm(600, NULL);
|
||
TEST_FAILED_EXIT((pStm == NULL), "CreateMemStm failed\n")
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
// try RMD on NORMAL marshal
|
||
|
||
hres = CoMarshalInterface(pStm, IID_IUnknown, punkIn, 0, NULL, MSHLFLAGS_NORMAL);
|
||
TEST_FAILED_EXIT(FAILED(hres), "CoMarshalInterface failed.\n")
|
||
VerifyRHRefCnt(punkIn, 1);
|
||
VerifyObjRefCnt(punkIn, 2);
|
||
OUTPUT (" - MarshalInterface NORMAL OK\n");
|
||
|
||
LISet32(large_int, 0);
|
||
hres = pStm->Seek(large_int, STREAM_SEEK_SET, NULL);
|
||
TEST_FAILED_EXIT(FAILED(hres), "Seek on shared stream failed\n")
|
||
|
||
hres = CoReleaseMarshalData(pStm);
|
||
TEST_FAILED_EXIT(FAILED(hres), "CoReleaseMarshalData failed.\n")
|
||
VerifyRHRefCnt(punkIn, 0);
|
||
VerifyObjRefCnt(punkIn, 1);
|
||
OUTPUT (" - CoReleaseMarshalData NORMAL OK\n");
|
||
|
||
|
||
// try RMD on TABLESTRONG marshal
|
||
|
||
LISet32(large_int, 0);
|
||
hres = pStm->Seek(large_int, STREAM_SEEK_SET, NULL);
|
||
TEST_FAILED_EXIT(FAILED(hres), "Seek on shared stream failed\n")
|
||
|
||
hres = CoMarshalInterface(pStm, IID_IUnknown, punkIn, 0, NULL, MSHLFLAGS_TABLESTRONG);
|
||
TEST_FAILED_EXIT(FAILED(hres), "CoMarshalInterface failed.\n")
|
||
VerifyRHRefCnt(punkIn, 1);
|
||
VerifyObjRefCnt(punkIn, 2);
|
||
OUTPUT (" - MarshalInterface TABLESTRONG OK\n");
|
||
|
||
LISet32(large_int, 0);
|
||
hres = pStm->Seek(large_int, STREAM_SEEK_SET, NULL);
|
||
TEST_FAILED_EXIT(FAILED(hres), "Seek on shared stream failed\n")
|
||
|
||
hres = CoReleaseMarshalData(pStm);
|
||
TEST_FAILED_EXIT(FAILED(hres), "CoReleaseMarshalData failed.\n")
|
||
VerifyRHRefCnt(punkIn, 0);
|
||
VerifyObjRefCnt(punkIn, 1);
|
||
OUTPUT (" - CoReleaseMarshalData TABLESTRONG OK\n");
|
||
|
||
// try RMD on TABLEWEAK marshal
|
||
|
||
|
||
LISet32(large_int, 0);
|
||
hres = pStm->Seek(large_int, STREAM_SEEK_SET, NULL);
|
||
TEST_FAILED_EXIT(FAILED(hres), "Seek on shared stream failed\n")
|
||
|
||
hres = CoMarshalInterface(pStm, IID_IUnknown, punkIn, 0, NULL, MSHLFLAGS_TABLEWEAK);
|
||
TEST_FAILED_EXIT(FAILED(hres), "CoMarshalInterface failed.\n")
|
||
VerifyRHRefCnt(punkIn, 1);
|
||
VerifyObjRefCnt(punkIn, 2);
|
||
OUTPUT (" - MarshalInterface TABLEWEAK OK\n");
|
||
|
||
LISet32(large_int, 0);
|
||
hres = pStm->Seek(large_int, STREAM_SEEK_SET, NULL);
|
||
TEST_FAILED_EXIT(FAILED(hres), "Seek on shared stream failed\n")
|
||
|
||
hres = CoReleaseMarshalData(pStm);
|
||
TEST_FAILED_EXIT(FAILED(hres), "CoReleaseMarshalData failed.\n")
|
||
VerifyRHRefCnt(punkIn, 0);
|
||
VerifyObjRefCnt(punkIn, 1);
|
||
OUTPUT (" - CoReleaseMarshalData TABLEWEAK OK\n");
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
Cleanup:
|
||
|
||
OUTPUT (" - Test Complete. Doing Cleanup\n");
|
||
|
||
// Dump interfaces we are done with
|
||
if (punkIn)
|
||
{
|
||
cRefs = punkIn->Release();
|
||
TEST_FAILED(cRefs != 0, "punkIn RefCnt not zero\n");
|
||
}
|
||
|
||
if (pStm)
|
||
{
|
||
pStm->Release();
|
||
}
|
||
|
||
return TestResult(RetVal, "TestReleaseMarshalData");
|
||
}
|
||
|
||
|
||
|
||
// ----------------------------------------------------------------------
|
||
//
|
||
// TestDisconnectObject
|
||
//
|
||
// test CoDisconnectObject API
|
||
//
|
||
// ----------------------------------------------------------------------
|
||
|
||
BOOL TestDisconnectObject(void)
|
||
{
|
||
BOOL RetVal = TRUE;
|
||
HRESULT hres;
|
||
ULONG ulRefCnt;
|
||
IUnknown *punkIn = NULL;
|
||
IStream *pStm = NULL;
|
||
LARGE_INTEGER large_int;
|
||
|
||
|
||
OUTPUT ("Starting TestDisconnectObject\n");
|
||
|
||
punkIn = GetTestUnk();
|
||
TEST_FAILED_EXIT((punkIn == NULL), "new CTestUnk failed\n")
|
||
VerifyObjRefCnt(punkIn, 1);
|
||
|
||
// Create a shared memory stream for the marshaled object
|
||
pStm = CreateMemStm(600, NULL);
|
||
TEST_FAILED_EXIT((pStm == NULL), "CreateMemStm failed\n")
|
||
|
||
// ----------------------------------------------------------------------
|
||
// test calling it without having ever marshalled it.
|
||
|
||
hres = CoDisconnectObject(punkIn, 0);
|
||
TEST_FAILED_EXIT(FAILED(hres), "CoDisconnectObject succeeded but should have failed.\n")
|
||
VerifyRHRefCnt(punkIn, 0);
|
||
VerifyObjRefCnt(punkIn, 1);
|
||
|
||
OUTPUT (" - first CoDisconnectObject OK\n");
|
||
|
||
|
||
// test calling after having marshalled it.
|
||
|
||
hres = CoMarshalInterface(pStm, IID_IUnknown, punkIn, 0, NULL, MSHLFLAGS_TABLEWEAK);
|
||
TEST_FAILED_EXIT(FAILED(hres), "CoMarshalInterface failed.\n")
|
||
VerifyRHRefCnt(punkIn, 1);
|
||
VerifyObjRefCnt(punkIn, 2);
|
||
|
||
OUTPUT (" - CoMarshalInterface OK\n");
|
||
|
||
hres = CoDisconnectObject(punkIn, 0);
|
||
TEST_FAILED_EXIT(FAILED(hres), "second CoDisconnectObject failed\n")
|
||
VerifyRHRefCnt(punkIn, 0);
|
||
VerifyObjRefCnt(punkIn, 1);
|
||
|
||
OUTPUT (" - second CoDisconnectObject OK\n");
|
||
|
||
// now release the marshalled data
|
||
|
||
LISet32(large_int, 0);
|
||
hres = pStm->Seek(large_int, STREAM_SEEK_SET, NULL);
|
||
TEST_FAILED_EXIT(FAILED(hres), "Seek on shared stream failed\n")
|
||
|
||
hres = CoReleaseMarshalData(pStm);
|
||
TEST_FAILED_EXIT(FAILED(hres), "CoReleaseMarshalData failed.\n")
|
||
VerifyRHRefCnt(punkIn, 0);
|
||
VerifyObjRefCnt(punkIn, 1);
|
||
|
||
OUTPUT (" - CoReleaseMarshalData OK\n");
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
Cleanup:
|
||
|
||
OUTPUT (" - Test Complete. Doing Cleanup\n");
|
||
|
||
// Dump interfaces we are done with
|
||
if (punkIn)
|
||
{
|
||
ulRefCnt = punkIn->Release();
|
||
TEST_FAILED(ulRefCnt != 0, "punkIn RefCnt not zero\n");
|
||
}
|
||
|
||
if (pStm)
|
||
{
|
||
pStm->Release();
|
||
}
|
||
|
||
return TestResult(RetVal, "TestDisconnectObject");
|
||
}
|
||
|
||
// ----------------------------------------------------------------------
|
||
//
|
||
// TestOXIDs
|
||
//
|
||
// tests A calling B calling A calling B etc n times, to see if Rpc
|
||
// can handle this.
|
||
//
|
||
// ----------------------------------------------------------------------
|
||
BOOL TestExpiredOXIDs(void)
|
||
{
|
||
BOOL RetVal = TRUE;
|
||
HRESULT hRes = S_OK;
|
||
ILoop *pLocalLoop = NULL;
|
||
IClassFactory *pUnk = NULL;
|
||
|
||
OUTPUT ("Starting TestExpiredOXIDs\n");
|
||
|
||
// start the local server process manually so it stays alive for the
|
||
// duration of the test (even though we dont have an OXIDEntry for it.
|
||
|
||
STARTUPINFO startupInfo;
|
||
PROCESS_INFORMATION processInfo;
|
||
memset(&processInfo, 0, sizeof(processInfo));
|
||
memset(&startupInfo, 0, sizeof(startupInfo));
|
||
|
||
RetVal = CreateProcess(TEXT("ballsrv.exe"),
|
||
NULL, // command line
|
||
NULL, // security for process
|
||
NULL, // security for thread
|
||
FALSE, // inherit handles
|
||
NORMAL_PRIORITY_CLASS,
|
||
NULL, // environment block
|
||
NULL, // current directory
|
||
&startupInfo,
|
||
&processInfo);
|
||
|
||
if (RetVal == FALSE)
|
||
{
|
||
hRes = GetLastError();
|
||
OUTPUT (" - CreateProcess Failed\n");
|
||
}
|
||
else
|
||
{
|
||
// give the process time to register its class object
|
||
Sleep(2000);
|
||
}
|
||
|
||
for (ULONG i=0; i<7; i++)
|
||
{
|
||
// create a new instance of a local server that is already running,
|
||
// causing us to reuse the same OXID.
|
||
|
||
hRes = CoGetClassObject(CLSID_Balls,
|
||
CLSCTX_LOCAL_SERVER,
|
||
NULL, // pvReserved
|
||
IID_IClassFactory,
|
||
(void **)&pUnk);
|
||
|
||
TEST_FAILED_EXIT(FAILED(hRes), "CoGetClassObject ballsrv failed\n")
|
||
|
||
// release interface (lets OXIDEntry be placed on the expired list)
|
||
pUnk->Release();
|
||
pUnk = NULL;
|
||
|
||
for (ULONG j=0; j<i; j++)
|
||
{
|
||
// create (i) new instances of another class and release them
|
||
// right away. This causes (i) new processes to start and (i)
|
||
// entries of the OXID table expired list to get flushed.
|
||
|
||
hRes = CoCreateInstance(CLSID_LoopSrv, NULL, CLSCTX_LOCAL_SERVER,
|
||
IID_ILoop, (void **)&pLocalLoop);
|
||
TEST_FAILED_EXIT(FAILED(hRes), "CoCreateInstance First failed\n")
|
||
pLocalLoop->Release();
|
||
pLocalLoop = NULL;
|
||
}
|
||
}
|
||
|
||
Cleanup:
|
||
|
||
// release the two instances
|
||
OUTPUT (" - Releasing Instances\n");
|
||
|
||
if (pUnk)
|
||
pUnk->Release();
|
||
|
||
if (pLocalLoop)
|
||
pLocalLoop->Release();
|
||
|
||
// kill the server process
|
||
if (processInfo.hProcess != 0)
|
||
{
|
||
BOOL fKill = TerminateProcess(processInfo.hProcess, 0);
|
||
if (!fKill)
|
||
{
|
||
hRes = GetLastError();
|
||
OUTPUT (" - TermintateProcess Failed\n");
|
||
}
|
||
|
||
CloseHandle(processInfo.hThread);
|
||
CloseHandle(processInfo.hProcess);
|
||
}
|
||
|
||
return TestResult(RetVal, "TestExpiredOXIDs");
|
||
}
|
||
|
||
|
||
|
||
|
||
// ----------------------------------------------------------------------
|
||
//
|
||
// TestAggregate
|
||
//
|
||
// tests creating an RH that is aggregated.
|
||
//
|
||
// ----------------------------------------------------------------------
|
||
|
||
BOOL TestAggregate(void)
|
||
{
|
||
BOOL RetVal = TRUE;
|
||
HRESULT hRes = S_OK;
|
||
IUnknown *punkOuter = NULL;
|
||
IUnknown *pUnk = NULL;
|
||
IBalls *pIBall = NULL;
|
||
ULONG ulRefCnt = 0;
|
||
|
||
OUTPUT ("Starting TestAggregate\n");
|
||
|
||
punkOuter = GetTestUnk();
|
||
TEST_FAILED_EXIT((punkOuter == NULL), "new CTestUnk failed\n")
|
||
VerifyObjRefCnt(punkOuter, 1);
|
||
|
||
// create our interface to pass to the remote object.
|
||
hRes = CoCreateInstance(CLSID_Balls, punkOuter, CLSCTX_LOCAL_SERVER,
|
||
IID_IUnknown, (void **)&pUnk);
|
||
TEST_FAILED_EXIT(FAILED(hRes), "CoCreateInstance First failed\n")
|
||
|
||
// now release the object
|
||
ulRefCnt = pUnk->Release();
|
||
TEST_FAILED_EXIT(ulRefCnt != 0, "Release failed\n")
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
// create our interface to pass to the remote object.
|
||
hRes = CoCreateInstance(CLSID_Balls, punkOuter, CLSCTX_LOCAL_SERVER,
|
||
IID_IUnknown, (void **)&pUnk);
|
||
TEST_FAILED_EXIT(FAILED(hRes), "CoCreateInstance First failed\n")
|
||
|
||
hRes = pUnk->QueryInterface(IID_IBalls, (void **)&pIBall);
|
||
TEST_FAILED_EXIT(FAILED(hRes), "QueryInterface failed\n")
|
||
|
||
// now release the interface
|
||
ulRefCnt = pIBall->Release();
|
||
TEST_FAILED_EXIT(ulRefCnt == 0, "Release failed\n")
|
||
|
||
// now release the object
|
||
ulRefCnt = pUnk->Release();
|
||
TEST_FAILED_EXIT(ulRefCnt != 0, "Release failed\n")
|
||
|
||
// now release the punkOuter
|
||
ulRefCnt = punkOuter->Release();
|
||
TEST_FAILED_EXIT(ulRefCnt != 0, "Release failed\n")
|
||
|
||
Cleanup:
|
||
|
||
OUTPUT (" - Test Complete. Doing Cleanup\n");
|
||
|
||
return TestResult(RetVal, "TestAggregate");
|
||
}
|
||
|
||
|
||
|
||
// ----------------------------------------------------------------------
|
||
//
|
||
// TestCreateRemoteHandler
|
||
//
|
||
// test CoCreateRemoteHandler API and unmarshalling data into it.
|
||
//
|
||
// ----------------------------------------------------------------------
|
||
|
||
BOOL TestCreateRemoteHandler(void)
|
||
{
|
||
BOOL RetVal = TRUE;
|
||
HRESULT hres;
|
||
ULONG ulRefCnt;
|
||
IUnknown *punkBall = NULL;
|
||
IUnknown *punkOuter = NULL;
|
||
IClassFactory *pICF = NULL;
|
||
|
||
|
||
OUTPUT ("Starting TestCreateRemoteHandler\n");
|
||
|
||
|
||
// create the controlling unknown for the remote object.
|
||
punkOuter = GetTestUnk();
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
// create a remote object that we will aggregate.
|
||
|
||
// Create an IBall ClassFactory Interface.
|
||
DWORD grfContext=CLSCTX_LOCAL_SERVER; // handler/server/local server
|
||
hres = CoGetClassObject(CLSID_Balls,
|
||
grfContext,
|
||
NULL, // pvReserved
|
||
IID_IClassFactory,
|
||
(void **)&pICF);
|
||
|
||
TEST_FAILED_EXIT(FAILED(hres), "CoGetClassObject Balls failed\n")
|
||
TEST_FAILED_EXIT((pICF == NULL), "CoGetClassObject Balls failed\n")
|
||
OUTPUT (" - Aquired Remote Balls Class Object.\n");
|
||
VerifyObjRefCnt(pICF, 1);
|
||
VerifyRHRefCnt(pICF, 1);
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
// note, since pICF is a class object, it has special super secret
|
||
// behaviour to make it go away. create an instance, release the
|
||
// class object, then release the instance.
|
||
|
||
hres = pICF->CreateInstance(punkOuter, IID_IUnknown, (void **)&punkBall);
|
||
TEST_FAILED_EXIT(FAILED(hres), "CreateInstance failed\n")
|
||
TEST_FAILED_EXIT((punkBall == NULL), "CreateInstance failed\n")
|
||
OUTPUT (" - Created Balls Instance.\n");
|
||
|
||
VerifyObjRefCnt(punkBall, 1);
|
||
VerifyRHRefCnt(punkBall, 1);
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
// release class object
|
||
ulRefCnt = pICF->Release();
|
||
TEST_FAILED(ulRefCnt != 0, "pICF RefCnt not zero\n");
|
||
pICF = NULL;
|
||
OUTPUT (" - Released Balls Class Object.\n");
|
||
|
||
// release the remote object handler
|
||
ulRefCnt = punkBall->Release();
|
||
TEST_FAILED_EXIT(ulRefCnt != 0, "punkBall RefCnt not zero");
|
||
punkBall = NULL;
|
||
|
||
// release the outer
|
||
ulRefCnt = punkOuter->Release();
|
||
TEST_FAILED_EXIT(ulRefCnt != 0, "punkOuter RefCnt not zero");
|
||
punkOuter = NULL;
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
Cleanup:
|
||
|
||
OUTPUT (" - Test Complete. Doing Cleanup\n");
|
||
|
||
if (punkBall)
|
||
{
|
||
ulRefCnt = punkBall->Release();
|
||
TEST_FAILED(ulRefCnt != 0, "punkBall RefCnt not zero\n");
|
||
}
|
||
|
||
if (punkOuter)
|
||
{
|
||
ulRefCnt = punkOuter->Release();
|
||
TEST_FAILED(ulRefCnt != 0, "punkOuter RefCnt not zero\n");
|
||
}
|
||
|
||
return TestResult(RetVal, "TestCreateRemoteHandler");
|
||
}
|
||
|
||
|
||
// ----------------------------------------------------------------------
|
||
//
|
||
// TestTIDAndLID
|
||
//
|
||
// test the values of TID and MID to ensure they are correct across
|
||
// calls.
|
||
//
|
||
// ----------------------------------------------------------------------
|
||
HRESULT TIDAndLIDSubroutine();
|
||
DWORD _stdcall TIDAndLIDServer(void *param);
|
||
|
||
|
||
BOOL TestTIDAndLID(void)
|
||
{
|
||
BOOL RetVal = TRUE;
|
||
HRESULT hRes;
|
||
|
||
// First, try it across process boundaries.
|
||
hRes = TIDAndLIDSubroutine();
|
||
TEST_FAILED(FAILED(hRes), "TIDAndLID different process failed\n")
|
||
|
||
|
||
// Next, try it across thread boundaries.
|
||
// Spin a thread to be the server of the TIDAndLID
|
||
|
||
HANDLE hEvent[2];
|
||
hEvent[0]= CreateEvent(NULL, FALSE, FALSE, NULL);
|
||
hEvent[1]= CreateEvent(NULL, FALSE, FALSE, NULL);
|
||
|
||
DWORD dwThrdId = 0;
|
||
HANDLE hThrd = CreateThread(NULL, 0,
|
||
TIDAndLIDServer,
|
||
&hEvent[0], 0, &dwThrdId);
|
||
if (hThrd)
|
||
{
|
||
// wait for thread to register its class object
|
||
WaitForSingleObject(hEvent[0], 0xffffffff);
|
||
Sleep(0);
|
||
|
||
// Now run the whole test again. This time CoGetClassObject should
|
||
// find the server running in the other thread.
|
||
|
||
hRes = TIDAndLIDSubroutine();
|
||
TEST_FAILED(FAILED(hRes), "TIDAndLID different process failed\n")
|
||
|
||
// signal the other thread to exit
|
||
CloseHandle(hThrd);
|
||
PostThreadMessage(dwThrdId, WM_QUIT, 0, 0);
|
||
|
||
// wait for other thread to call CoUninitialize
|
||
WaitForSingleObject(hEvent[1], 0xffffffff);
|
||
CloseHandle(hEvent[0]);
|
||
CloseHandle(hEvent[1]);
|
||
}
|
||
else
|
||
{
|
||
hRes = GetLastError();
|
||
TEST_FAILED(hRes, "CreateThread failed\n")
|
||
}
|
||
|
||
return TestResult(RetVal, "TestTIDAndLID");
|
||
}
|
||
|
||
HRESULT TIDAndLIDSubroutine()
|
||
{
|
||
BOOL RetVal = TRUE;
|
||
ULONG ulRefCnt;
|
||
ICube *pCube = NULL;
|
||
IUnknown *pUnk = NULL;
|
||
HRESULT hRes;
|
||
|
||
// create our interface to pass to the remote object.
|
||
OUTPUT (" - Create Instance of ICube\n");
|
||
hRes = CoCreateInstance(CLSID_Cubes, NULL, CLSCTX_LOCAL_SERVER,
|
||
IID_ICube, (void **)&pCube);
|
||
TEST_FAILED_EXIT(FAILED(hRes), "CoCreateInstance CLSID_Cubes failed\n")
|
||
OUTPUT (" - Instance of ICubes created OK\n");
|
||
|
||
pUnk = GetTestUnk();
|
||
|
||
hRes = pCube->PrepForInputSyncCall(pUnk);
|
||
TEST_FAILED(FAILED(hRes), "pCube->PreForInputSyncCall failed\n")
|
||
|
||
hRes = pCube->InputSyncCall();
|
||
if (gInitFlag == COINIT_APARTMENTTHREADED)
|
||
{
|
||
TEST_FAILED(FAILED(hRes), "pCube->InputSyncCall failed\n")
|
||
}
|
||
else
|
||
{
|
||
TEST_FAILED(SUCCEEDED(hRes), "pCube->InputSyncCall should have failed\n")
|
||
}
|
||
OUTPUT (" - Completed Release inside InputSync call\n");
|
||
|
||
|
||
OUTPUT (" - Get the current LID information\n");
|
||
UUID lidCaller;
|
||
CoGetCurrentLogicalThreadId(&lidCaller);
|
||
|
||
OUTPUT (" - call on ICube interface\n");
|
||
hRes = pCube->SimpleCall(GetCurrentProcessId(),
|
||
GetCurrentThreadId(),
|
||
lidCaller);
|
||
|
||
TEST_FAILED(FAILED(hRes), "pCube->SimpleCall failed\n")
|
||
|
||
// release the interface
|
||
OUTPUT (" - Release the ICube interface\n");
|
||
ulRefCnt = pCube->Release();
|
||
TEST_FAILED(ulRefCnt != 0, "pCube RefCnt not zero\n");
|
||
pCube = NULL;
|
||
|
||
Cleanup:
|
||
|
||
OUTPUT (" - Subroutine Complete. Doing Cleanup\n");
|
||
|
||
if (pCube != NULL)
|
||
{
|
||
pCube->Release();
|
||
pCube = NULL;
|
||
}
|
||
|
||
return hRes;
|
||
}
|
||
|
||
// current COINIT flag used on main thread
|
||
extern DWORD gInitFlag;
|
||
|
||
DWORD _stdcall TIDAndLIDServer(void *param)
|
||
{
|
||
BOOL RetVal = TRUE;
|
||
|
||
HANDLE *pHandle = (HANDLE *) param;
|
||
|
||
HANDLE hEvent[2];
|
||
hEvent[0] = *pHandle;
|
||
hEvent[1] = *(pHandle+1);
|
||
|
||
OUTPUT (" - TIDAndLIDServer Start\n");
|
||
|
||
HRESULT hRes = CoInitializeEx(NULL, gInitFlag);
|
||
TEST_FAILED(FAILED(hRes), "TIDAndLIDServer CoInitialize failed\n")
|
||
|
||
if (SUCCEEDED(hRes))
|
||
{
|
||
DWORD dwReg;
|
||
IClassFactory *pICF = new CTestUnkCF();
|
||
|
||
if (pICF)
|
||
{
|
||
hRes = CoRegisterClassObject(CLSID_Cubes, pICF,
|
||
CLSCTX_LOCAL_SERVER,
|
||
REGCLS_MULTIPLEUSE, &dwReg);
|
||
|
||
TEST_FAILED(FAILED(hRes), "TIDAndLID CoRegisterClassObject failed\n")
|
||
SetEvent(hEvent[0]);
|
||
|
||
if (SUCCEEDED(hRes))
|
||
{
|
||
MSG msg;
|
||
while (GetMessage(&msg, NULL, 0, 0))
|
||
{
|
||
DispatchMessage(&msg);
|
||
}
|
||
|
||
hRes = CoRevokeClassObject(dwReg);
|
||
TEST_FAILED(FAILED(hRes), "TIDAndLID CoRevokeClassObject failed\n")
|
||
}
|
||
}
|
||
else
|
||
{
|
||
// set the event anyway
|
||
TEST_FAILED(TRUE, "TIDAndLID new CTestUnkCF failed\n")
|
||
SetEvent(hEvent[0]);
|
||
}
|
||
|
||
CoUninitialize();
|
||
}
|
||
else
|
||
{
|
||
// wake the other guy anyway
|
||
SetEvent(hEvent[0]);
|
||
}
|
||
|
||
// signal we've called CoUninitialize
|
||
SetEvent(hEvent[1]);
|
||
|
||
OUTPUT (" - TIDAndLIDServer done\n");
|
||
return hRes;
|
||
}
|
||
|
||
|
||
// ----------------------------------------------------------------------
|
||
//
|
||
// TestNonNDRProxy
|
||
//
|
||
// test using a non-NDR proxy and stub for ICube interface.
|
||
//
|
||
// ----------------------------------------------------------------------
|
||
BOOL TestNonNDRProxy(void)
|
||
{
|
||
BOOL RetVal = TRUE;
|
||
HRESULT hRes;
|
||
ULONG ulRefCnt;
|
||
ICube *pCube = NULL;
|
||
|
||
|
||
OUTPUT ("Starting TestNonNDR\n");
|
||
|
||
// stomp on the registry to use our custom proxy dll for ICube interface
|
||
BYTE szValueSave[MAX_PATH];
|
||
DWORD cbValue = sizeof(szValueSave);
|
||
DWORD dwType;
|
||
|
||
LONG lRes = RegQueryValueEx(HKEY_CLASSES_ROOT,
|
||
TEXT("Interface\\{00000139-0001-0008-C000-000000000046}\\ProxyStubClsid32"),
|
||
NULL,
|
||
&dwType,
|
||
szValueSave,
|
||
&cbValue);
|
||
|
||
if (lRes == ERROR_SUCCESS)
|
||
{
|
||
BYTE szValueNew[40];
|
||
strcpy((char *)&szValueNew[0], "{0000013e-0001-0008-C000-000000000046}");
|
||
|
||
lRes = RegSetValueEx(HKEY_CLASSES_ROOT,
|
||
TEXT("Interface\\{00000139-0001-0008-C000-000000000046}\\ProxyStubClsid32"),
|
||
NULL,
|
||
dwType,
|
||
szValueNew,
|
||
sizeof(szValueNew));
|
||
}
|
||
|
||
// create our interface to pass to the remote object.
|
||
OUTPUT (" - Create Instance of ICube\n");
|
||
hRes = CoCreateInstance(CLSID_Cubes, NULL, CLSCTX_LOCAL_SERVER,
|
||
IID_ICube, (void **)&pCube);
|
||
TEST_FAILED_EXIT(FAILED(hRes), "CoCreateInstance failed\n")
|
||
OUTPUT (" - Instance of ICube created OK\n");
|
||
|
||
|
||
OUTPUT (" - Make first call on ICube interface\n");
|
||
hRes = pCube->MoveCube(23, 34);
|
||
TEST_FAILED(FAILED(hRes), "ICube->MoveCube failed\n")
|
||
|
||
// release the interface
|
||
OUTPUT (" - Release the ICube interface\n");
|
||
ulRefCnt = pCube->Release();
|
||
TEST_FAILED(ulRefCnt != 0, "pCube RefCnt not zero\n");
|
||
pCube = NULL;
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
Cleanup:
|
||
|
||
OUTPUT (" - Test Complete. Doing Cleanup\n");
|
||
|
||
// restore the registry to use real proxy dll for ICube interface
|
||
if (lRes == ERROR_SUCCESS)
|
||
{
|
||
lRes = RegSetValueEx(HKEY_CLASSES_ROOT,
|
||
TEXT("Interface\\{00000139-0001-0008-C000-000000000046}\\ProxyStubClsid32"),
|
||
NULL,
|
||
dwType,
|
||
szValueSave,
|
||
cbValue);
|
||
}
|
||
|
||
return TestResult(RetVal, "TestNonNDR");
|
||
}
|
||
|
||
|
||
// ----------------------------------------------------------------------
|
||
//
|
||
// test rundown
|
||
//
|
||
// - build 9 objects
|
||
// - marshal 3 NORMAL, 3 TABLE_STRONG, 3 TABLE_WEAK.
|
||
// - start 3 clients that each do 3 things...
|
||
// Unmarshal Objects
|
||
// Call Method on each object
|
||
// Release Objects
|
||
// each client has a sleep before one of the operations to let rundown
|
||
// happen.
|
||
// - CoDisconnectObject each of the 9 objects
|
||
//
|
||
// ----------------------------------------------------------------------
|
||
BOOL TestRundown(void)
|
||
{
|
||
BOOL RetVal = TRUE;
|
||
BOOL fSame = TRUE;
|
||
ULONG k = 0;
|
||
HRESULT hres;
|
||
IStream *pstm[3] = {NULL, NULL, NULL};
|
||
IUnknown *punk[9] = {NULL, NULL, NULL,
|
||
NULL, NULL, NULL,
|
||
NULL, NULL, NULL};
|
||
|
||
DWORD mshlflags[3] = {MSHLFLAGS_NORMAL,
|
||
MSHLFLAGS_TABLESTRONG,
|
||
MSHLFLAGS_TABLEWEAK};
|
||
|
||
MSG msg;
|
||
DWORD dwEndTime;
|
||
|
||
|
||
OUTPUT ("Starting TestRundown\n");
|
||
|
||
|
||
// create 9 objects to play with
|
||
OUTPUT ("Creating Nine Objects\n");
|
||
for (ULONG i=0; i<9; i++)
|
||
{
|
||
punk[i] = GetTestUnk();
|
||
TEST_FAILED_EXIT((punk[i] == NULL), "new CTestUnk failed\n")
|
||
VerifyObjRefCnt(punk[i], 1);
|
||
}
|
||
|
||
|
||
// create 3 streams on files
|
||
OUTPUT ("Creating Three Streams\n");
|
||
for (i=0; i<3; i++)
|
||
{
|
||
pstm[i] = (IStream *) new CStreamOnFile(pwszFileName[i] ,hres, FALSE);
|
||
TEST_FAILED_EXIT((pstm[i] == NULL), "new CStreamOnFile failed\n")
|
||
TEST_FAILED_EXIT(FAILED(hres), "CStreamOnFile failed\n")
|
||
VerifyObjRefCnt(pstm[i], 1);
|
||
}
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
// marshal the nine objects into 3 different streams on files.
|
||
OUTPUT ("Marshal Nine Objects into Three Streams\n");
|
||
|
||
|
||
// loop on stream
|
||
for (i=0; i<3; i++)
|
||
{
|
||
// loop on marshal flags
|
||
for (ULONG j=0; j<3; j++)
|
||
{
|
||
hres = CoMarshalInterface(pstm[i], IID_IParseDisplayName, punk[k++],
|
||
0, NULL, mshlflags[j]);
|
||
TEST_FAILED_EXIT(FAILED(hres), "CoMarshalInterface failed\n")
|
||
}
|
||
}
|
||
|
||
|
||
// release the streams
|
||
OUTPUT ("Releasing the streams\n");
|
||
for (i=0; i<3; i++)
|
||
{
|
||
pstm[i]->Release();
|
||
pstm[i] = NULL;
|
||
}
|
||
|
||
|
||
// start the 3 client processes
|
||
OUTPUT ("Start Three Client Processes\n");
|
||
|
||
#if 0
|
||
for (i=0; i<3; i++)
|
||
{
|
||
DWORD dwThrdId = 0;
|
||
HANDLE hThrd = CreateThread(NULL, 0,
|
||
RundownClient,
|
||
(void *)i,
|
||
0, &dwThrdId);
|
||
|
||
if (hThrd)
|
||
{
|
||
CloseHandle(hThrd);
|
||
}
|
||
else
|
||
{
|
||
hres = GetLastError();
|
||
TEST_FAILED_EXIT(hres, "CreateThread failed\n")
|
||
}
|
||
}
|
||
#endif
|
||
|
||
// sleep for some time to let the clients run
|
||
OUTPUT ("Waiting 12 minutes to let clients run\n");
|
||
|
||
dwEndTime = GetTickCount() + 780000;
|
||
|
||
while (GetTickCount() < dwEndTime)
|
||
|
||
{
|
||
if (PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE))
|
||
{
|
||
if (GetMessage(&msg, NULL, 0, 0))
|
||
DispatchMessage(&msg);
|
||
}
|
||
else
|
||
{
|
||
Sleep(250);
|
||
}
|
||
}
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
Cleanup:
|
||
|
||
OUTPUT (" - Test Complete. Doing Cleanup\n");
|
||
|
||
// disconnect the nine objects
|
||
OUTPUT ("Disconnecting Nine Objects\n");
|
||
for (i=0; i<9; i++)
|
||
{
|
||
if (punk[i] != NULL)
|
||
{
|
||
hres = CoDisconnectObject(punk[i], 0);
|
||
punk[i] = NULL;
|
||
TEST_FAILED(FAILED(hres), "CoDisconnectObject failed\n")
|
||
}
|
||
}
|
||
|
||
// release the streams
|
||
OUTPUT ("Releasing the streams\n");
|
||
for (i=0; i<3; i++)
|
||
{
|
||
if (pstm[i] != NULL)
|
||
{
|
||
pstm[i]->Release();
|
||
pstm[i] = NULL;
|
||
}
|
||
}
|
||
|
||
return TestResult(RetVal, "TestRundown");
|
||
}
|
||
|
||
// ----------------------------------------------------------------------
|
||
//
|
||
// test rundown worker thread
|
||
//
|
||
// starts a thread that will do...
|
||
// Unmarshal Objects
|
||
// Call Method on each object
|
||
// Release Objects
|
||
//
|
||
// perform a sleep before one of the operations to let rundown
|
||
// happen.
|
||
//
|
||
// ----------------------------------------------------------------------
|
||
DWORD _stdcall RundownClient(void *param)
|
||
{
|
||
BOOL RetVal = TRUE;
|
||
ULONG i = 0;
|
||
HRESULT hres;
|
||
IStream *pstm = NULL;
|
||
IBindCtx *pbctx = NULL;
|
||
IParseDisplayName *punk[3] = {NULL, NULL, NULL};
|
||
|
||
|
||
OUTPUT (" Starting RundownClient\n");
|
||
|
||
// get the filename from the passed in parameter
|
||
DWORD dwThreadNum = (DWORD)param;
|
||
|
||
hres = CoInitialize(NULL);
|
||
TEST_FAILED_EXIT(FAILED(hres), "CoInitialzie failed\n")
|
||
|
||
|
||
// create a stream on the file
|
||
OUTPUT (" - CreateStreamOnFile\n");
|
||
pstm = (IStream *) new CStreamOnFile(pwszFileName[dwThreadNum], hres, TRUE);
|
||
TEST_FAILED_EXIT((pstm == NULL), "CStreamOnFile failed\n")
|
||
TEST_FAILED_EXIT(FAILED(hres), "CStreamOnFile failed\n")
|
||
VerifyObjRefCnt(pstm, 1);
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
if (dwThreadNum == 2)
|
||
Sleep(5000);
|
||
|
||
// unmarshal the interfaces
|
||
OUTPUT (" - Unmarshal the interfaces\n");
|
||
for (i=0; i<3; i++)
|
||
{
|
||
hres = CoUnmarshalInterface(pstm, IID_IParseDisplayName,
|
||
(void **)&punk[i]);
|
||
TEST_FAILED_EXIT(FAILED(hres), "CoUnmarshalInterface failed\n")
|
||
}
|
||
OUTPUT (" - Unmarshaled the interfaces OK.\n");
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
if (dwThreadNum == 1)
|
||
Sleep(5000);
|
||
|
||
hres = CreateBindCtx(0, &pbctx);
|
||
TEST_FAILED_EXIT(FAILED(hres), "CreateBindCtx failed\n")
|
||
|
||
// call the objects
|
||
for (i=0; i<3; i++)
|
||
{
|
||
ULONG cbEaten = 0;
|
||
IMoniker *pmnk = NULL;
|
||
|
||
hres = punk[i]->ParseDisplayName(pbctx, pwszFileName[dwThreadNum],
|
||
&cbEaten, &pmnk);
|
||
TEST_FAILED(FAILED(hres), "call on object failed\n")
|
||
|
||
if (pmnk)
|
||
{
|
||
pmnk->Release();
|
||
}
|
||
}
|
||
OUTPUT (" - Called the interfaces OK.\n");
|
||
|
||
pbctx->Release();
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
if (dwThreadNum == 0)
|
||
Sleep(5000);
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
Cleanup:
|
||
|
||
OUTPUT (" - Rundown Thread Complete. Doing Cleanup\n");
|
||
|
||
// release the objects
|
||
for (i=0; i<3; i++)
|
||
{
|
||
if (punk[i] != NULL)
|
||
{
|
||
punk[i]->Release();
|
||
punk[i] = NULL;
|
||
}
|
||
}
|
||
OUTPUT (" - Released the interfaces OK.\n");
|
||
|
||
// release the stream
|
||
pstm->Release();
|
||
|
||
CoUninitialize();
|
||
|
||
return TestResult(RetVal, "TestRundown");
|
||
}
|
||
|
||
|
||
|
||
// ----------------------------------------------------------------------
|
||
//
|
||
// TestMarshalStorage
|
||
//
|
||
// test marshalling a docfile
|
||
//
|
||
// ----------------------------------------------------------------------
|
||
|
||
BOOL TestMarshalStorage(void)
|
||
{
|
||
BOOL RetVal = TRUE;
|
||
HRESULT hres;
|
||
ULONG ulRefCnt;
|
||
IStorage *pStgIn = NULL;
|
||
IStorage *pStgOut = NULL;
|
||
IStream *pStm = NULL;
|
||
|
||
LARGE_INTEGER large_int;
|
||
LISet32(large_int, 0);
|
||
|
||
OUTPUT ("Starting TestMarshalStorage\n");
|
||
|
||
// create a docfile
|
||
hres = StgCreateDocfile(L"foo.bar",
|
||
STGM_READWRITE | STGM_CREATE | STGM_SHARE_EXCLUSIVE,
|
||
0, &pStgIn);
|
||
|
||
TEST_FAILED_EXIT(FAILED(hres), "StgCreateDocFile failed\n")
|
||
|
||
// create a stream to marshal the storage into
|
||
pStm = CreateMemStm(600, NULL);
|
||
TEST_FAILED_EXIT((pStm == NULL), "CreateMemStm failed\n")
|
||
VerifyObjRefCnt((IUnknown *)pStm, 1);
|
||
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
// marshal the interface
|
||
hres = CoMarshalInterface(pStm, IID_IStorage, pStgIn, 0, NULL, MSHLFLAGS_NORMAL);
|
||
TEST_FAILED_EXIT(FAILED(hres), "CoMarshalInterface failed\n")
|
||
OUTPUT (" - CoMarshalInterface OK\n");
|
||
|
||
hres = pStm->Seek(large_int, STREAM_SEEK_SET, NULL);
|
||
TEST_FAILED_EXIT(FAILED(hres), "Seek on shared stream failed\n")
|
||
|
||
// since we are unmarshalling in the same process, the RH should go away.
|
||
hres = CoUnmarshalInterface(pStm, IID_IStorage, (LPVOID FAR*)&pStgOut);
|
||
TEST_FAILED_EXIT(FAILED(hres), "CoUnmarshalInterface failed\n")
|
||
|
||
// make sure the interface pointers are identical
|
||
if (pStgIn != pStgOut)
|
||
OUTPUT("WARNING: CoUnmarshalInterface Local...ptrs dont match\n")
|
||
else
|
||
OUTPUT (" - CoUnmarshalInterface OK\n");
|
||
|
||
// release it and make sure it does not go away - refcnt > 0
|
||
ulRefCnt = pStgOut->Release();
|
||
pStgOut = NULL;
|
||
TEST_FAILED(ulRefCnt == 0, "pStgOut RefCnt is not zero");
|
||
OUTPUT (" - Release OK\n");
|
||
|
||
// the RH should have gone away, and we should have only the original
|
||
// refcnt from creation left on the object.
|
||
VerifyObjRefCnt(pStgIn, 1);
|
||
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
Cleanup:
|
||
|
||
OUTPUT (" - Test Complete. Doing Cleanup\n");
|
||
|
||
if (pStgIn)
|
||
{
|
||
ulRefCnt = pStgIn->Release();
|
||
TEST_FAILED(ulRefCnt != 0, "pStgIn RefCnt not zero\n");
|
||
}
|
||
|
||
if (pStgOut)
|
||
{
|
||
ulRefCnt = pStgOut->Release();
|
||
TEST_FAILED(ulRefCnt != 0, "pStgOut RefCnt not zero\n");
|
||
}
|
||
|
||
if (pStm)
|
||
{
|
||
ulRefCnt = pStm->Release();
|
||
TEST_FAILED(ulRefCnt != 0, "pStm RefCnt not zero\n");
|
||
}
|
||
|
||
return TestResult(RetVal, "TestMarshalStorage");
|
||
}
|
||
|
||
|
||
|
||
// ----------------------------------------------------------------------
|
||
//
|
||
// test LOCAL interface MSHLFLAGS_NORMAL, MSHCTX_DIFFERENTMACHINE
|
||
//
|
||
// ----------------------------------------------------------------------
|
||
|
||
BOOL TestStorageInterfaceDiffMachine(void)
|
||
{
|
||
BOOL RetVal = TRUE;
|
||
HRESULT hres;
|
||
LPSTREAM pStm = NULL;
|
||
ULONG ulRefCnt = 0;
|
||
IStorage *pStgIn = NULL;
|
||
IStorage *pStgOut = NULL;
|
||
|
||
LARGE_INTEGER large_int;
|
||
LISet32(large_int, 0);
|
||
|
||
OUTPUT ("Starting TestStorageInterfaceDiffMachine\n");
|
||
|
||
// create a docfile
|
||
hres = StgCreateDocfile(L"foo.bar",
|
||
STGM_READWRITE | STGM_CREATE | STGM_SHARE_EXCLUSIVE,
|
||
0, &pStgIn);
|
||
TEST_FAILED_EXIT(FAILED(hres), "CreateDocfile failed\n")
|
||
|
||
pStm = CreateMemStm(600, NULL);
|
||
TEST_FAILED_EXIT((pStm == NULL), "CreateMemStm failed\n")
|
||
VerifyObjRefCnt((IUnknown *)pStm, 1);
|
||
|
||
|
||
// ----------------------------------------------------------------------
|
||
hres = CoMarshalInterface(pStm, IID_IStorage, pStgIn,
|
||
MSHCTX_DIFFERENTMACHINE, 0,
|
||
MSHLFLAGS_NORMAL);
|
||
|
||
TEST_FAILED_EXIT(FAILED(hres), "CoMarshalInterface failed\n")
|
||
VerifyRHRefCnt(pStgIn, 1);
|
||
OUTPUT (" - CoMarshalInterface OK\n");
|
||
|
||
hres = pStm->Seek(large_int, STREAM_SEEK_SET, NULL);
|
||
TEST_FAILED_EXIT(FAILED(hres), "Seek on shared stream failed\n")
|
||
|
||
hres = CoUnmarshalInterface(pStm, IID_IStorage, (LPVOID FAR*)&pStgOut);
|
||
TEST_FAILED_EXIT(FAILED(hres), "CoUnmarshalInterface failed\n")
|
||
VerifyRHRefCnt(pStgIn, 0);
|
||
|
||
// release them
|
||
ulRefCnt = pStgOut->Release();
|
||
pStgOut = NULL;
|
||
OUTPUT (" - Release OK\n");
|
||
|
||
ulRefCnt = pStgIn->Release();
|
||
pStgIn = NULL;
|
||
OUTPUT (" - Release OK\n");
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
Cleanup:
|
||
|
||
OUTPUT (" - Test Complete. Doing Cleanup\n");
|
||
|
||
if (pStgIn)
|
||
{
|
||
ulRefCnt = pStgIn->Release();
|
||
TEST_FAILED(ulRefCnt != 0, "pStgIn RefCnt not zero\n");
|
||
}
|
||
|
||
if (pStgOut)
|
||
{
|
||
ulRefCnt = pStgOut->Release();
|
||
TEST_FAILED(ulRefCnt != 0, "pStgOut RefCnt not zero\n");
|
||
}
|
||
|
||
if (pStm)
|
||
{
|
||
ulRefCnt = pStm->Release();
|
||
TEST_FAILED(ulRefCnt != 0, "pStm RefCnt not zero\n");
|
||
}
|
||
|
||
return TestResult(RetVal, "TestStorageInterfaceDiffMachine");
|
||
}
|
||
|
||
|
||
|
||
// ----------------------------------------------------------------------
|
||
//
|
||
// test REMOTE interface MSHLFLAGS_NORMAL, MSHCTX_DIFFERENTMACHINE
|
||
//
|
||
// ----------------------------------------------------------------------
|
||
|
||
BOOL TestRemoteInterfaceDiffMachine(void)
|
||
{
|
||
BOOL RetVal = TRUE;
|
||
HRESULT hres;
|
||
LPSTREAM pStm = NULL;
|
||
LPCLASSFACTORY pICF = NULL;
|
||
ULONG ulRefCnt;
|
||
IUnknown *punkOut = NULL;
|
||
IUnknown *punkIn = NULL;
|
||
|
||
LARGE_INTEGER large_int;
|
||
LISet32(large_int, 0);
|
||
|
||
OUTPUT ("Starting TestRemoteInterfaceDifferentMachine\n");
|
||
|
||
// Create an IClassFactory Interface.
|
||
DWORD grfContext=CLSCTX_LOCAL_SERVER; // handler/server/local server
|
||
hres = CoGetClassObject(CLSID_Balls,
|
||
grfContext,
|
||
NULL, // pvReserved
|
||
IID_IClassFactory,
|
||
(void **)&pICF);
|
||
|
||
TEST_FAILED_EXIT(FAILED(hres), "CoGetClassObject failed\n")
|
||
TEST_FAILED_EXIT((pICF == NULL), "CoGetClassObject failed\n")
|
||
VerifyRHRefCnt((IUnknown *)pICF, 1);
|
||
OUTPUT (" - Aquired Remote Class Object.\n");
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
// note, since pICF is a class object, it has special super secret
|
||
// behaviour to make it go away. create an instance, release the
|
||
// class object, then release the instance.
|
||
|
||
hres = pICF->CreateInstance(NULL, IID_IUnknown, (void **)&punkIn);
|
||
TEST_FAILED_EXIT(FAILED(hres), "CreateInstance failed\n")
|
||
TEST_FAILED_EXIT((punkIn == NULL), "CreateInstance failed\n")
|
||
VerifyRHRefCnt(punkIn, 1);
|
||
OUTPUT (" - Created Instance.\n");
|
||
|
||
// release class object
|
||
ulRefCnt = pICF->Release();
|
||
TEST_FAILED(ulRefCnt != 0, "pICF RefCnt not zero\n");
|
||
// VerifyRHRefCnt((IUnknown *)pICF, 0);
|
||
pICF = NULL;
|
||
OUTPUT (" - Released Class Object.\n");
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
// Create a shared memory stream for the marshaled interface
|
||
pStm = CreateMemStm(600, NULL);
|
||
TEST_FAILED_EXIT((pStm == NULL), "CreateMemStm failed\n")
|
||
|
||
// Marshal the interface into the stream
|
||
hres = CoMarshalInterface(pStm, IID_IUnknown, punkIn,
|
||
MSHCTX_DIFFERENTMACHINE, 0,
|
||
MSHLFLAGS_NORMAL);
|
||
TEST_FAILED_EXIT(FAILED(hres), "CoMarshalInterface failed\n")
|
||
OUTPUT (" - CoMarshalInterface OK.\n");
|
||
VerifyRHRefCnt(punkIn, 1);
|
||
|
||
// unmarshal the interface. should get the same proxy back.
|
||
hres = pStm->Seek(large_int, STREAM_SEEK_SET, NULL);
|
||
TEST_FAILED_EXIT(FAILED(hres), "Seek on shared stream failed\n")
|
||
|
||
hres = CoUnmarshalInterface(pStm, IID_IUnknown, (LPVOID FAR*)&punkOut);
|
||
TEST_FAILED_EXIT(FAILED(hres), "CoUnmarshalInterface failed\n")
|
||
VerifyRHRefCnt(punkIn, 2);
|
||
|
||
// make sure the interface pointers are identical
|
||
if (punkIn != punkOut)
|
||
TEST_FAILED_EXIT(TRUE, "Interface ptrs dont match..1st Remote Unmarshal\n")
|
||
OUTPUT (" - CoUnmarshalInterface OK.\n");
|
||
|
||
|
||
// release the interface
|
||
ulRefCnt = punkOut->Release();
|
||
punkOut = NULL;
|
||
TEST_FAILED_EXIT(ulRefCnt == 0, "punkOut RefCnt is zero\n");
|
||
VerifyRHRefCnt(punkIn, 1);
|
||
OUTPUT (" - Release OK\n");
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
Cleanup:
|
||
|
||
OUTPUT (" - Test Complete. Doing Cleanup\n");
|
||
|
||
// Dump interfaces we are done with
|
||
if (pStm)
|
||
{
|
||
ulRefCnt = pStm->Release();
|
||
TEST_FAILED(ulRefCnt != 0, "Stream RefCnt not zero\n");
|
||
}
|
||
|
||
if (punkOut)
|
||
{
|
||
ulRefCnt = punkOut->Release();
|
||
TEST_FAILED(ulRefCnt != 0, "punkOut RefCnt not zero\n");
|
||
}
|
||
|
||
if (punkIn)
|
||
{
|
||
ulRefCnt = punkIn->Release();
|
||
TEST_FAILED(ulRefCnt != 0, "punkIn RefCnt not zero\n");
|
||
}
|
||
|
||
return TestResult(RetVal, "TestRemoteInterfaceDiffMachine");
|
||
}
|
||
|
||
// ----------------------------------------------------------------------
|
||
//
|
||
// test LOCAL interface MSHLFLAGS_NORMAL, MSHCTX_DIFFERENTMACHINE
|
||
//
|
||
// ----------------------------------------------------------------------
|
||
|
||
BOOL TestLocalInterfaceDiffMachine(void)
|
||
{
|
||
BOOL RetVal = TRUE;
|
||
HRESULT hres;
|
||
LPSTREAM pStm = NULL;
|
||
LPCLASSFACTORY pICF = NULL;
|
||
ULONG ulRefCnt;
|
||
IUnknown *punkOut = NULL;
|
||
IUnknown *punkIn = NULL;
|
||
|
||
LARGE_INTEGER large_int;
|
||
LISet32(large_int, 0);
|
||
|
||
OUTPUT ("Starting TestLocalInterfaceDifferentMachine\n");
|
||
|
||
punkIn = GetTestUnk();
|
||
TEST_FAILED_EXIT((punkIn == NULL), "new CTestUnk failed\n")
|
||
VerifyObjRefCnt(punkIn, 1);
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
// Create a shared memory stream for the marshaled interface
|
||
pStm = CreateMemStm(600, NULL);
|
||
TEST_FAILED_EXIT((pStm == NULL), "CreateMemStm failed\n")
|
||
|
||
// Marshal the interface into the stream
|
||
hres = CoMarshalInterface(pStm, IID_IUnknown, punkIn,
|
||
MSHCTX_DIFFERENTMACHINE, 0,
|
||
MSHLFLAGS_NORMAL);
|
||
TEST_FAILED_EXIT(FAILED(hres), "CoMarshalInterface failed\n")
|
||
OUTPUT (" - CoMarshalInterface OK.\n");
|
||
VerifyRHRefCnt(punkIn, 1);
|
||
|
||
// unmarshal the interface. should get the same proxy back.
|
||
hres = pStm->Seek(large_int, STREAM_SEEK_SET, NULL);
|
||
TEST_FAILED_EXIT(FAILED(hres), "Seek on shared stream failed\n")
|
||
|
||
hres = CoUnmarshalInterface(pStm, IID_IUnknown, (LPVOID FAR*)&punkOut);
|
||
TEST_FAILED_EXIT(FAILED(hres), "CoUnmarshalInterface failed\n")
|
||
VerifyRHRefCnt(punkIn, 0);
|
||
|
||
// make sure the interface pointers are identical
|
||
if (punkIn != punkOut)
|
||
TEST_FAILED_EXIT(TRUE, "Interface ptrs dont match..1st Local Unmarshal\n")
|
||
OUTPUT (" - CoUnmarshalInterface OK.\n");
|
||
|
||
|
||
// release the interface
|
||
ulRefCnt = punkOut->Release();
|
||
punkOut = NULL;
|
||
TEST_FAILED_EXIT(ulRefCnt == 0, "punkOut RefCnt is zero\n");
|
||
VerifyRHRefCnt(punkIn, 0);
|
||
OUTPUT (" - Release OK\n");
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
Cleanup:
|
||
|
||
OUTPUT (" - Test Complete. Doing Cleanup\n");
|
||
|
||
// Dump interfaces we are done with
|
||
if (pStm)
|
||
{
|
||
ulRefCnt = pStm->Release();
|
||
TEST_FAILED(ulRefCnt != 0, "Stream RefCnt not zero\n");
|
||
}
|
||
|
||
if (punkOut)
|
||
{
|
||
ulRefCnt = punkOut->Release();
|
||
TEST_FAILED(ulRefCnt != 0, "punkOut RefCnt not zero\n");
|
||
}
|
||
|
||
if (punkIn)
|
||
{
|
||
ulRefCnt = punkIn->Release();
|
||
TEST_FAILED(ulRefCnt != 0, "punkIn RefCnt not zero\n");
|
||
}
|
||
|
||
return TestResult(RetVal, "TestLocalInterfaceDiffMachine");
|
||
}
|
||
|
||
// ----------------------------------------------------------------------
|
||
//
|
||
// test NOPING with MSHLFLAGS NORMAL, TABLEWEAK and TABLESTRONG
|
||
//
|
||
// CodeWork: ensure SORF_FLAG set correctly.
|
||
// ensure precedence rules are followed.
|
||
// ensure protocol is followed.
|
||
//
|
||
// ----------------------------------------------------------------------
|
||
typedef struct tagNoPingThreadInfo
|
||
{
|
||
HANDLE hEvent;
|
||
IStream *pStm;
|
||
HRESULT hr;
|
||
} NoPingThreadInfo;
|
||
|
||
DWORD _stdcall NoPingThread(void *param);
|
||
|
||
BOOL TestNoPing(void)
|
||
{
|
||
BOOL RetVal = TRUE;
|
||
HRESULT hres;
|
||
LPSTREAM pStm = NULL;
|
||
ULONG ulRefCnt, i;
|
||
IUnknown *punkOut = NULL;
|
||
IUnknown *punkIn = NULL;
|
||
IUnknown *punk[5] = {NULL, NULL, NULL, NULL, NULL};
|
||
NoPingThreadInfo npInfo;
|
||
DWORD dwThrdId = 0;
|
||
HANDLE hThrd;
|
||
IMarshal *pIM = NULL;
|
||
|
||
LARGE_INTEGER large_int;
|
||
LISet32(large_int, 0);
|
||
|
||
OUTPUT ("Starting TestNoPing\n");
|
||
|
||
punkIn = GetTestUnk();
|
||
TEST_FAILED_EXIT((punkIn == NULL), "new CTestUnk failed\n")
|
||
VerifyObjRefCnt(punkIn, 1);
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
// Create a shared memory stream for the marshaled interface
|
||
pStm = CreateMemStm(600, NULL);
|
||
TEST_FAILED_EXIT((pStm == NULL), "CreateMemStm failed\n")
|
||
|
||
// marshal it NORMAL, TABLEWEAK and TABLESTRONG with the NOPING flag
|
||
// set, and unmarshal each in the server apartment.
|
||
|
||
for (i=0; i<3; i++)
|
||
{
|
||
// Marshal the interface into the stream
|
||
hres = CoMarshalInterface(pStm, IID_IUnknown, punkIn,
|
||
0, 0, (i | MSHLFLAGS_NOPING));
|
||
|
||
TEST_FAILED_EXIT(FAILED(hres), "CoMarshalInterface failed\n")
|
||
OUTPUT (" - CoMarshalInterface OK.\n");
|
||
VerifyRHRefCnt(punkIn, 1);
|
||
|
||
|
||
// verify the marshal format
|
||
hres = pStm->Seek(large_int, STREAM_SEEK_SET, NULL);
|
||
TEST_FAILED_EXIT(FAILED(hres), "Seek on shared stream failed\n")
|
||
|
||
hres = VerifyOBJREFFormat(pStm, (i | MSHLFLAGS_NOPING));
|
||
TEST_FAILED_EXIT(FAILED(hres), "VerifyOBJREFFormat failed\n")
|
||
OUTPUT (" - VerifyOBJREFFormat OK.\n");
|
||
|
||
|
||
// unmarshal the interface. should get the same proxy back.
|
||
hres = pStm->Seek(large_int, STREAM_SEEK_SET, NULL);
|
||
TEST_FAILED_EXIT(FAILED(hres), "Seek on shared stream failed\n")
|
||
|
||
hres = CoUnmarshalInterface(pStm, IID_IUnknown, (LPVOID FAR*)&punkOut);
|
||
TEST_FAILED_EXIT(FAILED(hres), "CoUnmarshalInterface failed\n")
|
||
|
||
|
||
// make sure the interface pointers are identical
|
||
if (punkIn != punkOut)
|
||
TEST_FAILED_EXIT(TRUE, "Interface ptrs dont match..1st Local Unmarshal\n")
|
||
OUTPUT (" - CoUnmarshalInterface OK.\n");
|
||
|
||
// check the refcnt on the stdid
|
||
if (i == 0)
|
||
{
|
||
// normal case, stdid should have been cleaned up
|
||
VerifyRHRefCnt(punkIn, 0);
|
||
}
|
||
else
|
||
{
|
||
// table case, stdid should still exist
|
||
VerifyRHRefCnt(punkIn, 1);
|
||
}
|
||
|
||
// release the interface
|
||
ulRefCnt = punkOut->Release();
|
||
punkOut = NULL;
|
||
|
||
TEST_FAILED_EXIT(ulRefCnt == 0, "punkOut RefCnt is zero\n");
|
||
VerifyRHRefCnt(punkIn, (i == 0) ? 0 : 1);
|
||
OUTPUT (" - Release OK\n");
|
||
|
||
if (i > 0)
|
||
{
|
||
// need to release marshal data on table marshaled interfaces
|
||
// reset the stream
|
||
hres = pStm->Seek(large_int, STREAM_SEEK_SET, NULL);
|
||
TEST_FAILED_EXIT(FAILED(hres), "Seek on shared stream failed\n")
|
||
|
||
hres = CoReleaseMarshalData(pStm);
|
||
TEST_FAILED_EXIT(FAILED(hres), "ReleaseMarshalData failed\n")
|
||
}
|
||
|
||
// reset the stream
|
||
hres = pStm->Seek(large_int, STREAM_SEEK_SET, NULL);
|
||
TEST_FAILED_EXIT(FAILED(hres), "Seek on shared stream failed\n")
|
||
}
|
||
|
||
|
||
// check the precedence rules
|
||
|
||
// Whatever an interface is first marshaled as is what sets the
|
||
// PING / NOPING flags. Marshal first as normal then noping and
|
||
// expect a normal 2nd marshal. Then marshal first as noping then
|
||
// normal and expect a noping 2nd marshal.
|
||
|
||
for (i=0; i<2; i++)
|
||
{
|
||
DWORD mshlflags1 = (i==0) ? MSHLFLAGS_NORMAL : MSHLFLAGS_NOPING;
|
||
DWORD mshlflags2 = (i==0) ? MSHLFLAGS_NOPING : MSHLFLAGS_NORMAL;
|
||
|
||
// Marshal the interface into the stream
|
||
hres = CoMarshalInterface(pStm, IID_IUnknown, punkIn,
|
||
0, 0, mshlflags1);
|
||
|
||
TEST_FAILED_EXIT(FAILED(hres), "CoMarshalInterface failed\n")
|
||
OUTPUT (" - CoMarshalInterface OK.\n");
|
||
VerifyRHRefCnt(punkIn, 1);
|
||
|
||
// verify the marshal format
|
||
hres = pStm->Seek(large_int, STREAM_SEEK_SET, NULL);
|
||
TEST_FAILED_EXIT(FAILED(hres), "Seek on shared stream failed\n")
|
||
|
||
hres = VerifyOBJREFFormat(pStm, mshlflags1);
|
||
TEST_FAILED_EXIT(FAILED(hres), "VerifyOBJREFFormat failed\n")
|
||
OUTPUT (" - VerifyOBJREFFormat OK.\n");
|
||
|
||
|
||
// marshal it again, with the opposite flags then check the value
|
||
hres = pStm->Seek(large_int, STREAM_SEEK_SET, NULL);
|
||
TEST_FAILED_EXIT(FAILED(hres), "Seek on shared stream failed\n")
|
||
|
||
hres = CoMarshalInterface(pStm, IID_IUnknown, punkIn,
|
||
0, 0, mshlflags2);
|
||
|
||
TEST_FAILED_EXIT(FAILED(hres), "CoMarshalInterface failed\n")
|
||
OUTPUT (" - CoMarshalInterface OK.\n");
|
||
VerifyRHRefCnt(punkIn, 1);
|
||
|
||
// verify the marshal format
|
||
hres = pStm->Seek(large_int, STREAM_SEEK_SET, NULL);
|
||
TEST_FAILED_EXIT(FAILED(hres), "Seek on shared stream failed\n")
|
||
|
||
hres = VerifyOBJREFFormat(pStm, mshlflags1);
|
||
TEST_FAILED_EXIT(FAILED(hres), "VerifyOBJREFFormat failed\n")
|
||
OUTPUT (" - VerifyOBJREFFormat OK.\n");
|
||
|
||
// release the marshaled data
|
||
hres = CoDisconnectObject(punkIn, 0);
|
||
TEST_FAILED_EXIT(FAILED(hres), "CoDisconnectObject failed\n")
|
||
OUTPUT (" - CoDisconnectObject OK.\n");
|
||
|
||
// reset the stream
|
||
hres = pStm->Seek(large_int, STREAM_SEEK_SET, NULL);
|
||
TEST_FAILED_EXIT(FAILED(hres), "Seek on shared stream failed\n")
|
||
|
||
|
||
|
||
// check CoGetStandardMarshal.
|
||
hres = CoGetStandardMarshal(IID_IUnknown, punkIn, 0, 0,
|
||
mshlflags1, &pIM);
|
||
TEST_FAILED_EXIT(FAILED(hres), "CoGetStandardMarshal failed\n")
|
||
OUTPUT (" - CoGetStandardMarshal OK.\n");
|
||
|
||
// Marshal the interface into the stream
|
||
hres = pIM->MarshalInterface(pStm, IID_IUnknown, punkIn,
|
||
0, 0, mshlflags2);
|
||
TEST_FAILED_EXIT(FAILED(hres), "pIM->MarshalInterface failed\n")
|
||
OUTPUT (" - pIM->MarshalInterface OK.\n");
|
||
|
||
// verify the marshal format
|
||
hres = pStm->Seek(large_int, STREAM_SEEK_SET, NULL);
|
||
TEST_FAILED_EXIT(FAILED(hres), "Seek on shared stream failed\n")
|
||
|
||
hres = VerifyOBJREFFormat(pStm, mshlflags1);
|
||
TEST_FAILED_EXIT(FAILED(hres), "VerifyOBJREFFormat failed\n")
|
||
OUTPUT (" - VerifyOBJREFFormat OK.\n");
|
||
|
||
// release the IMarshal
|
||
pIM->Release();
|
||
|
||
// release the marshal data
|
||
hres = CoDisconnectObject(punkIn, 0);
|
||
TEST_FAILED_EXIT(FAILED(hres), "CoDisconnectObject failed\n")
|
||
OUTPUT (" - CoDisconnectObject OK.\n");
|
||
|
||
// reset the stream
|
||
hres = pStm->Seek(large_int, STREAM_SEEK_SET, NULL);
|
||
TEST_FAILED_EXIT(FAILED(hres), "Seek on shared stream failed\n")
|
||
}
|
||
|
||
|
||
|
||
// marshal 3 objects, NORMAL, TABLEWEAK, and TABLESTRONG, then
|
||
// pass the stream to another apartment and unmarshal them.
|
||
|
||
for (i=0; i<3; i++)
|
||
{
|
||
punk[i] = GetTestUnk();
|
||
TEST_FAILED_EXIT((punk[i] == NULL), "new CTestUnk failed\n")
|
||
VerifyObjRefCnt(punk[i], 1);
|
||
|
||
// Marshal the interface into the stream
|
||
hres = CoMarshalInterface(pStm, IID_IUnknown, punk[i],
|
||
0, 0, (i | MSHLFLAGS_NOPING));
|
||
|
||
TEST_FAILED_EXIT(FAILED(hres), "CoMarshalInterface failed\n")
|
||
OUTPUT (" - CoMarshalInterface OK.\n");
|
||
VerifyRHRefCnt(punk[i], 1);
|
||
}
|
||
|
||
// marshal one more object, NOPING
|
||
punk[i] = GetTestUnk();
|
||
TEST_FAILED_EXIT((punk[i] == NULL), "new CTestUnk failed\n")
|
||
VerifyObjRefCnt(punk[i], 1);
|
||
|
||
// Marshal the interface into the stream
|
||
hres = CoMarshalInterface(pStm, IID_IUnknown, punk[i],
|
||
0, 0, (MSHLFLAGS_NORMAL | MSHLFLAGS_NOPING));
|
||
|
||
TEST_FAILED_EXIT(FAILED(hres), "CoMarshalInterface failed\n")
|
||
OUTPUT (" - CoMarshalInterface OK.\n");
|
||
VerifyRHRefCnt(punk[i], 1);
|
||
|
||
|
||
// marshal a second interface on the same object as PING
|
||
hres = CoMarshalInterface(pStm, IID_IParseDisplayName, punk[i],
|
||
0, 0, MSHLFLAGS_NORMAL);
|
||
|
||
TEST_FAILED_EXIT(FAILED(hres), "CoMarshalInterface failed\n")
|
||
OUTPUT (" - CoMarshalInterface OK.\n");
|
||
VerifyRHRefCnt(punk[i], 2);
|
||
|
||
|
||
// pass one more interface that does custom marshaling delegating
|
||
// to standard marshaling and replacing the PING option with NOPING.
|
||
i++;
|
||
punk[i] = (IUnknown *) new CTestUnkMarshal();
|
||
TEST_FAILED_EXIT((punk[i] == NULL), "new CTestUnkMarshal failed\n")
|
||
VerifyObjRefCnt(punk[i], 1);
|
||
|
||
// Marshal the interface into the stream
|
||
hres = CoMarshalInterface(pStm, IID_IUnknown, punk[i],
|
||
0, 0, MSHLFLAGS_NORMAL);
|
||
|
||
TEST_FAILED_EXIT(FAILED(hres), "CoMarshalInterface failed\n")
|
||
OUTPUT (" - CoMarshalInterface OK.\n");
|
||
VerifyRHRefCnt(punk[i], 2);
|
||
|
||
|
||
// reset the stream seek ptr
|
||
hres = pStm->Seek(large_int, STREAM_SEEK_SET, NULL);
|
||
TEST_FAILED_EXIT(FAILED(hres), "Seek on shared stream failed\n")
|
||
|
||
for (i=0; i<6; i++)
|
||
{
|
||
// verify the marshal format
|
||
hres = VerifyOBJREFFormat(pStm, (i | MSHLFLAGS_NOPING));
|
||
TEST_FAILED_EXIT(FAILED(hres), "VerifyOBJREFFormat failed\n")
|
||
OUTPUT (" - VerifyOBJREFFormat OK.\n");
|
||
}
|
||
|
||
// reset the stream seek ptr
|
||
hres = pStm->Seek(large_int, STREAM_SEEK_SET, NULL);
|
||
TEST_FAILED_EXIT(FAILED(hres), "Seek on shared stream failed\n")
|
||
|
||
// create thread and wait for it to complete
|
||
npInfo.hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
|
||
npInfo.pStm = pStm;
|
||
npInfo.hr = S_OK;
|
||
|
||
hThrd = CreateThread(NULL, 0, NoPingThread,
|
||
&npInfo, 0, &dwThrdId);
|
||
if (hThrd)
|
||
{
|
||
// wait for thread to register run to completetion. Note that
|
||
// we dont have to provide a message pump because with the NOPING
|
||
// flag set the other thread should never call back to get or release
|
||
// any references.
|
||
|
||
WaitForSingleObject(npInfo.hEvent, 0xffffffff);
|
||
Sleep(0);
|
||
CloseHandle(npInfo.hEvent);
|
||
|
||
// close the thread handle
|
||
CloseHandle(hThrd);
|
||
}
|
||
|
||
// cleanup the leftover objects.
|
||
for (i=0; i<5; i++)
|
||
{
|
||
hres = CoDisconnectObject(punk[i], 0);
|
||
TEST_FAILED_EXIT(FAILED(hres), "CoDisconnectObject failed\n")
|
||
OUTPUT (" - CoDisconnectObject OK.\n");
|
||
}
|
||
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
Cleanup:
|
||
|
||
OUTPUT (" - Test Complete. Doing Cleanup\n");
|
||
|
||
// Dump interfaces we are done with
|
||
if (pStm)
|
||
{
|
||
ulRefCnt = pStm->Release();
|
||
TEST_FAILED(ulRefCnt != 0, "Stream RefCnt not zero\n");
|
||
}
|
||
|
||
if (punkOut)
|
||
{
|
||
ulRefCnt = punkOut->Release();
|
||
TEST_FAILED(ulRefCnt != 0, "punkOut RefCnt not zero\n");
|
||
}
|
||
|
||
if (punkIn)
|
||
{
|
||
ulRefCnt = punkIn->Release();
|
||
TEST_FAILED(ulRefCnt != 0, "punkIn RefCnt not zero\n");
|
||
}
|
||
|
||
for (i=0; i<5; i++)
|
||
{
|
||
if (punk[i] != NULL)
|
||
{
|
||
ulRefCnt = punk[i]->Release();
|
||
TEST_FAILED(ulRefCnt != 0, "punk[i] RefCnt not zero\n");
|
||
}
|
||
}
|
||
|
||
return TestResult(RetVal, "TestNoPing");
|
||
}
|
||
|
||
|
||
// ----------------------------------------------------------------------
|
||
//
|
||
// Thread SubRoutine for testing NOPING.
|
||
//
|
||
// ----------------------------------------------------------------------
|
||
DWORD _stdcall NoPingThread(void *param)
|
||
{
|
||
BOOL RetVal = TRUE;
|
||
IUnknown *punk = NULL;
|
||
ULONG i = 0;
|
||
|
||
NoPingThreadInfo *npInfo = (NoPingThreadInfo *) param;
|
||
OUTPUT (" - NoPingThread Start\n");
|
||
|
||
HRESULT hRes = CoInitializeEx(NULL, gInitFlag);
|
||
TEST_FAILED(FAILED(hRes), "NoPingThread CoInitialize failed\n")
|
||
|
||
// Create a shared memory stream for the marshaled interface
|
||
IStream *pStm = CreateMemStm(600, NULL);
|
||
if (pStm == NULL)
|
||
{
|
||
TEST_FAILED((pStm == NULL), "CreateMemStm failed\n")
|
||
hRes = E_OUTOFMEMORY;
|
||
}
|
||
|
||
LARGE_INTEGER large_int;
|
||
LISet32(large_int, 0);
|
||
|
||
if (SUCCEEDED(hRes))
|
||
{
|
||
// unmarshal the interfaces
|
||
for (i=0; i<6; i++)
|
||
{
|
||
|
||
REFIID riid = (i==4) ? IID_IParseDisplayName : IID_IUnknown;
|
||
|
||
hRes = CoUnmarshalInterface(npInfo->pStm, riid, (void **)&punk);
|
||
TEST_FAILED(FAILED(hRes), "NoPingThread CoUnmarshalInterface failed\n")
|
||
OUTPUT(" - NoPingThread CoUnmarshalInterface done\n");
|
||
|
||
if (SUCCEEDED(hRes))
|
||
{
|
||
if (i==3)
|
||
{
|
||
// try remarshaling NOPING client as normal. Should end up
|
||
// as NOPING.
|
||
|
||
hRes = CoMarshalInterface(pStm, IID_IUnknown, punk,
|
||
0, 0, MSHLFLAGS_NORMAL);
|
||
TEST_FAILED(FAILED(hRes), "CoMarshalInterface failed\n")
|
||
OUTPUT (" - CoMarshalInterface OK.\n");
|
||
|
||
// reset the stream seek ptr
|
||
hRes = pStm->Seek(large_int, STREAM_SEEK_SET, NULL);
|
||
TEST_FAILED(FAILED(hRes), "Seek on shared stream failed\n")
|
||
|
||
// verify the marshal format
|
||
hRes = VerifyOBJREFFormat(pStm, MSHLFLAGS_NOPING);
|
||
TEST_FAILED(FAILED(hRes), "VerifyOBJREFFormat failed\n")
|
||
OUTPUT (" - VerifyOBJREFFormat OK.\n");
|
||
}
|
||
|
||
punk->Release();
|
||
punk = NULL;
|
||
OUTPUT(" - NoPingThread Release done\n");
|
||
}
|
||
}
|
||
|
||
// uninit OLE
|
||
CoUninitialize();
|
||
}
|
||
|
||
if (pStm)
|
||
{
|
||
// release stream we created above
|
||
pStm->Release();
|
||
}
|
||
|
||
OUTPUT (" - NoPingThread Exit\n");
|
||
npInfo->hr = hRes;
|
||
SetEvent(npInfo->hEvent);
|
||
return RetVal;
|
||
}
|
||
|
||
|
||
// ----------------------------------------------------------------------
|
||
//
|
||
// test marshaling between apartments in the same process using
|
||
// MSHLFLAGS_NORMAL, MSHLFLAGS_TABLEWEAK, and MSHLFLAGS_TABLESTRONG
|
||
//
|
||
// ----------------------------------------------------------------------
|
||
typedef struct tagCrossThreadCallInfo
|
||
{
|
||
HANDLE hEvent;
|
||
IStream *pStm;
|
||
DWORD dwInitFlag;
|
||
DWORD dwThreadId;
|
||
HRESULT hr;
|
||
} CrossThreadCallInfo;
|
||
|
||
|
||
DWORD _stdcall CrossThreadCalls(void *param);
|
||
DWORD _stdcall CrossThreadLoops(void *param);
|
||
DWORD _stdcall CrossThreadActivate(void *param);
|
||
|
||
|
||
BOOL TestCrossThread(void)
|
||
{
|
||
BOOL RetVal = TRUE;
|
||
HRESULT hres;
|
||
LPSTREAM pStm = NULL;
|
||
ULONG ulRefCnt, i, j;
|
||
IUnknown *punk[3] = {NULL, NULL, NULL};
|
||
IUnknown *pUnk;
|
||
ILoop *pLocalLoop = NULL;
|
||
CrossThreadCallInfo ctInfo;
|
||
DWORD dwThrdId = 0;
|
||
HANDLE hThrd;
|
||
DWORD mshlflags[3] = {MSHLFLAGS_NORMAL,
|
||
MSHLFLAGS_TABLEWEAK,
|
||
MSHLFLAGS_TABLESTRONG};
|
||
|
||
DWORD dwInitFlags[4] = {COINIT_APARTMENTTHREADED,
|
||
COINIT_APARTMENTTHREADED,
|
||
COINIT_MULTITHREADED,
|
||
COINIT_MULTITHREADED};
|
||
|
||
|
||
LARGE_INTEGER large_int;
|
||
LISet32(large_int, 0);
|
||
|
||
OUTPUT ("Starting TestCrossThread\n");
|
||
|
||
// Create a shared memory stream for the marshaled interface
|
||
pStm = CreateMemStm(600, NULL);
|
||
TEST_FAILED_EXIT((pStm == NULL), "CreateMemStm failed\n")
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
for (j=0; j<4; j++)
|
||
{
|
||
// reset the stream seek ptr
|
||
hres = pStm->Seek(large_int, STREAM_SEEK_SET, NULL);
|
||
TEST_FAILED_EXIT(FAILED(hres), "Seek on shared stream failed\n")
|
||
|
||
// marshal an interface NORMAL, TABLEWEAK and TABLESTRONG
|
||
// and unmarshal each in another apartment.
|
||
|
||
for (i=0; i<3; i++)
|
||
{
|
||
punk[i] = GetTestUnk();
|
||
TEST_FAILED_EXIT((punk[i] == NULL), "new CTestUnkCube failed\n")
|
||
VerifyObjRefCnt(punk[i], 1);
|
||
|
||
// Marshal the interface into the stream
|
||
hres = CoMarshalInterface(pStm, IID_ICube, punk[i],
|
||
0, 0, mshlflags[i]);
|
||
|
||
TEST_FAILED_EXIT(FAILED(hres), "CoMarshalInterface failed\n")
|
||
OUTPUT (" - CoMarshalInterface OK.\n");
|
||
VerifyRHRefCnt(punk[i], 1);
|
||
}
|
||
|
||
// reset the stream seek ptr
|
||
hres = pStm->Seek(large_int, STREAM_SEEK_SET, NULL);
|
||
TEST_FAILED_EXIT(FAILED(hres), "Seek on shared stream failed\n")
|
||
|
||
for (i=0; i<3; i++)
|
||
{
|
||
hres = VerifyOBJREFFormat(pStm, mshlflags[i]);
|
||
TEST_FAILED_EXIT(FAILED(hres), "VerifyOBJREFFormat failed\n")
|
||
OUTPUT (" - VerifyOBJREFFormat OK.\n");
|
||
}
|
||
|
||
// reset the stream seek ptr
|
||
hres = pStm->Seek(large_int, STREAM_SEEK_SET, NULL);
|
||
TEST_FAILED_EXIT(FAILED(hres), "Seek on shared stream failed\n")
|
||
|
||
|
||
// create thread and wait for it to complete
|
||
ctInfo.hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
|
||
ctInfo.pStm = pStm;
|
||
ctInfo.dwInitFlag = dwInitFlags[j];
|
||
ctInfo.dwThreadId = GetCurrentThreadId();
|
||
ctInfo.hr = S_OK;
|
||
|
||
RunThread(&ctInfo, ctInfo.hEvent, CrossThreadCalls);
|
||
CloseHandle(ctInfo.hEvent);
|
||
|
||
|
||
// cleanup the leftover objects.
|
||
for (i=0; i<3; i++)
|
||
{
|
||
hres = CoDisconnectObject(punk[i], 0);
|
||
punk[i] = NULL;
|
||
TEST_FAILED_EXIT(FAILED(hres), "CoDisconnectObject failed\n")
|
||
OUTPUT (" - CoDisconnectObject OK.\n");
|
||
}
|
||
}
|
||
|
||
// ----------------------------------------------------------------------
|
||
// Now test out doing activation from different apartments.
|
||
// create thread and wait for it to complete
|
||
|
||
for (j=0; j<2; j++)
|
||
{
|
||
ctInfo.hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
|
||
ctInfo.pStm = NULL;
|
||
ctInfo.dwInitFlag = dwInitFlags[j];
|
||
ctInfo.dwThreadId = GetCurrentThreadId();
|
||
ctInfo.hr = S_OK;
|
||
|
||
RunThread(&ctInfo, ctInfo.hEvent, CrossThreadActivate);
|
||
CloseHandle(ctInfo.hEvent);
|
||
|
||
// create an interface
|
||
hres = CoCreateInstance(CLSID_LoopSrv, NULL, CLSCTX_LOCAL_SERVER,
|
||
IID_ILoop, (void **)&pLocalLoop);
|
||
TEST_FAILED(FAILED(hres), "CoCreateInstance Second failed\n")
|
||
|
||
if (SUCCEEDED(hres))
|
||
{
|
||
pLocalLoop->Release();
|
||
}
|
||
}
|
||
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
// Now test doing nested calls between apartments.
|
||
#if 0
|
||
for (j=0; j<2; j++)
|
||
{
|
||
// reset the stream seek ptr
|
||
hres = pStm->Seek(large_int, STREAM_SEEK_SET, NULL);
|
||
TEST_FAILED_EXIT(FAILED(hres), "Seek on shared stream failed\n")
|
||
|
||
pUnk = GetTestUnk();
|
||
TEST_FAILED_EXIT((pUnk == NULL), "new GetTestUnk failed\n")
|
||
VerifyObjRefCnt(pUnk, 1);
|
||
|
||
// Marshal the interface into the stream
|
||
hres = CoMarshalInterface(pStm, IID_ILoop, pUnk,
|
||
0, 0, MSHLFLAGS_NORMAL);
|
||
|
||
TEST_FAILED_EXIT(FAILED(hres), "CoMarshalInterface failed\n")
|
||
OUTPUT (" - CoMarshalInterface OK.\n");
|
||
VerifyRHRefCnt(pUnk, 1);
|
||
|
||
// reset the stream seek ptr
|
||
hres = pStm->Seek(large_int, STREAM_SEEK_SET, NULL);
|
||
TEST_FAILED_EXIT(FAILED(hres), "Seek on shared stream failed\n")
|
||
|
||
|
||
ctInfo.hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
|
||
ctInfo.pStm = pStm;
|
||
ctInfo.dwInitFlag = dwInitFlags[j];
|
||
ctInfo.dwThreadId = GetCurrentThreadId();
|
||
ctInfo.hr = S_OK;
|
||
|
||
RunThread(&ctInfo, ctInfo.hEvent, CrossThreadLoops);
|
||
CloseHandle(ctInfo.hEvent);
|
||
|
||
pUnk->Release();
|
||
}
|
||
#endif
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
Cleanup:
|
||
|
||
OUTPUT (" - Test Complete. Doing Cleanup\n");
|
||
|
||
// Dump interfaces we are done with
|
||
if (pStm)
|
||
{
|
||
ulRefCnt = pStm->Release();
|
||
TEST_FAILED(ulRefCnt != 0, "Stream RefCnt not zero\n");
|
||
}
|
||
|
||
for (i=0; i<3; i++)
|
||
{
|
||
if (punk[i] != NULL)
|
||
{
|
||
ulRefCnt = punk[i]->Release();
|
||
TEST_FAILED(ulRefCnt != 0, "punk[i] RefCnt not zero\n");
|
||
}
|
||
}
|
||
|
||
return TestResult(RetVal, "TestCrossThread");
|
||
}
|
||
|
||
|
||
// ----------------------------------------------------------------------
|
||
//
|
||
// Thread SubRoutine for testing CROSSTHREAD calls.
|
||
//
|
||
// ----------------------------------------------------------------------
|
||
DWORD _stdcall CrossThreadCalls(void *param)
|
||
{
|
||
BOOL RetVal = TRUE;
|
||
ICube *pCube = NULL;
|
||
IOleWindow *pIOW = NULL;
|
||
IAdviseSink *pIAS = NULL;
|
||
ULONG i = 0;
|
||
|
||
// get the execution parameters
|
||
CrossThreadCallInfo *ctInfo = (CrossThreadCallInfo *) param;
|
||
OUTPUT (" - CrossThreadCalls Start\n");
|
||
|
||
// initialize COM
|
||
HRESULT hRes = CoInitializeEx(NULL, ctInfo->dwInitFlag);
|
||
TEST_FAILED(FAILED(hRes), "CrossThreadCalls CoInitializeEx failed\n")
|
||
|
||
if (SUCCEEDED(hRes))
|
||
{
|
||
// unmarshal the interfaces
|
||
for (i=0; i<3; i++)
|
||
{
|
||
hRes = CoUnmarshalInterface(ctInfo->pStm, IID_ICube, (void **)&pCube);
|
||
TEST_FAILED(FAILED(hRes), "CrossThread CoUnmarshalInterface failed\n")
|
||
OUTPUT(" - CrossThread CoUnmarshalInterface done\n");
|
||
|
||
if (SUCCEEDED(hRes))
|
||
{
|
||
// test a synchronous method call between apartments
|
||
// (also checks the lid & tid)
|
||
|
||
UUID lidCaller;
|
||
CoGetCurrentLogicalThreadId(&lidCaller);
|
||
hRes = pCube->SimpleCall(GetCurrentProcessId(),
|
||
GetCurrentThreadId(),
|
||
lidCaller);
|
||
TEST_FAILED(FAILED(hRes), "pCube->SimpleCall failed\n")
|
||
OUTPUT(" - Synchronous call done\n");
|
||
|
||
// test an input-sync method call between apartments
|
||
hRes = pCube->QueryInterface(IID_IOleWindow, (void **)&pIOW);
|
||
|
||
if (SUCCEEDED(hRes))
|
||
{
|
||
HWND hWnd;
|
||
hRes = pIOW->GetWindow(&hWnd);
|
||
|
||
// input sync is only allowed between two apartment
|
||
// threaded apartments.
|
||
if (ctInfo->dwInitFlag == gInitFlag)
|
||
{
|
||
TEST_FAILED(FAILED(hRes), "pIOW->GetWindow failed\n");
|
||
}
|
||
else
|
||
{
|
||
TEST_FAILED(SUCCEEDED(hRes), "pIOW->GetWindow should have failed\n");
|
||
}
|
||
|
||
pIOW->Release();
|
||
OUTPUT(" - Input-Synchronous call done\n");
|
||
}
|
||
|
||
|
||
// test an async method call between apartments
|
||
hRes = pCube->QueryInterface(IID_IAdviseSink, (void **)&pIAS);
|
||
|
||
if (SUCCEEDED(hRes))
|
||
{
|
||
// no return code to check
|
||
pIAS->OnViewChange(1,2);
|
||
pIAS->Release();
|
||
OUTPUT(" - ASynchronous call done\n");
|
||
}
|
||
|
||
// release the object
|
||
pCube->Release();
|
||
pCube = NULL;
|
||
OUTPUT(" - CrossThread Calls and Release done\n");
|
||
}
|
||
}
|
||
|
||
// uninit OLE
|
||
CoUninitialize();
|
||
}
|
||
|
||
OUTPUT (" - CrossThreadCalls Exit\n");
|
||
ctInfo->hr = hRes;
|
||
|
||
// signal the other thread we are done.
|
||
if (gInitFlag == COINIT_APARTMENTTHREADED)
|
||
{
|
||
PostThreadMessage(ctInfo->dwThreadId, WM_QUIT, 0, 0);
|
||
}
|
||
else
|
||
{
|
||
SetEvent(ctInfo->hEvent);
|
||
}
|
||
|
||
return hRes;
|
||
}
|
||
|
||
|
||
// ----------------------------------------------------------------------
|
||
//
|
||
// Thread SubRoutine for testing CROSSTHREAD activation
|
||
//
|
||
// ----------------------------------------------------------------------
|
||
DWORD _stdcall CrossThreadActivate(void *param)
|
||
{
|
||
BOOL RetVal = TRUE;
|
||
ILoop *pLocalLoop = NULL;
|
||
|
||
// get the execution parameters
|
||
CrossThreadCallInfo *ctInfo = (CrossThreadCallInfo *) param;
|
||
OUTPUT (" - CrossThreadActivate Start\n");
|
||
|
||
// initialize COM
|
||
HRESULT hRes = CoInitializeEx(NULL, ctInfo->dwInitFlag);
|
||
TEST_FAILED(FAILED(hRes), "CrossThreadActivate CoInitializeEx failed\n")
|
||
|
||
if (SUCCEEDED(hRes))
|
||
{
|
||
// create an interface
|
||
hRes = CoCreateInstance(CLSID_LoopSrv, NULL, CLSCTX_LOCAL_SERVER,
|
||
IID_ILoop, (void **)&pLocalLoop);
|
||
TEST_FAILED(FAILED(hRes), "CoCreateInstance First failed\n")
|
||
|
||
if (SUCCEEDED(hRes))
|
||
{
|
||
pLocalLoop->Release();
|
||
}
|
||
|
||
// uninit OLE
|
||
CoUninitialize();
|
||
}
|
||
|
||
OUTPUT (" - CrossThreadActivate Exit\n");
|
||
ctInfo->hr = hRes;
|
||
|
||
// signal the other thread we are done.
|
||
if (gInitFlag == COINIT_APARTMENTTHREADED)
|
||
{
|
||
PostThreadMessage(ctInfo->dwThreadId, WM_QUIT, 0, 0);
|
||
}
|
||
else
|
||
{
|
||
SetEvent(ctInfo->hEvent);
|
||
}
|
||
|
||
return hRes;
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
#if 0
|
||
// ----------------------------------------------------------------------
|
||
//
|
||
// Thread SubRoutine for testing CROSSTHREAD calls.
|
||
//
|
||
// ----------------------------------------------------------------------
|
||
DWORD _stdcall CrossThreadLoops(void *param)
|
||
{
|
||
BOOL RetVal = TRUE;
|
||
ILoop *pLoop = NULL;
|
||
IUnknown *punk = NULL;
|
||
ILoop *pLoopLocal = NULL;
|
||
|
||
// get the execution parameters
|
||
CrossThreadCallInfo *ctInfo = (CrossThreadCallInfo *) param;
|
||
OUTPUT (" - CrossThreadLoops Start\n");
|
||
|
||
// initialize COM
|
||
HRESULT hRes = CoInitializeEx(NULL, ctInfo->dwInitFlag);
|
||
TEST_FAILED(FAILED(hRes), "CrossThreadLoops CoInitializeEx failed\n")
|
||
|
||
if (SUCCEEDED(hRes))
|
||
{
|
||
punk = GetTestUnk();
|
||
punk->QueryInterface(IID_ILoop, (void **)&pLoopLocal);
|
||
punk->Release();
|
||
|
||
// unmarshal the interface
|
||
hRes = CoUnmarshalInterface(ctInfo->pStm, IID_ILoop, (void **)&pLoop);
|
||
TEST_FAILED(FAILED(hRes), "CrossThreadLoop CoUnmarshalInterface failed\n")
|
||
OUTPUT(" - CrossThreadLoop CoUnmarshalInterface done\n");
|
||
|
||
if (SUCCEEDED(hRes))
|
||
{
|
||
// test nested synchronous method calls between apartments
|
||
|
||
hRes = pLoop->Init(pLoopLocal);
|
||
TEST_FAILED(FAILED(hRes), "pLoop->Init failed\n")
|
||
|
||
if (SUCCEEDED(hRes))
|
||
{
|
||
hRes = pLoop->Loop(5);
|
||
TEST_FAILED(FAILED(hRes), "pLoop->Loop failed\n")
|
||
|
||
hRes = pLoop->Uninit();
|
||
TEST_FAILED(FAILED(hRes), "pLoop->Uninit failed\n")
|
||
}
|
||
|
||
pLoop->Release();
|
||
pLoop = NULL;
|
||
|
||
OUTPUT(" - CrossThreadLoop Calls and Release done\n");
|
||
}
|
||
|
||
// uninit OLE
|
||
CoUninitialize();
|
||
}
|
||
|
||
OUTPUT (" - CrossThreadLoops Exit\n");
|
||
ctInfo->hr = hRes;
|
||
|
||
// signal the other thread we are done.
|
||
if (gInitFlag == COINIT_APARTMENTTHREADED)
|
||
{
|
||
PostThreadMessage(ctInfo->dwThreadId, WM_QUIT, 0, 0);
|
||
}
|
||
else
|
||
{
|
||
SetEvent(ctInfo->hEvent);
|
||
}
|
||
|
||
return hRes;
|
||
}
|
||
#endif
|
||
|
||
|
||
|
||
// ----------------------------------------------------------------------
|
||
//
|
||
// Test calling CoGetPSClsid and CoRegisterPSClsid
|
||
//
|
||
// ----------------------------------------------------------------------
|
||
BOOL TestPSClsid(void)
|
||
{
|
||
BOOL RetVal = TRUE;
|
||
HRESULT hRes;
|
||
CLSID clsidOriginal, clsidNew;
|
||
|
||
OUTPUT ("Starting TestPSClsid\n");
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
// get the PSClsid that is currently registered for this interface.
|
||
|
||
hRes = CoGetPSClsid(IID_IViewObject, &clsidOriginal);
|
||
TEST_FAILED(FAILED(hRes), "Failed 1st CoGetPSClsid\n");
|
||
OUTPUT (" - Done 1st CoGetPSClsid\n");
|
||
|
||
// Set a new PSClsid for this interface for this process. Note that
|
||
// if we have used the interface before, we will get an error back,
|
||
// otherwise, this will succeed.
|
||
|
||
hRes = CoRegisterPSClsid(IID_IViewObject, CLSID_Balls);
|
||
TEST_FAILED(FAILED(hRes), "Failed 1st CoGRegisterPSClsid\n");
|
||
OUTPUT (" - Done 1st CoRegisterPSClsid\n");
|
||
|
||
// now get the PSClsid that is registered for this interface. This
|
||
// should match the value we just passed in.
|
||
|
||
hRes = CoGetPSClsid(IID_IViewObject, &clsidNew);
|
||
TEST_FAILED(FAILED(hRes), "Failed 2nd CoGetPSClsid\n");
|
||
OUTPUT (" - Done 2nd CoGetPSClsid\n");
|
||
|
||
if (memcmp(&clsidNew, &CLSID_Balls, sizeof(CLSID)))
|
||
{
|
||
TEST_FAILED(TRUE, "Failed Compare of CLSIDs\n");
|
||
}
|
||
|
||
// now try to register it again. This should fail since it has
|
||
// already been registered.
|
||
|
||
hRes = CoRegisterPSClsid(IID_IViewObject, clsidOriginal);
|
||
TEST_FAILED(FAILED(hRes), "Failed 2nd CoGRegisterPSClsid\n");
|
||
OUTPUT (" - Done 2nd CoRegisterPSClsid\n");
|
||
|
||
// now get the PSClsid that is registered for this interface. This
|
||
// should match the value we just passed in.
|
||
|
||
hRes = CoGetPSClsid(IID_IViewObject, &clsidNew);
|
||
TEST_FAILED(FAILED(hRes), "Failed 3rd CoGetPSClsid\n");
|
||
OUTPUT (" - Done 3rd CoGetPSClsid\n");
|
||
|
||
if (memcmp(&clsidNew, &clsidOriginal, sizeof(CLSID)))
|
||
{
|
||
TEST_FAILED(TRUE, "Failed 2nd Compare of CLSIDs\n");
|
||
}
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
OUTPUT (" - Test Complete. Doing Cleanup\n");
|
||
return TestResult(RetVal, "TestPSClsid");
|
||
}
|
||
|
||
// ----------------------------------------------------------------------
|
||
//
|
||
// Test calling CoGetPSClsid for a LONG IID/PSCLSID pair.
|
||
//
|
||
// ----------------------------------------------------------------------
|
||
BOOL TestPSClsid2(void)
|
||
{
|
||
BOOL RetVal = TRUE;
|
||
HRESULT hRes = S_OK;
|
||
CLSID clsidOriginal;
|
||
|
||
OUTPUT ("Starting TestPSClsid2\n");
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
// get the PSClsid that is currently registered for this interface.
|
||
hRes = CoGetPSClsid(IID_IViewObject, &clsidOriginal);
|
||
TEST_FAILED(FAILED(hRes), "Failed 1st CoGetPSClsid\n");
|
||
OUTPUT (" - Done 1st CoGetPSClsid\n");
|
||
|
||
if (!IsEqualGUID(clsidOriginal, CLSID_OLEPSFACTORY))
|
||
{
|
||
TEST_FAILED(FAILED(hRes), "CoGetPSClsid returned wrong value\n");
|
||
}
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
OUTPUT (" - Test Complete. Doing Cleanup\n");
|
||
return TestResult(RetVal, "TestPSClsid2");
|
||
}
|
||
|
||
|
||
|
||
// ----------------------------------------------------------------------
|
||
//
|
||
// TestGetIIDFromMI
|
||
//
|
||
// ----------------------------------------------------------------------
|
||
BOOL TestGetIIDFromMI(void)
|
||
{
|
||
BOOL RetVal = TRUE;
|
||
HRESULT hres;
|
||
IUnknown *punkIn = NULL;
|
||
IID iid;
|
||
|
||
OUTPUT ("Starting TestGetIIDFromMI\n");
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
ULARGE_INTEGER ulSeekEnd;
|
||
LARGE_INTEGER lSeekStart;
|
||
LISet32(lSeekStart, 0);
|
||
|
||
IStream *pStm = CreateMemStm(600, NULL);
|
||
TEST_FAILED_EXIT((pStm == NULL), "CreateMemStm failed\n")
|
||
VerifyObjRefCnt((IUnknown *)pStm, 1);
|
||
|
||
punkIn = GetTestUnk();
|
||
|
||
hres = CoMarshalInterface(pStm, IID_IUnknown, punkIn, 0, NULL, MSHLFLAGS_NORMAL);
|
||
TEST_FAILED_EXIT(FAILED(hres), "CoMarshalInterface failed\n")
|
||
OUTPUT (" - CoMarshalInterface OK\n");
|
||
|
||
// go back to begining
|
||
hres = pStm->Seek(lSeekStart, STREAM_SEEK_SET, NULL);
|
||
TEST_FAILED_EXIT(FAILED(hres), "Seek on shared stream failed\n")
|
||
OUTPUT (" - Seek Start OK\n");
|
||
|
||
#if 0 // BUGBUG: RICKHI
|
||
// get the IID from the stream, and ensure it matches the IID we
|
||
// marshaled. Also, ensure the stream is left where it was. This
|
||
// is accomplished by calling CRMD on the stream.
|
||
|
||
hres = CoGetIIDFromMarshaledInterface(pStm, &iid);
|
||
TEST_FAILED(FAILED(hres), "CoGetIIDFromMarshaledInterface failed\n")
|
||
OUTPUT (" - CoGetIIDFromMarshaledInterface Done\n");
|
||
|
||
if (!IsEqualIID(IID_IUnknown, iid))
|
||
{
|
||
TEST_FAILED(TRUE, "IID read does not match IID marshaled\n")
|
||
}
|
||
#endif
|
||
// release the marshaled interface
|
||
hres = CoReleaseMarshalData(pStm);
|
||
TEST_FAILED(FAILED(hres), "CoReleaseMarshalData failed\n")
|
||
OUTPUT (" - CoReleaseMarshalData Done\n");
|
||
|
||
// ----------------------------------------------------------------------
|
||
Cleanup:
|
||
|
||
if (punkIn)
|
||
{
|
||
punkIn->Release();
|
||
punkIn = NULL;
|
||
}
|
||
|
||
OUTPUT (" - Test Complete. Doing Cleanup\n");
|
||
return TestResult(RetVal, "TestGetIIDFromMI");
|
||
}
|
||
|