//+-------------------------------------------------------------------
//
//  File:	testvars.cxx
//
//  Synopsis:	source code for Interface Marshaling stress test
//		variations.
//
//  History:	21-Aug-95  Rickhi	Created
//
//--------------------------------------------------------------------
#include <smarshal.hxx>

//+-------------------------------------------------------------------
//
//  Private Function ProtoTypes:
//
//--------------------------------------------------------------------
BOOL SingleThreadOps(ULONG cThreads, ULONG cReps, DWORD dwFlags);

BOOL ThreadPairOps(ULONG cThreadPairs,	ULONG cReps,
		   DWORD dwServerFlags, DWORD dwClientFlags);


//+-------------------------------------------------------------------
//
//  Function:	TestVar1
//
//  Synopsis:	Multiple Operations on the Same Thread.
//
//  History:	21-Aug-95  Rickhi	Created
//
//--------------------------------------------------------------------
BOOL TestVar1(void)
{
    MSGOUT("TestStart: TestLevel1\n");

    ULONG cThreads = gicThreads;
    ULONG cReps    = gicReps;
    DWORD dwOps    = 0;
    BOOL  fRes;


    // VAR1: test Marshal + ReleaseMarshalData

    dwOps = giThreadModel | OPF_MARSHAL | OPF_RELEASEMARSHALDATA;
    fRes = SingleThreadOps(cThreads, cReps, dwOps);
    CHKTESTRESULT(fRes, "TestVar1");


    // VAR2: test Marshal + Unmarshal + Release

    dwOps = giThreadModel | OPF_MARSHAL | OPF_UNMARSHAL | OPF_RELEASE;
    fRes = SingleThreadOps(cThreads, cReps, dwOps);
    CHKTESTRESULT(fRes, "TestVar2");


    // VAR3: test Marshal + Disconnect

    dwOps = giThreadModel | OPF_MARSHAL | OPF_DISCONNECT;
    fRes = SingleThreadOps(cThreads, cReps, dwOps);
    CHKTESTRESULT(fRes, "TestVar3");



    CHKTESTRESULT(fRes, "TestLevel1");
    return fRes;
}

//+-------------------------------------------------------------------
//
//  Function:	SingleThreadOps
//
//  Synopsis:	Perform Operations on the Same Thread.
//
//  History:	21-Aug-95  Rickhi	Created
//
//--------------------------------------------------------------------
BOOL SingleThreadOps(ULONG cThreads, ULONG cReps, DWORD dwFlags)
{
    BOOL fRes = TRUE;
    MSGOUT("SingleThreadOps Start\n");

    // CODEWORK: multiple interfaces
    ULONG cIPs = 1;

    EXECPARAMS *pEP[20];	// can launch up to 20 threads at once

    for (ULONG i=0; i<cThreads; i++)
    {
	// build an execution parameter block
	pEP[i] = CreateExecParam(cIPs);

	// fill in the execution parameter block. we dont need events
	// to synchronize the repetitions since all operations are done
	// on the same thread.

	FillExecParam(pEP[i],
		  dwFlags,	    // dwFlags (operations to perform)
		  cReps,	    // cReps
		  NULL,		    // hEventRepStart
		  NULL,		    // hEventRepDone
		  GetEvent(),	    // hEventThreadStart
		  GetEvent());	    // hEventThreadDone

	// fill in the INTERFACEPARAMSs
	for (ULONG j=0; j<cIPs; j++)
	{
	    INTERFACEPARAMS *pIP = &(pEP[i]->aIP[j]);

	    FillInterfaceParam(pIP,
		   IID_IUnknown,    // iid to operate on
		   GetInterface(),  // interface pointer to operate on
		   GetStream(),     // stream to use
		   NULL,	    // per interface start event
		   NULL);	    // per interface done  event
	}
    }

    // Execute all the command blocks simultaneously
    fRes = GenericExecute(cThreads, pEP);

    GenericCleanup(cThreads, pEP);

    CHKTESTRESULT(fRes, "SingleThreadOps");
    return fRes;
}

//+-------------------------------------------------------------------
//
//  Function:	TestVar2
//
//  Synopsis:	Operations on Thread Pairs (1 server, 1 client)
//
//  History:	21-Aug-95  Rickhi	Created
//
//--------------------------------------------------------------------
BOOL TestVar2(void)
{
    MSGOUT("TestStart: TestLevel2\n");

    ULONG cThreads = gicThreads;
    ULONG cReps    = gicReps;
    DWORD dwOps    = 0;
    BOOL  fRes;


    // VAR1: test Marshal on Server, Unmarshal + Release on Client.

    DWORD dwSrvOps = giThreadModel | OPF_MARSHAL;
    DWORD dwCliOps = giThreadModel | OPF_UNMARSHAL | OPF_RELEASE;
    fRes = ThreadPairOps(cThreads, cReps, dwSrvOps, dwCliOps);
    CHKTESTRESULT(fRes, "TestVar1");


    // VAR2: test Marshal on Server, RMD on Client.

#if 0
    dwSrvOps = giThreadModel | OPF_MARSHAL;
    dwCliOps = giThreadModel | OPF_RELEASEMARSHALDATA;
    fRes = ThreadPairOps(cThreads, cReps, dwSrvOps, dwCliOps);
    CHKTESTRESULT(fRes, "TestVar1");
#endif


    CHKTESTRESULT(fRes, "TestLevel2");
    return fRes;
}

//+-------------------------------------------------------------------
//
//  Function:	ThreadPairOps
//
//  Synopsis:	Perform Operations on two synchronized threads.
//
//  History:	21-Aug-95  Rickhi	Created
//
//--------------------------------------------------------------------
BOOL ThreadPairOps(ULONG cThreadPairs,	ULONG cReps,
		   DWORD dwServerFlags, DWORD dwClientFlags)
{
    BOOL fRes = TRUE;
    MSGOUT("ThreadPairOps Start\n");

    // CODEWORK: multiple interfaces
    ULONG cIPs = 1;

    EXECPARAMS *pEP[20];	// can launch up to 20 threads at once

    for (ULONG i=0; i<cThreadPairs * 2; i+=2)
    {
	// build execution parameter blocks for the server and client threads.
	EXECPARAMS *pEPSrv = CreateExecParam(cIPs);
	EXECPARAMS *pEPCli = CreateExecParam(cIPs);
	pEP[i]	 = pEPSrv;
	pEP[i+1] = pEPCli;


	// fill in the server execution parameter block.
	FillExecParam(pEPSrv,
		  dwServerFlags,    // dwFlags (operations to perform)
		  cReps,	    // cReps
		  GetEvent(),	    // hEventRepStart
		  GetEvent(),	    // hEventRepDone
		  GetEvent(),	    // hEventThreadStart
		  GetEvent());	    // hEventThreadDone

	// we need to kick the hEventRepStart in order to get the ball rolling,
	// since the server thread will be waiting on it.

	SignalEvent(pEPSrv->hEventRepStart);

	// client waits for the server to complete his first repetition
	// before starting. Server waits for the client to complete his
	// first repetition before starting the next iteration.

	FillExecParam(pEPCli,
		  dwClientFlags,	    // dwFlags (operations to perform)
		  cReps,		    // cReps
		  pEPSrv->hEventRepDone,    // hEventRepStart
		  pEPSrv->hEventRepStart,   // hEventRepDone
		  GetEvent(),		    // hEventThreadStart
		  GetEvent());		    // hEventThreadDone


	// fill in the INTERFACEPARAMSs
	// CODEWORK: when multiple interfaces, will need to use events.

	for (ULONG j=0; j<cIPs; j++)
	{
	    INTERFACEPARAMS *pIPSrv = &(pEPSrv->aIP[j]);
	    INTERFACEPARAMS *pIPCli = &(pEPCli->aIP[j]);

	    FillInterfaceParam(pIPSrv,
		   IID_IUnknown,    // iid to operate on
		   GetInterface(),  // interface pointer to operate on
		   GetStream(),	    // stream to use
		   NULL,	    // per interface start event
		   NULL);	    // per interface done  event

	    // AddRef the stream pointer since both the client and server
	    // will hold pointers to it.

	    pIPSrv->pStm->AddRef();

	    FillInterfaceParam(pIPCli,
		   IID_IUnknown,    // iid to operate on
		   NULL,	    // interface pointer to operate on
		   pIPSrv->pStm,    // use same stream as the server
		   NULL,	    // per interface start event
		   NULL);	    // per interface done  event
	}
    }

    // Execute all the command blocks simultaneously
    fRes = GenericExecute(cThreadPairs * 2, pEP);

    // cleanup all the command blocks. We need to NULL out one copy of
    // those events that are shared between two command blocks.
    for (i=0; i<cThreadPairs * 2; i+=2)
    {
	EXECPARAMS *pEPCli = pEP[i+1];
	pEPCli->hEventRepStart = NULL;
	pEPCli->hEventRepDone  = NULL;

	for (ULONG j=0; j<cIPs; j++)
	{
	    INTERFACEPARAMS *pIPCli = &(pEPCli->aIP[j]);
	    pIPCli->hEventStart = NULL;
	    pIPCli->hEventDone	= NULL;
	}
    }

    GenericCleanup(cThreadPairs * 2, pEP);


    CHKTESTRESULT(fRes, "ThreadPairOps");
    return fRes;
}

//+-------------------------------------------------------------------
//
//  Function:	TestLevel3
//
//  Synopsis:	Operations on Thread Pools (1 server, n clients)
//
//  History:	21-Aug-95  Rickhi	Created
//
//--------------------------------------------------------------------
BOOL TestLevel3(void)
{
    BOOL fRes = TRUE;
    MSGOUT("TestStart: TestLevel3\n");

    // build a command block

    // launch a thread to run the command block


    CHKTESTRESULT(fRes, "TestLevel3");
    return fRes;
}