diff -r 000000000000 -r b8ed18f6c07b mmtestenv/mmtestfwunittest/src/tsu_mmtsth01/TSU_MmTsth01.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/mmtestenv/mmtestfwunittest/src/tsu_mmtsth01/TSU_MmTsth01.cpp Thu Oct 07 22:34:12 2010 +0100 @@ -0,0 +1,309 @@ +// 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 + +// Test system includes +#include +#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; + } + +