// 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 01 : Parseline.cpp
// 
//

// EPOC includes
#include <e32base.h>

// Test system includes
#include <testframework.h>
#include "script.h"
#include "parseline.h"
#include "Filename.h" 

// Specific includes for this test suite
#include "TSU_MmTsthSuite01.h"

// Specific includes for these test steps
#include "TSU_MmTsth01.h"

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

// Unit Test Suite 01 : Parseline.cpp
// Depends on : none

// Tests :-
// 1 Initialise a CParseLine
// 2 Process line : load & run a sample step
// 3 Run a sample panic step
// 4 Run a utility
// 11 CSuiteDLL initialise and verify

// (NB these tests are to test the parser ONLY; the underlying functionality of the
// commands parsed is tested in CTestStep, CTestSuite, CTestUtils etc. suites)

// ---------------------
// RTestMmTsthU0101

RTestMmTsthU0101* RTestMmTsthU0101::NewL()
	{
	RTestMmTsthU0101* self = new(ELeave) RTestMmTsthU0101;
	return self;
	}

// Each test step initialises its own name.
RTestMmTsthU0101::RTestMmTsthU0101()
	{
	iTestStepName = _L("MM-TSTH-U-0101");
	}

// preamble
TVerdict RTestMmTsthU0101::OpenL()
	{
	// don't call the default preamble
	return iTestStepResult = EPass;
	}

// postamble
void RTestMmTsthU0101::Close()
	{
	// don't call the default postamble
	}

// Do the test step.
TVerdict RTestMmTsthU0101::DoTestStepL()
	{
	INFO_PRINTF1(_L("Unit test for Parseline"));

	TVerdict currentVerdict = EPass;

	// initialise a CParseLine
	CLog* theLogClient  = iSuite->LogSystem();
	CTestUtils* theTestUtils  = CTestUtils::NewL(theLogClient);
	TInt64 theGuardTimer (-1);

	CleanupStack::PushL(theTestUtils);
	CScript* theParseScript = CScript::NewLC(theTestUtils, theLogClient, theGuardTimer, KNullDesC);
	CParseLine* theParser = CParseLine::NewL(theParseScript, theTestUtils, theLogClient, theGuardTimer, KNullDesC);
	CleanupStack::PushL(theParser);

	// if we got here, we're constructed successfully
	INFO_PRINTF1(_L("CParseLine constructed successfully"));

	CleanupStack::PopAndDestroy(3); // theParser, theParseScript, theTestUtils

	return iTestStepResult = currentVerdict;
	}


// ---------------------
// RTestMmTsthU0102

RTestMmTsthU0102* RTestMmTsthU0102::NewL()
	{
	RTestMmTsthU0102* self = new(ELeave) RTestMmTsthU0102;
	return self;
	}

// Each test step initialises its own name.
RTestMmTsthU0102::RTestMmTsthU0102()
	{
	iTestStepName = _L("MM-TSTH-U-0102");
	}

// Do the test step.
TVerdict RTestMmTsthU0102::DoTestStepL()
	{
	INFO_PRINTF1(_L("Unit test for ProcessLineL 1"));

	TVerdict currentVerdict = EPass;
	_LIT8(KTestStepScriptLine1, "LOAD_SUITE TSU_MMTSTH01");
	_LIT8(KTestStepScriptLine2, "RUN_TEST_STEP 1000 TSU_MMTSTH01 RTestStepDummy");

	TRAPD(err1, iParseLine->ProcessLineL(KTestStepScriptLine1, 1));
	if(err1 != KErrNone)
	{
		ERR_PRINTF2(_L("ProcessLineL for LOAD_SUITE left, error code %d"), err1);
		return iTestStepResult = EFail;
	}
	TRAPD(err2, iParseLine->ProcessLineL(KTestStepScriptLine2, 2));
	if(err2 != KErrNone)
	{
		ERR_PRINTF2(_L("ProcessLineL for RUN_TEST_STEP left, error code %d"), err2);
		return iTestStepResult = EFail;
	}

	return iTestStepResult = currentVerdict;
	}

// ---------------------
// RTestMmTsthU0103

RTestMmTsthU0103* RTestMmTsthU0103::NewL()
	{
	RTestMmTsthU0103* self = new(ELeave) RTestMmTsthU0103;
	return self;
	}

// Each test step initialises its own name.
RTestMmTsthU0103::RTestMmTsthU0103()
	{
	iTestStepName = _L("MM-TSTH-U-0103");
	}

// Do the test step.
TVerdict RTestMmTsthU0103::DoTestStepL()
	{
	INFO_PRINTF1(_L("Unit test for ProcessLineL 2"));

	TVerdict currentVerdict = EPass;
	_LIT8(KTestStepScriptLine1, "LOAD_SUITE TSU_MMTSTH01");
	_LIT8(KTestStepScriptLine2, "RUN_PANIC_STEP 1000 TSU_MMTSTH01 RPanicTestStepDummy, PanicDummy, 0");

	TRAPD(err1, iParseLine->ProcessLineL(KTestStepScriptLine1, 1));
	if(err1 != KErrNone)
	{
		ERR_PRINTF2(_L("ProcessLineL for LOAD_SUITE left, error code %d"), err1);
		return iTestStepResult = EInconclusive;
	}
	TRAPD(err2, iParseLine->ProcessLineL(KTestStepScriptLine2, 2));
	if(err2 != KErrNone)
	{
		ERR_PRINTF2(_L("ProcessLineL for RUN_PANIC_STEP left, error code %d"), err2);
		return iTestStepResult = EFail;
	}

	return iTestStepResult = currentVerdict;
	}


// ---------------------
// RTestMmTsthU0104

RTestMmTsthU0104* RTestMmTsthU0104::NewL()
	{
	RTestMmTsthU0104* self = new(ELeave) RTestMmTsthU0104;
	return self;
	}

// Each test step initialises its own name.
RTestMmTsthU0104::RTestMmTsthU0104()
	{
	iTestStepName = _L("MM-TSTH-U-0104");
	}

// Do the test step.
TVerdict RTestMmTsthU0104::DoTestStepL()
	{

	INFO_PRINTF1(_L("This test step is not available on EKA2 - Passing test!"));
	return EPass;

	}

// ---------------------
// RTestMmTsthU0111

RTestMmTsthU0111* RTestMmTsthU0111::NewL()
	{
	RTestMmTsthU0111* self = new(ELeave) RTestMmTsthU0111;
	return self;
	}

// Each test step initialises its own name.
RTestMmTsthU0111::RTestMmTsthU0111()
	{
	iTestStepName = _L("MM-TSTH-U-0111");
	}

// Do the test step.
TVerdict RTestMmTsthU0111::DoTestStepL()
	{
	INFO_PRINTF1(_L("Unit test for CSuiteDLL"));

	TVerdict currentVerdict = EPass;

	// create a new CSuiteDll object to store info on loaded DLL
	_LIT(KTestSuiteName, "TSU_MMTSTH01");
	CSuiteDll* newRef = NULL;
	TRAPD(err, newRef = CSuiteDll::NewL(KTestSuiteName, iLogClient));
	if(err != KErrNone)
	{
		ERR_PRINTF2(_L("CSuiteDll::NewL left, error code %d"), err);
		return iTestStepResult = EFail;
	}

	// make sure it's not NULL, get its name out and see if it matches
	CTestSuite* theTestSuite = newRef->Suite();
	if(theTestSuite == NULL)
	{
		ERR_PRINTF1(_L("CSuiteDll::Suite() is NULL"));
		return iTestStepResult = EFail;
	}

	TPtrC theName = newRef->Name();
	if (theName != KTestSuiteName)
	{
		ERR_PRINTF2(_L("CSuiteDll::Name() is %S"), &theName);
		return iTestStepResult = EFail;
	}

	return iTestStepResult = currentVerdict;
	}

// ---------------------
// Dummy test step for Parseline testing

RTestStepDummy* RTestStepDummy::NewL()
	{
	RTestStepDummy* self = new(ELeave) RTestStepDummy;
	return self;
	}

// Each test step initialises its own name.
RTestStepDummy::RTestStepDummy()
	{
	iTestStepName = _L("RTestStepDummy");
	}

// Do the test step.
TVerdict RTestStepDummy::DoTestStepL()
	{
	INFO_PRINTF1(_L("Dummy step completed"));

	TVerdict currentVerdict = EPass;

	return iTestStepResult = currentVerdict;
	}


// ---------------------
// Dummy panic test steps for Parseline testing

RPanicTestStepDummy* RPanicTestStepDummy::NewL()
	{
	RPanicTestStepDummy* self = new(ELeave) RPanicTestStepDummy;
	return self;
	}

// Each test step initialises its own name.
RPanicTestStepDummy::RPanicTestStepDummy()
	{
	iTestStepName = _L("RPanicTestStepDummy");
	}

// Do the test step.
TVerdict RPanicTestStepDummy::DoTestStepL()
	{
	INFO_PRINTF1(_L("Dummy panic step running"));
	User::Panic(_L("PanicDummy"), 0);

	// NB this code cannot be reached
	TVerdict currentVerdict = EPass;
	return iTestStepResult = currentVerdict;
	}