/*

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

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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 <test/testexecutelog.h>

#include <s32mem.h>

#include "cafserver.h"

#include "oomstep.h"

#include "content.h"

#include "data.h"

#include "supplier.h"

#include "cafmimeheader.h"

#include "importfile.h"

#include "supplieroutputfile.h"

#include "attribute.h"

#include "bitset.h"

using namespace ContentAccess;

const TInt KOomReadContent = 1;

const TInt KOomSupply = 2;

/* 

 * This step imports a DCF file into CAF 

 *

 */

CCafOomStep::~CCafOomStep()

	{

	}

CCafOomStep::CCafOomStep(CCAFServer& aParent) : iParent(aParent)

	{

	SetTestStepName(KCAFOomStep);

	}

TVerdict CCafOomStep::doTestStepL()

	{

	SetTestStepResult(EInconclusive);

	TInt failCount=1;

	TInt ret=-1;

	const TInt MaxAllocationFailures=450;

	TInt OomTest = KErrNotFound;

	GetIntFromConfig(ConfigSection(),_L("OomTest"),OomTest);

	if(OomTest == 2)

		{

		INFO_PRINTF2(_L("Starting Apparc..."),failCount);	

		StartApparcServerL();

		User::After(500000); // Allow async libraries to unload

		}

	while(failCount < MaxAllocationFailures && OomTest > 0)

		{

		// Mark heap and set allocation to fail

		__UHEAP_MARK;	

		switch(OomTest)

			{

		case KOomReadContent:

			INFO_PRINTF2(_L("ReadContent() __UHEAP_FAILNEXT: %d"),failCount);	

			__UHEAP_FAILNEXT(failCount);

			TRAP(ret,OomReadContentL());

			break;

		case KOomSupply:

			INFO_PRINTF2(_L("Supply() __UHEAP_FAILNEXT: %d"),failCount);	

			__UHEAP_FAILNEXT(failCount);

			TRAP(ret,OomSupplyL());

			break;

		default:

			INFO_PRINTF2(_L("Out of Memory test %d does not exist"),OomTest);

			SetTestStepResult(EFail);

			ret = KErrNone;

			break;

			};

		User::After(500000); // Allow async libraries to unload

		// Check all heap is free'd

		__UHEAP_MARKEND;

		// cancel heap failure

		__UHEAP_RESET;

		if(ret == KErrNone)

			{

			// Allocation failure has been moved all the way through the test

			// Succeeded after failCount allocations

			return TestStepResult();

			}

		else 

			{

			// Try failing a little further into the process

			failCount++;

			}

		}

	// We must have reached our maximum number of allocation failures

	// There must be some other problem 

	SetTestStepResult(EFail);

	return TestStepResult();

	}	

TVerdict CCafOomStep::OomReadContentL()

	{

	TBuf8<2> buffer;

	TRequestStatus status;

	TPtrC uri;

	GetStringFromConfig(ConfigSection(),_L("URI"),uri);

	CContent* content = CContent::NewLC(uri);

	CData* data = content->OpenContentL(EPeek);

	CleanupStack::PushL(data);

	TInt size = 0;

	data->DataSizeL(size);

	// Seek and read from start using both CAF and RFile

	TInt pos = size/4;

	data->Seek(ESeekStart, pos);

	data->Read(buffer);

	pos=0;

	data->Seek(ESeekCurrent, pos);

	data->Read(buffer,1,status);

	User::WaitForRequest(status);

	CleanupStack::PopAndDestroy(2, content);

	SetTestStepResult(EPass);

	return TestStepResult();

	}

TVerdict CCafOomStep::OomSupplyL()

	{

	SetTestStepResult(EInconclusive);

	RFs fs;

	RFile file;

	TBuf8 <128> readBuffer;

	TPtrC outputDirectory, sourceFileName, suggestedFileName, mimeType;

	TInt expectedLeave;

	// Get parameters from INI file

	GetStringFromConfig(ConfigSection(),_L("OutputPath"),outputDirectory);

	GetStringFromConfig(ConfigSection(),_L("SourceFileName"),sourceFileName);

	GetStringFromConfig(ConfigSection(),_L("SuggestedFileName"),suggestedFileName);

	GetStringFromConfig(ConfigSection(),_L("MimeType"),mimeType);

	GetIntFromConfig(ConfigSection(),_L("LeaveResult"),expectedLeave);

	// delete any file previously supplied, don't care if this 

	// has errors so trap.

	Delete(_L("C:\\supplied.drm"));

	Delete(_L("C:\\receipt.txt"));

	HBufC8 *mime = ConvertDes16toHBufC8LC(mimeType);

	CCafMimeHeader *header = CCafMimeHeader::NewL(mime->Des());

	CleanupStack::PushL(header);

	CSupplier *mySupplier = CSupplier::NewLC();

	mySupplier->SetOutputDirectoryL(outputDirectory);

	// ignore return value, just exercises code for CCover

	mySupplier->IsImportSupported(header->StandardMimeData(EContentType));

	CImportFile *import = NULL;

	import = mySupplier->ImportFileL(*header, suggestedFileName);

	CleanupStack::PushL(import);

	// read the input file and pass it to the CAF

	fs.Connect();

	CleanupClosePushL(fs);

	TInt result = file.Open(fs, sourceFileName, EFileRead | EFileStream | EFileShareAny);

	CleanupClosePushL(file);

	while(result == KErrNone)

		{

		result = file.Read(readBuffer);

		if(readBuffer.Length() == 0)

			break;

		User::LeaveIfError(import->WriteData(readBuffer));

		}

	CleanupStack::PopAndDestroy(&file); 

	User::LeaveIfError(import->WriteDataComplete());

	TInt n = import->OutputFileCountL();

	if(n > 0)

		{

		// get output file type (content or receipt)

		TOutputType outputType = import->OutputFileL(0).OutputType();

		// get output file name, but ignore it because it would cause a warning

		import->OutputFileL(0).FileName();

		// get output file mime type

		TPtrC8 OutputMimeType = import->OutputFileL(0).MimeTypeL();

		HBufC *outmime = ConvertDes8toHBufC16LC(OutputMimeType );

		CleanupStack::PopAndDestroy(outmime); 

		if(outputType != EContent)

			{

			SetTestStepResult(EFail);

			}

		else

			{

			// check an attribute, it's only a reference so no need to delete it

			import->OutputFileL(0).AttributesL(ETrue);

			}

		}

	CleanupStack::PopAndDestroy(&fs); 

	CleanupStack::PopAndDestroy(import); 

	CleanupStack::PopAndDestroy(mySupplier); 

	CleanupStack::PopAndDestroy(header); 

	CleanupStack::PopAndDestroy(mime); 

	if (TestStepResult() != EFail)

		{

		SetTestStepResult(EPass);

		}

	return TestStepResult();

	}