// Copyright (c) 2004-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// Contains IPC Test 04

// 

//

// EPOC includes

#include <e32base.h>

#include <ss_std.h>

#include "Test04IPCMultithreadedDataTransfer.h"

const TInt KInactivityTimeout = 1000000;	// Use 1 second so that there can be many timeouts, but we'll beat the TEF's 100 second timeout

const TDesC& CTest04IPCMultithreadedDataTransfer::GetTestName()

	{

	_LIT(ret,"IPCTest04");

	return ret;

	}

// constructor

CTest04IPCMultithreadedDataTransfer::CTest04IPCMultithreadedDataTransfer()

	{

    iThreadStackSize = 1024;

    iSemName = _L("IPC sem");

    iTestString = _L8("This is IPC test string");

	}

// destructor

CTest04IPCMultithreadedDataTransfer::~CTest04IPCMultithreadedDataTransfer() 

	{

	}

// 

TInt CTest04IPCMultithreadedDataTransfer::fTransmitterThread(TAny* aInput)

	{

	TInt err;

	RSocketServ aSockServer;

	RSocket aClientSock;

	RSemaphore aSem;

	TSockAddr aAddr;

    CTest04IPCMultithreadedDataTransfer* pTestObject =

								(CTest04IPCMultithreadedDataTransfer*)aInput;

	//-------------------substep 01-----------------------------	

	// Connect to Socket server, open semaphore and create client socket end point

	pTestObject->iTransmitThreadResult.Format(_L("   Step1..."));

	pTestObject->iTransmitThreadResult.Append(_L("Connect to Sock Server..."));

	if ( (err = OptimalConnect(aSockServer)) != KErrNone ) 

		return err;

	pTestObject->iTransmitThreadResult.Append(_L("Open Semaphore..."));

	if ((err = aSem.OpenGlobal(pTestObject->iSemName)) != KErrNone) 

		{

		aSockServer.Close();

		return err;

		}

	pTestObject->iTransmitThreadResult.Append(_L("Open Client Socket..."));

	if ( (err=aClientSock.Open(aSockServer,pTestObject->iProt)) != KErrNone)

		{

		aSockServer.Close();

		aSem.Close();

		return err;

		}

	//-------------------substep 02-----------------------------	

	// Wait the signal from receiver thread to continue

	pTestObject->iTransmitThreadResult.Append(_L("Wait..."));

	aSem.Wait(); 

	//-------------------substep 03-----------------------------	

	// Connect to the server socket and send test message

	aAddr.SetPort(1);

	pTestObject->iTransmitThreadResult.Append(_L("Connect..."));

	aClientSock.Connect(aAddr,pTestObject->iTrStatus);

	User::WaitForRequest(pTestObject->iTrStatus);

	if (pTestObject->iTrStatus != KErrNone)

		{

		aClientSock.Close();

		aSockServer.Close();

		aSem.Close();

		return pTestObject->iTrStatus.Int();

 		}

	pTestObject->iTransmitThreadResult.Append(_L("Write..."));

	aClientSock.Write(pTestObject->iTestString,pTestObject->iTrStatus);

	User::WaitForRequest(pTestObject->iTrStatus);

	if(pTestObject->iTrStatus!=KErrNone)

		{

		aClientSock.Close();

		aSockServer.Close();

		aSem.Close();

		return pTestObject->iTrStatus.Int();

		}

	//-------------------substep 04-----------------------------	

	// Wait the signal from receiver thread to continue

	pTestObject->iTransmitThreadResult.Append(_L("Wait..."));

	aSem.Wait(); 

	//-------------------substep 05-----------------------------	

	// Close the socket. Close connection to Socket server.

	pTestObject->iTransmitThreadResult.Append(_L("Exit OK..."));

	aClientSock.Close();

	aSockServer.Close();

	aSem.Close();

	return KErrNone;

	}

//

TInt CTest04IPCMultithreadedDataTransfer::fReceiverThread(TAny* aInput)

	{

	TInt err;

	RSocketServ aSockServer;

	RSemaphore aSem;

	RSocket aNewConn, aServerSock;

    CTest04IPCMultithreadedDataTransfer* pTestObject =

								(CTest04IPCMultithreadedDataTransfer*)aInput;

	//-------------------substep 01-----------------------------	

	// Connect to Socket setver, open semaphore and create server socket end point

	pTestObject->iReceiveThreadResult.Format(_L("   Step1..."));

	pTestObject->iReceiveThreadResult.Append(_L("Connect to SockServer..."));

	if ( (err = OptimalConnect(aSockServer)) != KErrNone )   

		return err;

	pTestObject->iReceiveThreadResult.Append(_L("Open semaphore..."));

	if ((err = aSem.OpenGlobal(pTestObject->iSemName)) != KErrNone)

		{

		aSockServer.Close();

		return err;

		}

	pTestObject->iReceiveThreadResult.Append(_L("Open Server socket..."));

	if ( (err=aServerSock.Open(aSockServer,pTestObject->iProt)) != KErrNone)

		{

		aSockServer.Close();

		aSem.Close();

		return err;

		}

	if ( (err=aServerSock.SetLocalPort(1)) != KErrNone)

		{

		aServerSock.Close();

		aSockServer.Close();

		aSem.Close();

		return err;

		}

	if ( (err=aServerSock.Listen(1)) != KErrNone)

		{

		aServerSock.Close();

		aSockServer.Close();

		aSem.Close();

		return err;

		}

	pTestObject->iReceiveThreadResult.Append(_L("Open Blank Socket..."));

	if ( (err=aNewConn.Open(aSockServer)) != KErrNone)

		{

		aServerSock.Close();

		aSockServer.Close();

		aSem.Close();

		return err;

		}

	//-------------------substep 02-----------------------------	

	// Send the signal to transmit thread to continue

	pTestObject->iReceiveThreadResult.Append(_L("Signal..."));

	aSem.Signal();

	//-------------------substep 03-----------------------------	

	// Read the message from the socket

	pTestObject->iReceiveThreadResult.Append(_L("Accept..."));

	aServerSock.Accept(aNewConn,pTestObject->iRecStatus);

	User::WaitForRequest(pTestObject->iRecStatus);

	if (pTestObject->iRecStatus != KErrNone)

		{

		aNewConn.Close();

		aServerSock.Close();

		aSockServer.Close();

		aSem.Close();

		return pTestObject->iRecStatus.Int();

		}

	int aLen = pTestObject->iTestString.Length(); 

	TAny* aPtr = User::Alloc(aLen);

	if (aPtr == NULL)

		{

		aNewConn.Close();

		aServerSock.Close();

		aSockServer.Close();

		aSem.Close();

		return KErrNoMemory;

		}

	TPtr8 aIn((TUint8*)aPtr,aLen,aLen);

	aIn.SetLength(aLen);

	pTestObject->iReceiveThreadResult.Append(_L("Read..."));

	aNewConn.Read(aIn,pTestObject->iRecStatus);

	User::WaitForRequest(pTestObject->iRecStatus);

	if (pTestObject->iRecStatus != KErrNone)

		{

		User::Free(aPtr);

		aNewConn.Close();

		aServerSock.Close();

		aSockServer.Close();

		aSem.Close();

		return pTestObject->iRecStatus.Int();

		}

	aNewConn.Close();

	//-------------------substep 04-----------------------------	

	// Send the signal to transmit thread to continue

	pTestObject->iReceiveThreadResult.Append(_L("Signal..."));

	aSem.Signal();

	//-------------------substep 05-----------------------------	

	// Check the data received against test message that is sent

	pTestObject->iReceiveThreadResult.Append(_L("Compare data..."));

	if (aIn.Compare(pTestObject->iTestString)) 

		{

		User::Free(aPtr);

		aServerSock.Close();

		aSockServer.Close();

		aSem.Close();

		return EFail;

		}

	//-------------------substep 02-----------------------------	

	// Close the server socket. Close connection to Socket server. Free memory

	pTestObject->iReceiveThreadResult.Append(_L("Exit OK..."));

	aServerSock.Close();

	aSockServer.Close();

	User::Free(aPtr);

	aSem.Close();

	return KErrNone;

	}

//

TInt CTest04IPCMultithreadedDataTransfer::fInactivityTimeoutThread(TAny* aSelf)	

	{

	CTest04IPCMultithreadedDataTransfer* pTestObject = REINTERPRET_CAST(CTest04IPCMultithreadedDataTransfer*,aSelf);

	User::After(KInactivityTimeout);

	if (pTestObject->iRecStatus == KRequestPending)

		{

		pTestObject->iReceiveThreadResult.Append(_L("TIMEOUT..."));

		TRequestStatus* reqStat = &(pTestObject->iRecStatus);

		pTestObject->iThreadRec.RequestComplete(reqStat,KErrTimedOut);

		}

	if (pTestObject->iTrStatus == KRequestPending)

		{

		pTestObject->iTransmitThreadResult.Append(_L("TIMEOUT..."));

		TRequestStatus* reqStat = &(pTestObject->iTrStatus);

		pTestObject->iThreadTr.RequestComplete(reqStat,KErrTimedOut);

		}

	return KErrNone;

	}

// 

enum TVerdict CTest04IPCMultithreadedDataTransfer::InternalDoTestStepL(void)

	{

	//-------------------substep 01-----------------------------	

	_LIT(aLog01,"01 Create threads and semaphore:"); Logger().Write(aLog01);

	RThread aTimeoutThread;

	TRequestStatus aStatusRec,aStatusTr;

	TInt err=iThreadRec.Create(_L("testThreadRec"), 

		fReceiverThread, 

		KDefaultStackSize, 

		KDefaultHeapSize, 

		KDefaultHeapSize, 

		(TAny*)this,

		EOwnerProcess);

	if (err != KErrNone)

		{

		_LIT(aLog,"Error:Could not create receiving thread. err = %d");

		Logger().WriteFormat(aLog, err);

		return EFail;

		}

	err=iThreadTr.Create(_L("testThreadTr"),

		fTransmitterThread, 

		KDefaultStackSize, 

		KDefaultHeapSize, 

		KDefaultHeapSize, 

		(TAny*)this,

		EOwnerProcess);

	if (err != KErrNone)

		{

		_LIT(aLog,"Error:Could not create transmitting thread. err = %d");

		Logger().WriteFormat(aLog, err);

		return EFail;

		}

	RSemaphore aSem;

	err = aSem.CreateGlobal(iSemName,0);

	if (err != KErrNone)

		{

		_LIT(aLog,"Error:Could not create semaphore. err = %d");

		Logger().WriteFormat(aLog, err);

		return EFail;

		}

	err=aTimeoutThread.Create(_L("testThreadTimeout"),

		fInactivityTimeoutThread, 

		KDefaultStackSize, 

		KDefaultHeapSize, 

		KDefaultHeapSize, 

		(TAny*)this,

		EOwnerProcess);

	if (err != KErrNone)

		{

		_LIT(aLog,"Error:Could not create timeout thread. err = %d");

		Logger().WriteFormat(aLog, err);

		return EFail;

		}

	//-------------------substep 02-----------------------------	

	_LIT(aLog02,"02 Resume threads and wait them to end:"); Logger().Write(aLog02);

	iThreadRec.Logon(aStatusRec);

	iThreadRec.Resume();

	iThreadTr.Logon(aStatusTr);

	iThreadTr.Resume();

	User::WaitForRequest(aStatusRec,aStatusTr);

	if (aStatusRec!=KErrNone && aStatusTr==KRequestPending)

		{

		/* If the receiver completes prematurely with an error before the 

		 * transmitter, the transmitter will hang waiting to be signalled.

		 * So we send 2 signals to ensure that the transmitter completes. */

		aSem.Signal();

		aSem.Signal();

		}

	/* kick off a timeout thread that ensures that the test doesn't hang.

	 * (This can happen when an OOM occurs at an unfavourable time.) */

	aTimeoutThread.Resume();

	User::WaitForRequest(aStatusRec,aStatusTr);

	// We've completed, so the timeout thread won't be needed any longer

	aTimeoutThread.Kill(KErrNone);

	aTimeoutThread.Close();

	aSem.Close();

	iThreadRec.Close();

	iThreadTr.Close();

	TVerdict verdict = EPass;

	Logger().Write(_L("   Info:Receiving thread log:"));

	Logger().Write(iReceiveThreadResult);

	err = aStatusRec.Int();

	if (KErrNone != err)

		{

		_LIT(aLog,"Error:Receiving thread has returned error. err = %d");

		Logger().WriteFormat(aLog, err);

		verdict = EFail;

		}

	Logger().Write(_L("   Info:Transmitting thread log:"));

	Logger().Write(iTransmitThreadResult);

	err = aStatusTr.Int();

	if (KErrNone != err)

		{

		_LIT(aLog,"Error:Transmitting thread has returned error. err = %d");

		Logger().WriteFormat(aLog, err);

		verdict = EFail;

		}

	return verdict;

	}