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

// Name of test harness: T_PopFullDsk

// Component: POPS

// Owner: NB

// Brief description of test harness:

// Tests copying messages in POPS when there is a Full Disk

// Detailed description of test harness:

// Implements the following Tests:

// 1 - Test Copy To Local

// 2 - Test Copy Within Service

// 3 - Test Copying from a Local folder to another Local Folder

// 4 - Test Offline Copy

// Input files required to run test harness:

// The following files should be copied to <drive>:\msgtest\pops\

// T_PopFullDsk_CopyAll.scr

// T_PopFullDsk_Populate.scr

// T_PopFullDsk_OfflineCopy.scr

// T_PopFullDsk_Msg.eml

// Output files produced by running test harness:

// <DRIVE>:\msglogs\T_POPSFullDisk.<PLATFORM>.<VARIANT>.LOG.txt

// Description of how to build test harness:

// cd \msg\pops\

// bldmake bldfiles

// abld test build

// Description of how to run test harness:

// (1) You need to create a small partitioned drive (ie less than 20GB) to 

// run the harness on (eg a Compact Flash Card).

// (2) For running on the emulator, alter the epoc32\data\epoc.ini 

// file so that it uses this drive (eg    _EPOC_DRIVE_C E:\   

// if E:\ is your small partioned drive ).

// The following instructions are the same for all platforms:

// 1. Build T_DB test harness from COMMDB component:

// cd \commdb\group

// bldmake bldfiles

// abld test build t_db

// 2. Build the test utilities:

// cd \msg\testutils\group\

// bldmake bldfiles

// abld build

// WINS running instructions:

// 1. \epoc32\release\wins\<VARIANT>\T_PopFullDsk.exe can be used at the command prompt

// or executable can be run from Windows Explorer.

// All other platform running instructions:

// 1. Copy \epoc32\release\<PLATFORM>\<VARIANT>\T_PopFullDsk.exe onto the other platform

// 2. Copy \epoc32\release\<PLATFORM>\<VARIANT>\MSVTESTUTILS.DLL into 

// <DRIVE>:\system\libs on the other platform

// 3. Copy \epoc32\release\<PLATFORM>\<VARIANT>\EMAILTESTUTILS.DLL into 

// <DRIVE>:\system\libs on the other platform

// 4. Copy \epoc32\wins\c\msgtest\pops\*.* to

// <DRIVE>:\msgtest\pops\

// Note that this drive should be a CF card as the test files are large

// 5. Run T_PopFullDsk.exe on the other platform with the CF card

// Generic POPS Test Harness

// 

//

#include "emailtestutils.h"

#include "scripttestutils.h"

#include <miutlog.h>

#include <miutmsg.h>

#include <txtrich.h>

#include <popsmtm.h>

#include "T_mtmcmd.h"

#include <cemailaccounts.h>

// NOTE:  This is the amout of available Disk Space that we are creating to test

// the Low Disk Space condition.  It definitely has to be less than KMinimumDiskSpaceForSync

// and ideally very small, as more space is made available as the operations are performed.

const TInt KTestDiskSpace = 500;

const TInt KFillDiskTooBigFreeSize		=0x00080000;	// 1/2 Gb in kb

const TInt KFillDiskOneKByte			=0x400;

const TInt KFillDiskMaxBlockSize		=1024;

_LIT(KSubFolder,  "LocalFolder");

_LIT(KSessionPath, "c:\\");

_LIT(KTestMsgPath, "c:\\msgtest\\pops\\T_PopFullDsk_Msg.eml");  

_LIT(KMsvTestFillDiskFile,	"c:\\Dummy fill file");

_LIT(K_POPS_COMPONENT_NAME, "POPS");

_LIT(K_SCRIPT_COPY_ALL,		"T_PopFullDsk_CopyAll.scr");

_LIT(K_SCRIPT_POPULATE_ALL, "T_PopFullDsk_Populate.scr");

_LIT(K_SCRIPT_OFFLINE_COPY, "T_PopFullDsk_OfflineCopy.scr");

_LIT(KTest1Pass, "Test 1 OK, Copy To Local Failed correctly with KErrDiskFull");

_LIT(KTest2Pass, "Test 2 OK, Copy Within Service Failed correctly with KErrDiskFull");

_LIT(KTest3Pass, "Test 3 OK, Local Copy Failed correctly with KErrDiskFull");

_LIT(KTest1Failed, "Test 1 Failed, Copy To Local should NOT have completed");

_LIT(KTest2Failed, "Test 2 Failed, CopyWithin Service should NOT have completed");

_LIT(KTest3Failed, "Test 3 Failed, Local Copy should NOT have completed");

const TInt KMsvTestBackgroundDeleteInitialWait	=1000000;

_LIT(KImcmTest, "T_POPSFullDisk - Test Copy when Disk Full");

RTest test(KImcmTest);

class CDelayTimer : public CTimer

	{

public:

	CDelayTimer() : CTimer(EPriorityHigh)

		{}

	void ConstructL()

		{ CTimer::ConstructL(); CActiveScheduler::Add(this); }

	void RunL(void)

		{ CActiveScheduler::Stop(); }

	void Delay(TTimeIntervalMicroSeconds32 anInterval)

		{ CTimer::After(anInterval); CActiveScheduler::Start(); }

	};

//-------------------------------------

//		CPopsTestHarness

//-------------------------------------

class CPopsTestHarness : public CBase

	{

public:

	static CPopsTestHarness* NewLC();

	~CPopsTestHarness();

	void RunTestsL();

private:

	CPopsTestHarness();

	void ConstructL();

	void InitL();

	void ResetL();

	void StartTestL(CMtmTestHarness& aTestCommands);

	void CopyScriptFileL(const TDesC& aScriptFile);

	void EndTestL();

	void EndTestHarnessL();

	// Fns to fill the disk

	void FillDiskL();

	TInt CheckDiskSpace(TInt64& aFreeSpace);

	void TestAvailableSpaceOnDriveL();

	// The Testing Functions

	void TestCopyToLocalL(const TDesC& aPassText, const TDesC& aFailText);

	void TestCopyWithinServiceL(const TDesC& aPassText, const TDesC& aFailText);

	void TestLocalCopyL(const TDesC& aPassText, const TDesC& aFailText);

	void TestOfflineCopyL(const TDesC& aPassText, const TDesC& aFailText);

	void DoLocalCopyTestL();

	void CheckIfTestFailedL(TInt aError, CMtmTestHarness& aTestHarness,const TDesC& aPassText, const TDesC& aFailText);

	void SetUpTestL(const TDesC& aScriptFile);

	void SetUpPopServiceL();

	void CreateTestHarnessesL();

	void ResetMtmL();

public:

	CMtmTestHarness*	iConnectAndCopyAll;

	CMtmTestHarness*	iConnectAndPopulateAll;

	CMtmTestHarness*	iOfflineCopy;

private:

	TBool				iRemoveMailFolder;

	TInt				iTestError;

	TInt				iTestNumber;

	TInt				iGlobalError;

	TMsvId				iPop3Service;

	CEmailTestUtils*	iTestUtils;

	CScriptTestUtils*	iScriptUtils;

	};

//

CPopsTestHarness::CPopsTestHarness() 

: iGlobalError(KErrNone)

	{

	}

CPopsTestHarness::~CPopsTestHarness()

	{

	delete iTestUtils;

	delete iScriptUtils;

	delete iConnectAndCopyAll;

	delete iConnectAndPopulateAll;

	delete iOfflineCopy;

	}

CPopsTestHarness* CPopsTestHarness::NewLC()

	{

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

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

void CPopsTestHarness::ConstructL()

	{

	iTestUtils = CEmailTestUtils::NewL(test);

	InitL();

	}

void CPopsTestHarness::SetUpTestL(const TDesC& aScriptFile)

	{

	// Delete any old dummy fill files 

	iTestUtils->FileSession().Delete(KMsvTestFillDiskFile);

	// Reset & Copy the script file before filling the Disk

	ResetL();

	CopyScriptFileL(aScriptFile); 

	}

void CPopsTestHarness::RunTestsL()

	{

	iTestNumber = 0;

	iRemoveMailFolder = ETrue;

	SetUpPopServiceL();

	// 1 - Test Copy To Local

	TestCopyToLocalL(KTest1Pass, KTest1Failed);

	// 2 - Test Copy Within Service

	TestCopyWithinServiceL(KTest2Pass, KTest2Failed);

	// 3 - Test Copying from a Local folder to another Local Folder

	TestLocalCopyL(KTest3Pass, KTest3Failed);

	// 4 - Test Offline Copy

//	TestOfflineCopyL(KTest4Pass, KTest4Failed);

	// Enf of the Tests	

	EndTestHarnessL();

	}

void CPopsTestHarness::TestCopyToLocalL(const TDesC& aPassText, const TDesC& aFailText)

// ------------------------------------

// Test Copying To Local

// ------------------------------------

	{

	iTestError = 0;

	iTestNumber++;

	SetUpTestL(K_SCRIPT_COPY_ALL);

	FillDiskL();

	TRAPD(testError, StartTestL(*iConnectAndCopyAll));

	// Check if the Test Failed

	CheckIfTestFailedL(testError, *iConnectAndCopyAll, aPassText, aFailText);

	EndTestL();

	}

void CPopsTestHarness::TestCopyWithinServiceL(const TDesC& aPassText, const TDesC& aFailText)

// ------------------------------------

// Test Copy Within Service

// ------------------------------------

	{

	iTestError = 0;

	iTestNumber++;

	SetUpTestL(K_SCRIPT_POPULATE_ALL);

	FillDiskL();

	TRAPD(testError, StartTestL(*iConnectAndPopulateAll));

	// Check if the Test Failed

	CheckIfTestFailedL(testError, *iConnectAndPopulateAll, aPassText, aFailText);

	EndTestL();

	}

void CPopsTestHarness::TestLocalCopyL(const TDesC& aPassText, const TDesC& aFailText)

// ------------------------------------------------------------------

// Test Copying from a Local folder to another Local Folder

// ------------------------------------------------------------------

	{

	iTestError = 0;

	iTestNumber++;

	// Reset the harness & run the Test

	iTestUtils->FileSession().Delete(KMsvTestFillDiskFile);

	ResetL();

	iTestUtils->TestStart(iTestNumber);

	TRAPD(error, DoLocalCopyTestL());

		// Delete the fill file, so we can write to the log

	iTestUtils->FileSession().Delete(KMsvTestFillDiskFile);

	if (error == KErrDiskFull)

		{

		// Test OK = We could not Copy, as the disk was too Full

		iTestUtils->WriteComment(aPassText);

		}

	else if (error == KErrNone)

		{

		// ERROR - The Copy completed, even though the Disk was Full

		iTestUtils->WriteComment(aFailText);

		iTestError = KErrGeneral;

		}

	EndTestL();

	}

void CPopsTestHarness::TestOfflineCopyL(const TDesC& aPassText, const TDesC& aFailText)

// ------------------------------------------------------------------

// Test Offline Copy - Populate some Messages & then try to create 

// Offline Ops to copy them locally

// ------------------------------------------------------------------

	{

	iTestError = 0;

	iTestNumber++;

	// Connect & Populate all the messages first

	SetUpTestL(K_SCRIPT_POPULATE_ALL);

	TRAPD(test2Error, StartTestL(*iConnectAndPopulateAll));

	// Now reset, but DONT delete the Mail directory. 

	iRemoveMailFolder = EFalse;

	SetUpTestL(K_SCRIPT_OFFLINE_COPY);

	// Fill the Disk & attempt to do an Offline Copy

	FillDiskL();

	TRAPD(error, StartTestL(*iOfflineCopy));

	// Check if the Test Failed

	CheckIfTestFailedL(error, *iOfflineCopy, aPassText, aFailText);

	EndTestL();

	}

void CPopsTestHarness::DoLocalCopyTestL()

// Test copying a message locally.  ie create a message in the Drafts folder

// and copy it to a local sub folder

	{

	// Create the Message in the Drafts Folder

	iTestUtils->CreateMessageL(KTestMsgPath, KMsvDraftEntryId, KMsvDraftEntryId);

	CMsvServerEntry* serverEntry = iTestUtils->iServerEntry;

	serverEntry->SetEntry(KMsvDraftEntryId);

	CMsvEntrySelection* newMessageList = new (ELeave)CMsvEntrySelection();

	CleanupStack::PushL(newMessageList);

	serverEntry->GetChildren(*newMessageList);

	TMsvId newMessageId = (*newMessageList)[0];

	// Create  a local folder under the Drafts folder

	TMsvEntry parentEntry = serverEntry->Entry();

	TMsvEntry newFolder;

	newFolder.SetStandardFolder(ETrue);

	newFolder.iDetails.Set(KSubFolder);

	newFolder.iType.iUid=KUidMsvFolderEntryValue;

	newFolder.iMtm=parentEntry.iMtm;

	newFolder.iServiceId = parentEntry.iServiceId;

	serverEntry->CreateEntry(newFolder);

	// Fill the Disk Space and attempt to do the Copy

	FillDiskL();

	// Copy the message into the new LOCAL Sub-Folder

	CTestActive* active = new(ELeave) CTestActive;

	CleanupStack::PushL(active);

	serverEntry->CopyEntryL(newMessageId, newFolder.Id(), active->iStatus);

	active->StartL();

	CActiveScheduler::Start();

	CleanupStack::PopAndDestroy(2); // newMessageList, active

	}

void CPopsTestHarness::CheckIfTestFailedL(TInt aError, CMtmTestHarness& aTestHarness,

										  const TDesC& aPassText, const TDesC& aFailText)

	{

	// Delete the fill file, so we can write to the log

	iTestUtils->FileSession().Delete(KMsvTestFillDiskFile);

	if (aError == KErrDiskFull)

		{

		// Test OK = We could not Copy, as the disk was too Full

		iTestUtils->WriteComment(aPassText);

		}

	else if (aError == KErrNone)

		{

		// The test returned ok, so check if the Mtm Test Harness returned an error

		TInt commandError = aTestHarness.CommandError();

		TInt commandStatus = aTestHarness.iStatus.Int();

		if (commandError == KErrDiskFull || commandStatus == KErrDiskFull)

			{

			// Test OK = We could not Copy as the disk was too Full

			iTestUtils->WriteComment(aPassText);

			}

		else

			{

			// ERROR - The Copy completed, even though the Disk was Full

			iTestUtils->WriteComment(aFailText);

			iTestError = KErrGeneral;

			}

		}

	}

void CPopsTestHarness::TestAvailableSpaceOnDriveL()

//

// Make sure there is enougth disk space to run the Tests

//

	{

	const TInt64 KMaximumAllowedFreeSpaceOnDrive=10*1024*1024; // 10MB

	// Get drive information.

	TVolumeInfo volumeInfo;

	User::LeaveIfError(iTestUtils->FileSession().Volume(volumeInfo, EDriveC));

	// Check that the media is present.

	test(volumeInfo.iDrive.iType!=EMediaNotPresent);

	// Check that there is not too much free space (ie 20Gb!)

	test(volumeInfo.iFree<=KMaximumAllowedFreeSpaceOnDrive);

	}

TInt CPopsTestHarness::CheckDiskSpace(TInt64& aFreeSpace)

//

// Check available disk space.

//

	{

	TVolumeInfo volumeInfo;

	TInt error = iTestUtils->FileSession().Volume(volumeInfo, EDriveC);

	aFreeSpace = error?0:volumeInfo.iFree;

	return(error);

	}

void CPopsTestHarness::FillDiskL()

//

// Fill all available space on C: drive leaving aLeaveFreeByes free.

//

	{

	TInt leaveFreeBytes = KTestDiskSpace; 

	// Check that there is a C-drive and that it is less than 10MB in size.

	TestAvailableSpaceOnDriveL();

	// NOTE: This test harness should be used with a dedicated small partition or 

	//       subst'ed floppy drive as the EPOC C: drive. As a safety precaution, it

	//		 tests the free space on the partition to ensure that it does not attempt

	//       to eat 20 GB of free space and either crash Windows or at least cause a

	//       headache of some sort...

	// Delete any old dummy fill files - if there is one to delete.

	iTestUtils->FileSession().Delete(KMsvTestFillDiskFile);

	// Create the delay timer 

	CDelayTimer* delayTimer = new(ELeave)CDelayTimer;

	CleanupStack::PushL(delayTimer);

	delayTimer->ConstructL();

	// Check that available disk space does not exceed the max free space to fill. 

	// See above...

	TInt64 freeSpace;

	TInt64 freeSpaceLeft;

	TInt error = CheckDiskSpace(freeSpace);

	TInt reclaimActive = 0;

	do

		{

		delayTimer->Delay(KMsvTestBackgroundDeleteInitialWait);

		error = CheckDiskSpace(freeSpaceLeft);

		if (freeSpaceLeft == freeSpace)

			reclaimActive++;

		freeSpace = freeSpaceLeft;

		}

	while (!error && reclaimActive<3);

	User::LeaveIfError(error);

	CleanupStack::PopAndDestroy(); //delayTimer

	// Free space in kb.

	freeSpace/=KFillDiskOneKByte;

	// Check free space on C: drive is not too big.

	TInt freeSpaceInKb = I64INT(freeSpace);

	if (freeSpaceInKb>KFillDiskTooBigFreeSize)

		User::Leave(KErrTooBig);

	// Fill disk with large file.

	TBuf8<KFillDiskMaxBlockSize> dummy;

	dummy.SetMax();

	dummy.Fill('?');

	// Open dummy file.

	RFile fillDiskFile;

	User::LeaveIfError(fillDiskFile.Replace(iTestUtils->FileSession(), KMsvTestFillDiskFile, EFileWrite));

	// Establish required dummy file size.

	freeSpaceLeft-=leaveFreeBytes;

	if (freeSpaceLeft<0)

		// Uh oh, we have less space available than what was asked for... 

		User::Leave(KErrDiskFull);

	// Write dummy file.

	while (freeSpaceLeft>0 && error==KErrNone)

		{

		dummy.SetLength(Min(KFillDiskMaxBlockSize,I64INT(freeSpaceLeft)));

		error=fillDiskFile.Write(dummy);

		freeSpaceLeft-=KFillDiskMaxBlockSize;

		}

	fillDiskFile.Close();

	if (error==KErrDiskFull)

		error=KErrNone;

	User::LeaveIfError(error);

	}