diff -r 000000000000 -r 72b543305e3a email/pop3andsmtpmtm/popservermtm/test/src/T_PopFullDsk.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/email/pop3andsmtpmtm/popservermtm/test/src/T_PopFullDsk.cpp Thu Dec 17 08:44:11 2009 +0200 @@ -0,0 +1,742 @@ +// 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 :\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: +// :\msglogs\T_POPSFullDisk...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\\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\\\T_PopFullDsk.exe onto the other platform +// 2. Copy \epoc32\release\\\MSVTESTUTILS.DLL into +// :\system\libs on the other platform +// 3. Copy \epoc32\release\\\EMAILTESTUTILS.DLL into +// :\system\libs on the other platform +// 4. Copy \epoc32\wins\c\msgtest\pops\*.* to +// :\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 +#include +#include +#include +#include "T_mtmcmd.h" +#include + + +// 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 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); + } + +void CPopsTestHarness::ResetMtmL() + { + // Get server MTM. + iTestUtils->Reset(); + + if (iRemoveMailFolder) + { + iTestUtils->CleanMessageFolderL(); + } + else + { + iRemoveMailFolder = ETrue; + } + + iTestUtils->GoServerSideL(); + SetUpPopServiceL(); + iTestUtils->InstantiatePopServerMtmL(); + } + +void CPopsTestHarness::ResetL() + { + ResetMtmL(); + CreateTestHarnessesL(); + } + +void CPopsTestHarness::StartTestL(CMtmTestHarness& aTestCommands) + { + iTestError = KErrNone; + iTestUtils->TestStart(iTestNumber); + + // Run the commands. + aTestCommands.StartL(_L("T_PopFullDsk - POP Copy Disk Full Test Harness")); + } + +void CPopsTestHarness::CopyScriptFileL(const TDesC& aScriptFile) + { + TParse parsedScriptFile; + parsedScriptFile.Set(aScriptFile,0,0); + if (!parsedScriptFile.DrivePresent()) + // This isn't a full path name so we need to resolve it + { + iTestUtils->ResolveFile(K_POPS_COMPONENT_NAME, aScriptFile, parsedScriptFile); + } + iTestUtils->CopyScriptFileL(parsedScriptFile.FullName(), _L("110")); + } + +void CPopsTestHarness::EndTestL() + { + if ((iTestError != KErrNone) && (iGlobalError == KErrNone)) + { + iGlobalError = iTestError; + } + + iTestUtils->TestFinish(iTestNumber, iTestError); + } + +void CPopsTestHarness::EndTestHarnessL() + { + if (iGlobalError == KErrNone) + { + iTestUtils->TestHarnessCompleted(); + } + else + { + iTestUtils->TestHarnessFailed(iGlobalError); + } + } + +void CPopsTestHarness::InitL() + { + iTestUtils->CreateAllTestDirectories(); + iTestUtils->FileSession().SetSessionPath(KSessionPath); + iTestUtils->CleanMessageFolderL(); + iTestUtils->GoServerSideL(); + + iScriptUtils = CScriptTestUtils::NewLC(*iTestUtils); + CleanupStack::Pop(); // iScriptUtils + + iTestUtils->FileSession().SetSessionPath(KSessionPath); + } + +void CPopsTestHarness::SetUpPopServiceL() + { + // Create the POP3 service and set the settings for this test. + iPop3Service = iTestUtils->CreatePopServiceL(); + + CImPop3Settings* settings = new(ELeave) CImPop3Settings(); + CleanupStack::PushL(settings); + + settings->Reset(); + _LIT(KPopServer, "pop3.demon.co.uk"); + settings->SetServerAddressL(KPopServer); + settings->SetLoginNameL(iTestUtils->MachineName()); + settings->SetPasswordL(iTestUtils->MachineName()); + settings->SetPort(110); + settings->SetDisconnectedUserMode(ETrue); // eh xxxx, must test this when set to EFalse + + CEmailAccounts* accounts = CEmailAccounts::NewLC(); + TPopAccount popAccount; + accounts->GetPopAccountL(iPop3Service, popAccount); + accounts->SavePopSettingsL(popAccount, *settings); + CleanupStack::PopAndDestroy(2, settings); // accounts/store, settings + + test.Printf(_L("\nPerforming Tests\n")); + } + + +void CPopsTestHarness::CreateTestHarnessesL() + { + CMsvEntrySelection* serviceSelection = new (ELeave) CMsvEntrySelection; + CleanupStack::PushL(serviceSelection); + serviceSelection->AppendL(iPop3Service); + TBuf8<128> parameter; + + //-------------------------------------------- + // Copy To Local + //-------------------------------------------- + delete iConnectAndCopyAll; + iConnectAndCopyAll = NULL; + iConnectAndCopyAll = CMtmTestHarness::NewL(*(iTestUtils->iPopServerMtm), *iTestUtils); + // Connect + iConnectAndCopyAll->AddCommandL(CMtmTestStartCommand::NewL(*(iTestUtils->iPopServerMtm), serviceSelection, KPOP3MTMConnect, parameter)); + // Copy all messages under the service to the local inbox. + CMtmTestCommand* copyToLocal = CMtmTestCopyToLocal::NewL(*(iTestUtils->iPopServerMtm), 0, KMsvGlobalInBoxIndexEntryId); + iConnectAndCopyAll->AddCommandL(CMtmTestCommandOnAllMessages::NewL(*(iTestUtils->iPopServerMtm), copyToLocal, iPop3Service, *(iTestUtils->iServerEntry))); + // Quit + iConnectAndCopyAll->AddCommandL(CMtmTestStartCommand::NewL(*(iTestUtils->iPopServerMtm), serviceSelection, KPOP3MTMDisconnect, parameter)); + + //-------------------------------------------- + // Copy Within Service + //-------------------------------------------- + delete iConnectAndPopulateAll; + iConnectAndPopulateAll = NULL; + iConnectAndPopulateAll = CMtmTestHarness::NewL(*(iTestUtils->iPopServerMtm), *iTestUtils); + // Connect + iConnectAndPopulateAll->AddCommandL(CMtmTestStartCommand::NewL(*(iTestUtils->iPopServerMtm), serviceSelection, KPOP3MTMConnect, parameter)); + // Copy all messages under the service to the local service. + copyToLocal = CMtmTestCopyWithinService::NewL(*(iTestUtils->iPopServerMtm), 0, iPop3Service); + iConnectAndPopulateAll->AddCommandL(CMtmTestCommandOnAllMessages::NewL(*(iTestUtils->iPopServerMtm), copyToLocal, iPop3Service, *(iTestUtils->iServerEntry))); + // Quit + iConnectAndPopulateAll->AddCommandL(CMtmTestStartCommand::NewL(*(iTestUtils->iPopServerMtm), serviceSelection, KPOP3MTMDisconnect, parameter)); + + + //-------------------------------------------- + // Offline Copy + //-------------------------------------------- + CMsvServerEntry* serverEntry = iTestUtils->iServerEntry; + serverEntry->SetEntry(iPop3Service); + CMsvEntrySelection* newMessageList = new (ELeave)CMsvEntrySelection(); + CleanupStack::PushL(newMessageList); + serverEntry->GetChildren(*newMessageList); + delete iOfflineCopy; + iOfflineCopy = NULL; + iOfflineCopy = CMtmTestHarness::NewL(*(iTestUtils->iPopServerMtm), *iTestUtils); + // Copy all messages under the service to the local inbox. + copyToLocal = CMtmTestCopyToLocal::NewL(*(iTestUtils->iPopServerMtm), newMessageList, KMsvGlobalInBoxIndexEntryId); + iOfflineCopy->AddCommandL(CMtmTestCommandOnAllMessages::NewL(*(iTestUtils->iPopServerMtm), copyToLocal, iPop3Service, *(iTestUtils->iServerEntry))); + // Connect + iOfflineCopy->AddCommandL(CMtmTestStartCommand::NewL(*(iTestUtils->iPopServerMtm), serviceSelection, KPOP3MTMConnect, parameter)); + // Quit + iOfflineCopy->AddCommandL(CMtmTestStartCommand::NewL(*(iTestUtils->iPopServerMtm), serviceSelection, KPOP3MTMDisconnect, parameter)); + + + CleanupStack::PopAndDestroy(2); // newMessageList, serviceSelection + } + + +// + + + +LOCAL_C void doMainL() + { + CActiveScheduler* scheduler; + scheduler = new (ELeave) CActiveScheduler; + CleanupStack::PushL(scheduler); + CActiveScheduler::Install(scheduler); + + // Create the Test Harness & run the Tests + CPopsTestHarness* popsTestHarness = CPopsTestHarness::NewLC(); + popsTestHarness->RunTestsL(); + + CleanupStack::PopAndDestroy(2); // popsTestHarness, scheduler + } + +GLDEF_C TInt E32Main() + { + __UHEAP_MARK; + test.Start(_L("T_PopFullDsk, POP Copy Disk Full Tests")); + CTrapCleanup* theCleanup = CTrapCleanup::New(); + + TRAPD(ret,doMainL()); + test(ret==KErrNone); + delete theCleanup; + test.End(); + test.Close(); + __UHEAP_MARKEND; + User::Heap().Check(); + return(KErrNone); + } + + + + + + + + + + + + + +