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

// This contains ESock Test cases from section 6

// 

//

// EPOC includes

#include <e32base.h>

#include <dns_qry.h>

#include <es_sock.h>

// Test system includes

#include "SocketTestSection6.h"

// Test step 6.1

const TDesC& CSocketTest6_1::GetTestName()

	{

	_LIT(ret,"Test6.1");

	return ret;

	}

enum TVerdict CSocketTest6_1::InternalDoTestStepL( void )

	{

	TVerdict verdict = EPass;

	Logger().WriteFormat(_L("Test Purpose: Out of Memory During Connect"));

#if defined (_DEBUG_SOCKET_FUNCTIONS)

	// connect to esock

	Logger().WriteFormat(_L("Attempting to connect to socket server"));

    RSocketServ ss;

	TInt ret = OptimalConnect(ss);

	CleanupClosePushL(ss);

	Logger().WriteFormat(_L("Connect returned %S"), &EpocErrorToText(ret));

	TESTL(KErrNone == ret);

	Logger().WriteFormat(_L("Starting OOM Connect loop"));

	TInt failure = 0;

	RSocketServ ss2;

	ret = -1;

	//	ss.__DbgMarkHeap();		// in ESOCKMT leak checking is best done by shutting down the server

	while (ret != KErrNone)

		{

		Logger().WriteFormat(_L("Failing after %d allocs"), failure);

		ss.__DbgFailNext(failure);

		ret = OptimalConnect(ss2);

		//		if (ret != KErrNone)

		//			ss.__DbgCheckHeap(0);

		failure++;

		}

	Logger().WriteFormat(_L("Connected OK"));

	ss2.Close();

	//	ss.__DbgMarkEnd(0);

	ss.__DbgFailNext(-1);

	CleanupStack::Pop(&ss);

	ss.Close();

#else

	Logger().WriteFormat(_L("TestDisabled on release build."));

	verdict = EInconclusive;

#endif

	SetTestStepResult(verdict);

	return verdict;

	}

// Test step 6.2

const TDesC& CSocketTest6_2::GetTestName()

	{

	_LIT(ret,"Test6.2");

	return ret;

	}

enum TVerdict CSocketTest6_2::InternalDoTestStepL( void )

	{

	TVerdict verdict = EPass;

	Logger().WriteFormat(_L("Test Purpose: Out of Memory Conditions for Socket Open"));

#if defined (_DEBUG_SOCKET_FUNCTIONS)

	// connect to esock

	Logger().WriteFormat(_L("Attempting to connect to socket server"));

    RSocketServ ss;

	TInt ret = OptimalConnect(ss);

	CleanupClosePushL(ss);

	Logger().WriteFormat(_L("Connect returned %S"), &EpocErrorToText(ret));

	TESTL(KErrNone == ret);

	Logger().WriteFormat(_L("Trying FindProtocol"));

	TProtocolDesc protoInfo;

	ret = ss.FindProtocol(_L("Dummy Protocol 1"), protoInfo);

	Logger().WriteFormat(_L("FindProtocol returned %S"), &EpocErrorToText(ret));

	TESTL(KErrNone == ret);

	// Flush any FailNext there might be hanging around.

	ss.__DbgFailNext(-1);

	// test OOM during socket open

	//	ss.__DbgMarkHeap();		// in ESOCKMT leak checking is best done by shutting down the server

	TInt failure = 0;

	RSocket sock;

	ret = -1;

	Logger().WriteFormat(_L("Starting OOM Socket Open Loop"));

	while (ret != KErrNone)

		{

		Logger().WriteFormat(_L("Failing after %d allocs"), failure);

		ss.__DbgFailNext(failure);

		ret = sock.Open(ss, protoInfo.iAddrFamily, protoInfo.iSockType, protoInfo.iProtocol);

		failure++;

		}

	Logger().WriteFormat(_L("Opened socket OK"));

	sock.Close();

	//	ss.__DbgMarkEnd(0);

	// Flush any FailNext there might be hanging around.

	ss.__DbgFailNext(-1);

	CleanupStack::Pop(&ss);

	ss.Close();

#else

	Logger().WriteFormat(_L("TestDisabled on release build."));

	verdict = EInconclusive;

#endif

	SetTestStepResult(verdict);

	return verdict;

	}

// Test step 6.3

const TDesC& CSocketTest6_3::GetTestName()

	{

	_LIT(ret,"Test6.3");

	return ret;

	}

enum TVerdict CSocketTest6_3::InternalDoTestStepL( void )

	{

	TVerdict verdict = EPass;

	Logger().WriteFormat(_L("Test Purpose: Out of Memory Conditions for Host Resolver"));

#if defined (_DEBUG_SOCKET_FUNCTIONS)

	// connect to esock

	Logger().WriteFormat(_L("Attempting to connect to socket server"));

    RSocketServ ss;

	TInt ret = OptimalConnect(ss);

	CleanupClosePushL(ss);

	Logger().WriteFormat(_L("Connect returned %S"), &EpocErrorToText(ret));

	TESTL(KErrNone == ret);

	Logger().WriteFormat(_L("Trying FindProtocol"));

	TProtocolDesc protoInfo;

	ret = ss.FindProtocol(_L("Dummy Protocol 1"), protoInfo);

	Logger().WriteFormat(_L("FindProtocol returned %S"), &EpocErrorToText(ret));

	TESTL(KErrNone == ret);

	// Host resolvers

	//	ss.__DbgMarkHeap();		// in ESOCKMT leak checking is best done by shutting down the server

	TInt failure = 0;

	RHostResolver hResolv;

	ret = -1;

	Logger().WriteFormat(_L("Starting OOM Host Resolver Open Loop"));

	while (ret != KErrNone)

		{

		Logger().WriteFormat(_L("Failing after %d allocs"), failure);

		ss.__DbgFailNext(failure);

		ret = hResolv.Open(ss, protoInfo.iAddrFamily, protoInfo.iProtocol);

		failure++;

		}

	Logger().WriteFormat(_L("Opened host resolver OK"));

	hResolv.Close();

	//	ss.__DbgMarkEnd(0);

	// Flush any FailNext there might be hanging around.

	ss.__DbgFailNext(-1);

	// Test OOM on Query()

    Logger().WriteFormat(_L("Testing OOM handling of RHostResolver::Query()"));

	ret = hResolv.Open(ss, protoInfo.iAddrFamily, protoInfo.iProtocol);

	TESTL(KErrNone == ret);

    TDnsQueryBuf dnsQryBuf;

	TDnsRespABuf dnsRespABuf;

    dnsQryBuf().SetType(KDnsRRTypeA);

    dnsQryBuf().SetData(_L8("http://www.sample.net/"));

    // create a timer to catch esock hanging

	RTimer timer;

	timer.CreateLocal();

	CleanupClosePushL(timer);

	const TUint oneSec(1000000);

	TRequestStatus timerStatus;

	TRequestStatus status(KErrNoMemory);

	TUint failCount(0);

	// slowly increase the fail count until success

	while(KErrNoMemory == status.Int() && failCount < 20)

		{

		Logger().WriteFormat(_L("Checking Query with %d allocs before failure"), failCount);

		ss.__DbgFailNext(failCount++);

		hResolv.Query(dnsQryBuf, dnsRespABuf, status);

		timer.After(timerStatus, oneSec);

		User::WaitForRequest(status, timerStatus);

		timer.Cancel();

		User::WaitForAnyRequest();

		}

	// check query eventually finished ok

	ss.__DbgFailNext(-1);

	TESTL(KErrNone == status.Int());

	CleanupStack::PopAndDestroy(&timer);

	CleanupStack::Pop(&ss);

	ss.Close();

#else

	Logger().WriteFormat(_L("TestDisabled on release build."));

	verdict = EInconclusive;

#endif

	SetTestStepResult(verdict);

	return verdict;

	}

// Test step 6.4

const TDesC& CSocketTest6_4::GetTestName()

	{

	_LIT(ret,"Test6.4");

	return ret;

	}

enum TVerdict CSocketTest6_4::InternalDoTestStepL( void )

	{

	TVerdict verdict = EPass;

	Logger().WriteFormat(_L("Test Purpose: Out of Memory Conditions for Service Resolver"));

#if defined (_DEBUG_SOCKET_FUNCTIONS)

	// connect to esock

	Logger().WriteFormat(_L("Attempting to connect to socket server"));

    RSocketServ ss;

	TInt ret = OptimalConnect(ss);

	CleanupClosePushL(ss);

	Logger().WriteFormat(_L("Connect returned %S"), &EpocErrorToText(ret));

	TESTL(KErrNone == ret);

	Logger().WriteFormat(_L("Trying FindProtocol"));

	TProtocolDesc protoInfo;

	ret = ss.FindProtocol(_L("Dummy Protocol 1"), protoInfo);

	Logger().WriteFormat(_L("FindProtocol returned %S"), &EpocErrorToText(ret));

	TESTL(KErrNone == ret);

	// Flush any FailNext there might be hanging around.

	ss.__DbgFailNext(-1);

	// service resolvers

	//	ss.__DbgMarkHeap();		// in ESOCKMT leak checking is best done by shutting down the server

	TInt failure = 0;

	RServiceResolver sResolv;

	ret = -1;

	Logger().WriteFormat(_L("Starting OOM Service Resolver Open Loop"));

	while (ret != KErrNone)

		{

		Logger().WriteFormat(_L("Failing after %d allocs"), failure);

		ss.__DbgFailNext(failure);

		ret = sResolv.Open(ss, protoInfo.iAddrFamily, protoInfo.iSockType, protoInfo.iProtocol);

		failure++;

		}

	Logger().WriteFormat(_L("Created service resolver OK"));

	sResolv.Close();

	//	ss.__DbgMarkEnd(0);

	// Flush any FailNext there might be hanging around.

	ss.__DbgFailNext(-1);

	CleanupStack::Pop(&ss);

	ss.Close();

#else

	Logger().WriteFormat(_L("TestDisabled on release build."));

	verdict = EInconclusive;

#endif

	SetTestStepResult(verdict);

	return verdict;

	}

// Test step 6.5

const TDesC& CSocketTest6_5::GetTestName()

	{

	_LIT(ret,"Test6.5");

	return ret;

	}

enum TVerdict CSocketTest6_5::InternalDoTestStepL( void )

	{

	TVerdict verdict = EPass;

	Logger().WriteFormat(_L("Test Purpose: Out of Memory Conditions for Net Database"));

#if defined (_DEBUG_SOCKET_FUNCTIONS)

	// connect to esock

	Logger().WriteFormat(_L("Attempting to connect to socket server"));

    RSocketServ ss;

	TInt ret = OptimalConnect(ss);

	CleanupClosePushL(ss);

	Logger().WriteFormat(_L("Connect returned %S"), &EpocErrorToText(ret));

	TESTL(KErrNone == ret);

	Logger().WriteFormat(_L("Trying FindProtocol"));

	TProtocolDesc protoInfo;

	ret = ss.FindProtocol(_L("Dummy Protocol 1"), protoInfo);

	Logger().WriteFormat(_L("FindProtocol returned %S"), &EpocErrorToText(ret));

	TESTL(KErrNone == ret);

	// Flush any FailNext there might be hanging around.

	ss.__DbgFailNext(-1);

	// net database

	//	ss.__DbgMarkHeap();		// in ESOCKMT leak checking is best done by shutting down the server

	TInt failure = 0;

	RNetDatabase netDb;

	ret = -1;

	Logger().WriteFormat(_L("Starting OOM Net Database Open Loop"));

	while (ret != KErrNone)

		{

		Logger().WriteFormat(_L("Failing after %d allocs"), failure);

		ss.__DbgFailNext(failure);

		ret = netDb.Open(ss, protoInfo.iAddrFamily, protoInfo.iProtocol);

		failure++;

		}

	Logger().WriteFormat(_L("Created net database OK"));

	netDb.Close();

	//	ss.__DbgMarkEnd(0);

	// Flush any FailNext there might be hanging around.

	ss.__DbgFailNext(-1);

	CleanupStack::Pop(&ss);

	ss.Close();

#else

	Logger().WriteFormat(_L("TestDisabled on release build."));

	verdict = EInconclusive;

#endif

	SetTestStepResult(verdict);

	return verdict;

	}