// 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 07
// 
//

// EPOC includes
#include <e32base.h>

// Test system includes
#include "Test07IPCDataTransferMemoryLeak.h"

const TDesC& CTest07IPCDataTransferMemoryLeak::GetTestName()
	{
	_LIT(ret,"IPCTest07");
	return ret;
	}

enum TVerdict CTest07IPCDataTransferMemoryLeak::InternalDoTestStepL()
	{
#if defined (_DEBUG_SOCKET_FUNCTIONS)
	// Server memory leak checking - this is a contentious thing because the
	// only sure "leak" is when dynamic memory is 100% orphaned, ie no pointer
	// from the root class to it, which we can't determine. The checking in this
	// code used to be at the level of the socket operations, ie like:
	//		iSockServer.__DbgMarkHeap();
	//		ret = socket.DoSomething();
	//		if(ret == KErrNoMemory)
	//			iSockServer.__DbgMarkCheck();
	// but this explicitly requires that upon a OOM condition the SAP will unwind
	// any allocations, such as recv queues, and this is not true and isn't stated
	// in any "contract" - it used to work purely because the recv queue was the
	// last thing allocated, but now the shim introduces a later allocation.
	
	// So here we move the heap mark/check outside all of the socket handling, on
	// the assumption that once all the SAPs are closed then all memory will have
	// been returned. This is still a weak assumption, eg what if the protocol keeps
	// a dynamic array of SAPs, then even once the SAPs have been freed this still
	// preserves a "high water mark" (unless the array is compressed)
	
	TInt err;
	RSocketServ heapSockServer;
	
	CleanupClosePushL (heapSockServer);
	
	if((err = OptimalConnect(heapSockServer)) != KErrNone)
		{
		Logger().WriteFormat(_L("Connecting to socket server failed with %d"), err);
		User::Leave(EFail);
		}
	
//	heapSockServer.__DbgMarkHeap();
	
	//-------------------substep 00-----------------------------
	Logger().Write(_L("00 Open socket server:"));
	
	RSocketServ ss;
	CleanupClosePushL(ss);
	if((err = OptimalConnect(ss)) != KErrNone)
		{
		Logger().WriteFormat(_L("Connecting to socket server failed with %d"), err);
		User::Leave(EFail);
		}
	
	//-------------------substep 01-----------------------------
	Logger().Write(_L("01 Create a single client/server connection:"));
	
	RSocket clientSock, newConn, serverSock;
	TRequestStatus acceptStat, connectStat;
	TSockAddr addr;
	
	CleanupClosePushL (clientSock);
	CleanupClosePushL (newConn);
	CleanupClosePushL (serverSock);
	
	if((err = serverSock.Open(ss, iProt)) != KErrNone)
		{
		Logger().WriteFormat(_L("Error: Could not open server socket. err = %d"), err);
		User::Leave(EFail);		
		}
	
	if((err = serverSock.SetLocalPort(1)) != KErrNone)
		{
		Logger().WriteFormat(_L("Error: Could not set port. err = %d"), err);
		User::Leave(EFail);
		}
	
	if((err = serverSock.Listen(1)) != KErrNone)
		{
		Logger().WriteFormat(_L("Error: Could not set up socket to listen. err = %d"), err);
		User::Leave(EFail);		
		}
	
	if((err = newConn.Open(ss)) != KErrNone)
		{
		Logger().WriteFormat(_L("Error: Could not open blank socket. err = %d"), err);
		User::Leave(EFail);		
		}
	
	serverSock.Accept(newConn, acceptStat);
	
	if((err = clientSock.Open(ss, iProt)) != KErrNone)
		{
		Logger().WriteFormat(_L("Error: Could not open socket. err = %d"), err);
		User::Leave(EFail);		
		}
	
	addr.SetPort(1);
	clientSock.Connect(addr, connectStat);
	
	User::WaitForRequest(connectStat);
	User::WaitForRequest(acceptStat);
	TVerdict verdict = EPass;
	
	err = connectStat.Int();
	if (err != KErrNone)
		{
		Logger().WriteFormat(_L("Error: Client socket not connected. err = %d"), err);
		verdict = EFail;	       
		}
	
	err = acceptStat.Int();
	if (acceptStat != KErrNone)
		{
		Logger().WriteFormat(_L("Error: Connection not accepted on server side. err = %d"), err);
		verdict = EFail;		
		}
	
	if (verdict == EFail)
		User::Leave(EFail);
	
	//-------------------substep 02-----------------------------
	Logger().Write(_L("02 Set heap to fails after N=0 allocations..."));
	Logger().Write(_L("   ...Call Write method. If it returns error, check memory leak."));
	Logger().Write(_L("   ...Increase N and repeat the same until write method returns NoError:"));
	
	TBuf8<1> out, in;
	TInt failure = 0;
	TRequestStatus writeStat, readStat;
	
	in.SetMax();
	out.SetMax();
	
	clientSock.Read(in, readStat);
	
	do
		{
		ss.__DbgFailNext(failure);
		
		newConn.Write(out, writeStat);
		User::WaitForRequest(writeStat);
		
		failure++;
		}
        while(writeStat.Int() != KErrNone);
		
	// flush the hanging __DbgFailNext
	ss.__DbgFailNext(-1);
	Logger().WriteFormat(_L("Info: Loop has passed %d times"), failure - 1);
	
	User::WaitForRequest(readStat);
	err = readStat.Int();
	// Depending upon the number of lazy allocs the read may already have been non-fatally failed - try again now we're out of OOM
	if (err == KErrNoMemory)
		{
		clientSock.Read(in, readStat);
		User::WaitForRequest(readStat);
		err = readStat.Int();
		}
	if (err != KErrNone)
		{
		Logger().WriteFormat(_L("Read returned err=%d"), err);
		User::Leave(EFail);
		}
	
	//-------------------substep 03-----------------------------	
	Logger().Write(_L("03 Set heap to fails after N=0 allocations..."));
	Logger().Write(_L("   ...Call Read method. If it returns error, check memory leak."));
	Logger().Write(_L("   ...Increase N and repeat the same until read method returns NoError:"));
	failure = 0;
	
	newConn.Write(out, writeStat);
	
	do
		{
		ss.__DbgFailNext(failure);
		
		clientSock.Read(in, readStat);
		User::WaitForRequest(readStat);
		
		failure++;
		}
		while(readStat.Int() != KErrNone);
		
	// To flush the hanging __DbgFailNext
	ss.__DbgFailNext(-1);
	
	Logger().WriteFormat(_L("Info: Loop has passed %d times"), failure - 1);
	
	User::WaitForRequest(writeStat);
	err = writeStat.Int();
	if(err != KErrNone)
		{
		Logger().WriteFormat(_L("Write returned err=%d"), err);
		User::Leave(EFail);
		}
	
	//-------------------substep 05-----------------------------
	Logger().Write(_L("04 Cleanup stack. Close the sockets & socket server"));
	
	CleanupStack::PopAndDestroy(4);
	
//	heapSockServer.__DbgCheckHeap(0);
	
	CleanupStack::PopAndDestroy();
	
	Logger().WriteFormat(_L("Got here OK"));
	
	return EPass;
#else
	Logger().WriteFormat(_L("Info: Test Disabled on release build"));
	return EPass;
#endif
}