// Copyright (c) 2002-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 file contains the test steps for Unit Test Suite 11 : TestStep.cpp

 // 

 //

 // EPOC includes

 #include <e32base.h>

 // Test system includes

 #include <testframework.h>

 // Specific includes for this test suite

 #include "TSU_MmTsthStep11.h"

 #include "TSU_MmTsthSuite11.h"

 // Specific includes for these test steps

 #include "TSU_MmTsth11.h"

 #include "TestStepVirtualStub.h"

 #include "TestSuiteVirtualStub.h"

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

 // Unit Test Suite 11 : TestStep.cpp

 // Depends on : none

 // Requires : subclass implementing pure virtual DoTestStepL()

 // Tests :-

 //	RTestStep() constructor (thru stub)

 //  test accessors

 //	DoTestStepL

 //	DoTestStepPreamble

 //  DoTestStepPostamble

 //	Load / unload config

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

 // RTestMmTsthU1101

 RTestMmTsthU1101* RTestMmTsthU1101::NewL()

 	{

 	RTestMmTsthU1101* self = new(ELeave) RTestMmTsthU1101;

 	return self;

 	}

 // Each test step initialises its own name.

 RTestMmTsthU1101::RTestMmTsthU1101()

 	{

 	iTestStepName = _L("MM-TSTH-U-1101");

 	}

 // preamble

 TVerdict RTestMmTsthU1101::OpenL()

 	{

 	// stub - purpose is that for this test we do not run the parent preamble

 	// which initialises iStepStub

 	return iTestStepResult = EPass;

 	}

 // postamble

 void RTestMmTsthU1101::Close()

 	{

 	}

 // do the test step

 TVerdict RTestMmTsthU1101::DoTestStepL()

 	{

 	INFO_PRINTF1(_L("Unit test for TestStep - construct"));

 	TVerdict currentVerdict = EPass;

 	RTestStepVirtualStub* theStepStub = NULL;

 	TRAPD(err, theStepStub = RTestStepVirtualStub::NewL());

 	if(err != KErrNone)

 		{

 		ERR_PRINTF1(_L("RTestStepVirtualStub::NewL() left"));

 		return iTestStepResult = EFail;

 		}

 	const TPtrC& theName = theStepStub->StepName();

 	if(theName != KTestStepVirtualStubName)

 		{

 		ERR_PRINTF1(_L("RTestStepVirtualStub did not initialise correctly"));

 		delete theStepStub;

 		return iTestStepResult = EFail;

 		}

 	delete theStepStub;

 	return iTestStepResult = currentVerdict; // should be EPass if we've got here

 	}

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

 // RTestMmTsthU1102

 RTestMmTsthU1102* RTestMmTsthU1102::NewL()

 	{

 	RTestMmTsthU1102* self = new(ELeave) RTestMmTsthU1102;

 	return self;

 	}

 // Each test step initialises its own name.

 RTestMmTsthU1102::RTestMmTsthU1102()

 	{

 	iTestStepName = _L("MM-TSTH-U-1102");

 	}

 // do the test step

 TVerdict RTestMmTsthU1102::DoTestStepL()

 	{

 	// RTestStepVirtualStub contains extra methods by which we can verify our accessors

 	INFO_PRINTF1(_L("Unit test for TestStep - accessors"));

 	TVerdict currentVerdict = EPass;

 	// test accessor to set name - not part of RTestStep

 	TBufC<KMaxLenTestStepName> KTestStepName = _L("TestStepName");

 	iStepStub->TestSetStepName(KTestStepName);

 	const TPtrC& theName = iStepStub->StepName();

 	if(theName != KTestStepName)

 		{

 		ERR_PRINTF1(_L("RTestStep::StepName() failed"));

 		return iTestStepResult = EFail;

 		}

 	TVerdict theResult = EInconclusive;

 	iStepStub->SetResult(theResult);

 	// test accessor to get result - not part of RTestStep

 	if(theResult != iStepStub->TestGetResult())

 		{

 		ERR_PRINTF1(_L("RTestStep::SetResult() failed"));

 		return iTestStepResult = EFail;

 		}

 	CTestSuiteVirtualStub* theSuite = new (ELeave) CTestSuiteVirtualStub;

 	CleanupStack::PushL(theSuite);

 	theSuite->ConstructL();

 	iStepStub->SetSuite(theSuite);

 	// test accessor to get suite - not part of RTestStep

 	if(theSuite != iStepStub->TestGetSuite())

 		{

 		ERR_PRINTF1(_L("RTestStep::SetSuite() failed"));

 		CleanupStack::PopAndDestroy(); // theSuite

 		return iTestStepResult = EFail;

 		}

 	// cleanup

 	CleanupStack::PopAndDestroy(); // theSuite

 	return iTestStepResult = currentVerdict; // should be EPass if we've got here

 	}

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

 // RTestMmTsthU1103

 RTestMmTsthU1103* RTestMmTsthU1103::NewL()

 	{

 	RTestMmTsthU1103* self = new(ELeave) RTestMmTsthU1103;

 	return self;

 	}

 // Each test step initialises its own name.

 RTestMmTsthU1103::RTestMmTsthU1103()

 	{

 	iTestStepName = _L("MM-TSTH-U-1103");

 	}

 // do the test step.

 TVerdict RTestMmTsthU1103::DoTestStepL()

 	{

 	// RTestStepVirtualStub contains extra methods by which we can verify our accessors

 	INFO_PRINTF1(_L("Unit test for TestStep - preamble"));

 	TVerdict currentVerdict = EPass;

 	iStepStub->OpenL();

 	if(!iStepStub->PreambleRun())

 		{

 		ERR_PRINTF1(_L("RTestStep::OpenL() failed"));

 		return iTestStepResult = EFail;

 		}

 	return iTestStepResult = currentVerdict; // should be EPass if we've got here

 	}

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

 // RTestMmTsthU1104

 RTestMmTsthU1104* RTestMmTsthU1104::NewL()

 	{

 	RTestMmTsthU1104* self = new(ELeave) RTestMmTsthU1104;

 	return self;

 	}

 // Each test step initialises its own name.

 RTestMmTsthU1104::RTestMmTsthU1104()

 	{

 	iTestStepName = _L("MM-TSTH-U-1104");

 	}

 // do the test step

 TVerdict RTestMmTsthU1104::DoTestStepL()

 	{

 	// RTestStepVirtualStub contains extra methods by which we can verify our accessors

 	INFO_PRINTF1(_L("Unit test for TestStep - postamble"));

 	TVerdict currentVerdict = EPass;

 	iStepStub->Close();

 	if(!iStepStub->PostambleRun())

 		{

 		ERR_PRINTF1(_L("RTestStep::Close() failed"));

 		return iTestStepResult = EFail;

 		}

 	return iTestStepResult = currentVerdict; // should be EPass if we've got here

 	}

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

 // RTestMmTsthU1105

 RTestMmTsthU1105* RTestMmTsthU1105::NewL()

 	{

 	RTestMmTsthU1105* self = new(ELeave) RTestMmTsthU1105;

 	return self;

 	}

 // Each test step initialises its own name.

 RTestMmTsthU1105::RTestMmTsthU1105()

 	{

 	iTestStepName = _L("MM-TSTH-U-1105");

 	}

 // do the test step

 TVerdict RTestMmTsthU1105::DoTestStepL()

 	{

 	// RTestStepVirtualStub contains extra methods by which we can verify our accessors

 	INFO_PRINTF1(_L("Unit test for TestStep - step"));

 	TVerdict currentVerdict = EPass;

 	iStepStub->DoTestStepL();

 	if(!iStepStub->StepRun())

 		{

 		ERR_PRINTF1(_L("RTestStep::DoTestStepL() failed"));

 		return iTestStepResult = EFail;

 		}

 	return iTestStepResult = currentVerdict; // should be EPass if we've got here

 	}

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

 // RTestMmTsthU1111

 RTestMmTsthU1111* RTestMmTsthU1111::NewL()

 	{

 	RTestMmTsthU1111* self = new(ELeave) RTestMmTsthU1111;

 	return self;

 	}

 // Each test step initialises its own name.

 RTestMmTsthU1111::RTestMmTsthU1111()

 	{

 	iTestStepName = _L("MM-TSTH-U-1111");

 	}

 // do the test step

 TVerdict RTestMmTsthU1111::DoTestStepL()

 	{

 	const TInt KTestBufSize = 64;

 	// RTestStepVirtualStub contains extra methods by which we can verify our accessors

 	INFO_PRINTF1(_L("Unit test for TestStep - load config"));

 	TVerdict currentVerdict = EPass;

 	TBufC<KTestBufSize> KConfigName = _L("TSU_MMTSTH11_config.ini");

 	iStepStub->LoadConfig(KConfigName);

 	// we get no return saying that the file hasn't loaded - 

 	// therefore check something in the file we know is there : [SectionOne] keybool = true

 	// because these functions are protected, we have to wrap them in iStepStub

 	TBool aBoolResult;

 	TBool returnValue = iStepStub->TestGetBoolFromConfig(_L("SectionOne"),_L("Keybool"), aBoolResult);

 	if(!returnValue)

 		{

 		ERR_PRINTF1(_L("RTestStep::LoadConfig() failed"));

 		iStepStub->UnloadConfig();

 		return iTestStepResult = EFail;

 		}

 	iStepStub->UnloadConfig();

 	return iTestStepResult = currentVerdict; // should be EPass if we've got here

 	}

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