windows-xp/Source/XPSP1/NT/com/oleutest/balls/client/tmarshal/tmarshal.cxx

// 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");
}