// Copyright (c) 2000-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:

//

#include <e32std.h>

#include <e32test.h>

#include <push/pushmessage.h>

#include <push/cpushhandlerbase.h>

#include <push/pushlog.h>

#include "testlog.h"

#include "t_failure.h"

_LIT(KTestTitle,"T_Failure");

_LIT8(KHeader,"This is a dummy header");

_LIT8(KBody,"This is a dummy message body");

_LIT(KAppIdBufFormat, "0x%08x");

// Setting up parameters for CPushHandlerBase::NewL()

const TInt KAppId = 2;

const TInt KAppIdLength = 10;

// Global variables

RTest gTest(_L("t_Failure Test Harness"));

CPushMessageTester* CPushMessageTester::NewL()

	{

	CPushMessageTester* self = new (ELeave) CPushMessageTester();

	return self;

	}

CPushMessageTester::CPushMessageTester()

	{

	}

CPushMessageTester::~CPushMessageTester()

	{

	delete iHeader;

	delete iBody;

	delete iMessage;

	}

void CPushMessageTester::PluginFailureTestL()

	{

	TBuf<KAppIdLength> AppIdBuf;

	AppIdBuf.Format(KAppIdBufFormat, KAppId);

	CPushHandlerBase* pushHandler = NULL; 

	pushHandler = CPushHandlerBase::NewL(AppIdBuf, KUidPushHandlerBase);

	delete pushHandler;

	}

void CPushMessageTester::FailureTestL()

	{

	// constructing CPushMessage with the arguments as member variables

	iHeader	= KHeader().AllocL();

	iBody	= KBody().AllocL();

	iMessage = CPushMessage::NewL(iHeader, iBody);

	iHeader = NULL;

	iBody = NULL;

	}

CFailureTester* CFailureTester::NewL(CWapPushLog& aLog)

	{

	CFailureTester* self = new (ELeave) CFailureTester(aLog);

	return self;

	}

CFailureTester::CFailureTester(CWapPushLog& aLog)

:iLog(aLog)

	{

	}

CFailureTester::~CFailureTester()

	{

	delete iScheduler;

	}

void CFailureTester::LogFormatInt(const TDesC& aFormat, TInt aInt)

	{

	iFormatBuffer.Format(aFormat, aInt);

	iLog.WPLPrintf(iFormatBuffer);

	}

void CFailureTester::LogFormatInt(const TDesC& aFormat, TInt aInt1, TInt aInt2)

	{

	iFormatBuffer.Format(aFormat, aInt1, aInt2);

	iLog.WPLPrintf(iFormatBuffer);

	}

void CFailureTester::LogFormatStr(const TDesC& aFormat, const TDesC& aDes)

	{

	iFormatBuffer.Format(aFormat, &aDes);

	iLog.WPLPrintf(iFormatBuffer);

	}

void CFailureTester::LogStr(const TDesC& aDes)

	{

	iLog.WPLPrintf(aDes);

	}

void CFailureTester::HeapFailureTest()

	{

	__LOG_ALWAYS("Test Results");

	__LOG_ALWAYS(" ");

	__LOG_ALWAYS("***** HEAP FAILURE TEST FOR PUSH MESSAGE *****");

	TInt error;

	TBool finished = EFalse;

	TInt failCount = 0;

	CPushMessageTester* push = NULL;

	while(!finished)

		{

		__UHEAP_FAILNEXT(failCount++);

		__UHEAP_MARK;

		TRAP(error, push = DoPushMessageTestL());

		if (error == KErrNone)

			{

			delete push;

			__UHEAP_RESET;

			LogFormatInt(_L("Made %d attempts at calling DoPushMessageTestL()"), failCount);

			finished = ETrue;

			}

		else  // Handle error

			{

			// Check if error is out of memory

			gTest(error == KErrNoMemory);

			__UHEAP_RESET;

			}

		__UHEAP_MARKEND;

		}

	__LOG_ALWAYS("RTEST: SUCCESS ***** PUSH MESSAGE TEST SUCCESSFUL ******");

	__LOG_ALWAYS(" ");

	}

void CFailureTester::PluginHeapFailureTest()

	{

	__LOG_ALWAYS("***** HEAP FAILURE TEST FOR PLUGIN *****");

	TInt error;

	TBool finished = EFalse;

	TInt failCount = 0;

	CPushMessageTester* push = NULL;

	while(!finished)

		{

		__UHEAP_FAILNEXT(failCount++);

		__UHEAP_MARK;

		TRAP(error, push = CreatePushHandlerBaseL());

		if (error == KErrNone)

			{

			delete push;

			__UHEAP_RESET;

			LogFormatInt(_L("Made %d attempts at calling CreatePushHandlerBaseL()"), failCount);

			finished = ETrue;

			}

		else  // Handle error

			{

			// Check if error is out of memory

			gTest(error == KErrNoMemory);

			__UHEAP_RESET;

			}

		REComSession::FinalClose();

		__UHEAP_MARKEND;

		}

	__LOG_ALWAYS("RTEST: SUCCESS ***** PLUGIN TEST SUCCESSFUL ******");

	__LOG_ALWAYS(" ");

	__LOG_ALWAYS("Tests Completed");

	}

CPushMessageTester* CFailureTester::DoPushMessageTestL()

	{

	// First case

	CPushMessageTester* tester = CPushMessageTester::NewL();	

	CleanupStack::PushL(tester);

	tester->FailureTestL();

	// Second case

	CPushMessage* message = DoPushMessageTest2L();

	delete message;

	CleanupStack::Pop(tester);

	return tester;	

	}

CPushMessageTester*  CFailureTester::CreatePushHandlerBaseL()

	{

	CPushMessageTester* tester = CPushMessageTester::NewL();	

	CleanupStack::PushL(tester);

	tester->PluginFailureTestL();

	CleanupStack::Pop(tester);

	return tester;	

	}

CPushMessage* CFailureTester::DoPushMessageTest2L()

	{

	// constructing CPushMessage with the arguments put on the cleanupstack

	HBufC8*	header	= KHeader().AllocLC();

	HBufC8* body	= KBody().AllocLC();

	CPushMessage* push = CPushMessage::NewL(header, body);	

	CleanupStack::Pop(2);  //Header, Body

	return push;	

	}

void CFailureTester::InitSchedulerL()

	{

	iScheduler = new (ELeave) CActiveScheduler();

	CActiveScheduler::Install( iScheduler );

	}

/**

 * setup test environment, create CFailureTester object and run tests.

 * 

 * This is an OOM test. 

 * It tests 3 cases: 

 * (i) constructing CPushMessage with the arguments as member variables.

 * (ii) constructing CPushMessage with the arguments put on the cleanupstack.

 * (iii) constructing CPushHandlerBase 

 * Running Instructions:

 * 1. Build this test harness:	cd \wappush\pushutils\group

 *								bldmake bldfiles

 *								abld test build wins udeb t_failure

 * 2. Create log directories in	c:\logs\push 

 * 3. Run TFailure.exe:			cd \epoc32\release\wins\udeb

 *								tfailure -dtextshell -- 

 */

LOCAL_C void doMainL()

	{

	gTest.Start(KTestTitle);

	gTest.Printf(_L("@SYMTestCaseID IWS-WAPBROWSER-PUSHUTILS-T_FAILURE-0001 "));	

	CWapPushLog* log = CWapPushLog::NewL(*gTest.Console());

	log->SetLogFileName(_L("TFailure.txt"));

	CleanupStack::PushL(log);

	CFailureTester* myTester = CFailureTester::NewL(*log);

	CleanupStack::PushL(myTester);

	myTester->HeapFailureTest();

	myTester->InitSchedulerL();

	myTester->PluginHeapFailureTest();

	CleanupStack::PopAndDestroy(2, log); //log, myTester

	gTest.End();

	gTest.Close();

	}

/** entry point for test executable */

GLDEF_C TInt E32Main()

	{	

	__UHEAP_MARK;

	CTrapCleanup* theCleanup = CTrapCleanup::New();

	TRAPD(ret,doMainL());		

	gTest(ret==KErrNone);

	delete theCleanup;	

	__UHEAP_MARKEND;

	return(KErrNone);

	}