1 // Copyright (c) 2002-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // This module contains CParseLine and CSuiteDll classes

    15 // CParseLine contains the functions required to execute

    16 // a line of test script file.

    17 // CSuiteDll objects contains information about test suite

    18 // dlls that have been loaded.

    19 // 

    20 //

    21 

    22 // system includes

    23 #include <f32file.h>

    24 

    25 // test system includes

    26 #include "TestFramework.h"

    27 #include "script.h"

    28 #include "parseline.h"

    29 #include "Filename.h" 

    30 

    31 #include "parseline.inl"

    32 

    33 const TInt KTimeIncrement = 100*1000000; // max wait interval in micro-seconds (100s)

    34 const TUint KMaxThreadAttempts = 128;	// max number of times to attempt to create a thread

    35 

    36 /**

    37  *

    38  * File path literals

    39  *

    40  * @xxxx

    41  *

    42  */

    43 _LIT(KTxtDLLpath, "c:\\;c:\\system\\libs;d:\\;d:\\system\\libs;e:\\;e:\\system\\libs;z:\\;z:\\system\\libs");

    44 

    45 /**

    46  *

    47  * Script parameter defaults

    48  *

    49  * @xxxx

    50  *

    51  */

    52 //const TInt KTestGuardTimerDefault = 1000L;	// EABI warning removal

    53 const TInt KPanicGuardTimerDefault = 1000000L;

    54 const TInt KPanicExitReasonDefault = 0;

    55 

    56 /**

    57  *

    58  * CParseLine first-phase constructor

    59  *

    60  * @xxxx

    61  *

    62  */

    63 CParseLine::CParseLine(const TDesC& aMatchString)

    64 	:iTestVerdict(EPass), iMatchString(aMatchString)

    65 	{

    66 	}

    67 

    68 /**

    69  *

    70  * CParseLine second-phase constructor 

    71  *

    72  * @param	"CScript* aScript"

    73  *			The script to be parsed

    74  *

    75  * @param	"CTestUtils* aTestUtils"

    76  *			The TestUtils object to use

    77  *

    78  * @param	"CLog* aLog"

    79  *			The logger to use

    80  *

    81  * @xxxx

    82  *

    83  */

    84 void CParseLine::ConstructL(CScript* aScript, CTestUtils* aTestUtils, CLog* aLog, TInt64 aGuardTimer)

    85 	{

    86 	// create a new Array to store the test steps in

    87 	iArrayLoadedSuiteDll = new(ELeave) CArrayPtrFlat<CSuiteDll>(1);

    88 

    89 	iScript = aScript;

    90 	iTestUtils = aTestUtils;

    91 	iLog = aLog;

    92 	iGuardTimer = aGuardTimer;

    93 	iSeverity = ESevrAll;

    94 	iBreakOnError = EFalse;

    95 	}

    96 

    97 /**

    98  *

    99  * CParseLine static constructor 

   100  *

   101  * @param	"CScript* aScript"

   102  *			The script to be parsed

   103  *

   104  * @param	"CTestUtils* aTestUtils"

   105  *			The TestUtils object to use

   106  *

   107  * @param	"CLog* aLog"

   108  *			The logger to use

   109  *

   110  * @xxxx

   111  *

   112  */

   113 CParseLine* CParseLine::NewL(CScript* aScript, CTestUtils* aTestUtils, CLog* aLog, TInt64 aGuardTimer, const TDesC& aMatchString)

   114 	{

   115 	CParseLine* self = new(ELeave) CParseLine(aMatchString);

   116 	CleanupStack::PushL(self);

   117 	self->ConstructL(aScript, aTestUtils, aLog, aGuardTimer);

   118 	CleanupStack::Pop();

   119 	return self;

   120 	}

   121 

   122 /**

   123  *

   124  * CParseLine destructor 

   125  *

   126  * @xxxx

   127  *

   128  */

   129 CParseLine::~CParseLine()

   130 	{

   131 

   132 	// unload DLLs and their records

   133 	if (iArrayLoadedSuiteDll)

   134 		{

   135 		// delete all objects in iArrayLoadedSuiteDll

   136 		// the destructors will unload any loaded DLLS

   137 		iArrayLoadedSuiteDll->ResetAndDestroy();

   138 		delete iArrayLoadedSuiteDll;

   139 		}

   140 

   141 	}

   142 

   143 /**

   144  *

   145  * Process a single line from the script file.

   146  *

   147  * @param	"const TDesC8& aNarrowline"

   148  *			The script line

   149  *

   150  * @param	"TInt8 aLineNo"

   151  *			The script line number

   152  *

   153  * @xxxx

   154  *

   155  */

   156 void CParseLine::ProcessLineL(const TDesC8& aNarrowline, TInt aLineNo)

   157 	{

   158 	// make a local unicode buffer

   159 	TPtr16 lineBuf(REINTERPRET_CAST(TUint16*,User::AllocLC(KMaxLenScriptLine*2)), 0, KMaxLenScriptLine);

   160 	lineBuf.Fill('\0', KMaxLenScriptLine);

   161 

   162 	// convert the narrow script file to Unicode

   163 	// TBC find a better way to do this

   164 	CFileName* testnameU = CFileName::NewLC();

   165 	testnameU->Copy(aNarrowline);

   166 

   167 	// find the end of the line

   168 	TInt end = testnameU->Locate('\n');

   169 

   170 	// copy the line into lineBuf

   171 	if ((end != KErrNotFound) && (end < KMaxLenScriptLine))

   172 		lineBuf = testnameU->Left(end - 1);

   173 	else

   174 		lineBuf = testnameU->FileName();

   175 

   176 	// destroy filename

   177 	CleanupStack::PopAndDestroy(testnameU);

   178 

   179 	// the parser relies on spaces between tokens. Commas are

   180 	// allowed but are just replaced with spaces

   181 	TInt findComma = lineBuf.Locate(TChar(','));

   182 	while (findComma != KErrNotFound )

   183 		{

   184 		// found a comma so replace with space

   185 		lineBuf.Replace(findComma, 1, _L(" "));

   186 		findComma = lineBuf.Locate(TChar(','));

   187 		}

   188 

   189 	// for debugging display the line with a line no

   190 #ifdef SCRIPT_DEBUG

   191 	INFO_PRINTF3(_L("Line:%d %S "), aLineNo, &lineBuf);

   192 #endif

   193 

   194 	// if there has been a failure and the user has selected

   195 	// x then the next commands in the script are skipped until

   196 	// a test complete statement is found

   197 	if (iBreakOnError)

   198 		{

   199 		if (lineBuf.FindF(_L("TEST_COMPLETE")) == 0)

   200 			{

   201 			TestComplete(lineBuf);

   202 			// reset flag now test complete found

   203 			iBreakOnError = EFalse;

   204 			}

   205 

   206 		CleanupStack::PopAndDestroy(); // linebuf

   207 		// do not process the rest of the line

   208 		return;

   209 		}

   210 

   211 	// check the line for command keywords

   212 	if ((lineBuf.Find(_L("//")) == 0) || (lineBuf.Find(_L("#")) == 0))

   213 		{

   214 		// ignore comments

   215 		}

   216 	else if (lineBuf.FindF(_L("LOAD_SUITE")) == 0)

   217 		{

   218 		LoadSuiteL(lineBuf);

   219 		}

   220 	else if (lineBuf.FindF(_L("RUN_SCRIPT")) == 0)

   221 		{

   222 		RunScriptL(lineBuf);

   223 		}

   224 	else if (lineBuf.FindF(_L("RUN_TEST_STEP")) == 0)

   225 		{

   226 		RunTestStep(lineBuf);

   227 		}

   228 	else if (lineBuf.FindF(_L("RUN_PANIC_STEP")) == 0)

   229 		{

   230 		RunPanicTestStep(lineBuf);

   231 		}

   232 	else if (lineBuf.FindF(_L("RUN_TERMINATION_STEP")) == 0)

   233 		{

   234 		RunTerminationTestStep(lineBuf);

   235 		}

   236 	else if (lineBuf.FindF(_L("RUN_UTILS")) == 0)

   237 		{

   238 		RunUtil(lineBuf);

   239 		}

   240 	else if (lineBuf.FindF(_L("RUN_PROGRAM")) == 0)

   241 		{

   242 		RunProgram(lineBuf);

   243 		}

   244 	else if (lineBuf.FindF(_L("UNLOAD")) == 0)

   245 		{

   246 		Unload();

   247 		}

   248 	else if (lineBuf.FindF(_L("HEAP_MARK")) == 0)

   249 		{

   250 		HeapMark();

   251 		}

   252 	else if (lineBuf.FindF(_L("HEAP_CHECK")) == 0)

   253 		{

   254 		HeapCheck();

   255 		}

   256 	else if (lineBuf.FindF(_L("REQUEST_MARK")) == 0)

   257 		{

   258 		RequestMark();	

   259 		}

   260 	else if (lineBuf.FindF(_L("REQUEST_CHECK")) == 0)

   261 		{

   262 		RequestCheck();

   263 		}

   264 	else if (lineBuf.FindF(_L("HANDLES_MARK")) == 0)

   265 		{

   266 		HandlesMark();

   267 		}

   268 	else if (lineBuf.FindF(_L("HANDLES_CHECK")) == 0)

   269 		{

   270 		HandlesCheck();

   271 		}

   272 	else if (lineBuf.FindF(_L("PRINT")) == 0)

   273 		{

   274 		ScriptPrint(lineBuf);

   275 		}

   276 	else if (lineBuf.FindF(_L("DELAY")) == 0)

   277 		{

   278 		Delay(lineBuf);

   279 		}

   280 	else if (lineBuf.FindF(_L("SEVERITY")) == 0)

   281 		{

   282 		SetSeverity(lineBuf);

   283 		}

   284 	else if (lineBuf.FindF(_L("PAUSE_AT_END")) == 0)

   285 		{

   286 		// if implemented, add iScript->iPauseAtEnd = ETrue;

   287 		WARN_PRINTF1(_L("Warning : PAUSE_AT_END not implemented"));

   288 		}

   289 	else if (lineBuf.FindF(_L("MULTITHREAD")) == 0)

   290 		{

   291 		WARN_PRINTF1(_L("Warning : MULTITHREAD keyword no longer required"));

   292 		}

   293 	else if (lineBuf.FindF(_L("SINGLETHREAD")) == 0)

   294 		{

   295 		ERR_PRINTF1(_L("Error : Single thread operation no longer supported"));

   296 		}

   297 	else if (lineBuf.FindF(_L("PAUSE")) == 0)

   298 		{

   299 		iScript->Pause();

   300 		}

   301 	else if (lineBuf.FindF(_L("BREAK_ON_ERROR")) == 0)

   302 		{

   303 		// if the current test verdict is not PASS

   304 		// give the user the chance to quit

   305 		if ( iTestVerdict != EPass )

   306 			iBreakOnError = iScript->BreakOnError();

   307 		}

   308 	else if (lineBuf.FindF(_L("TEST_COMPLETE")) == 0)

   309 		{

   310 		// use Tlex to decode the cmd line

   311 		TestComplete(lineBuf);

   312 		}

   313 	else if (lineBuf.FindF(_L("LOG_SETTINGS")) == 0)

   314 		{

   315 		// use Tlex to decode the cmd line

   316 		LogSettings(lineBuf);

   317 		}

   318 	else if (lineBuf.Length() == 0)

   319 		{

   320 		// ignore blank lines

   321 		}

   322 	else

   323 		{

   324 		// failed to decode line

   325 		ERR_PRINTF3(_L("Error in script line:%d - \'%S\'"), aLineNo, &lineBuf);

   326 		}

   327 

   328 	CleanupStack::PopAndDestroy(); // linebuf

   329 	}

   330 

   331 /**

   332  *

   333  * Implements the TEST_COMPLETE script command.

   334  *

   335  * @param	"const TDesC& aText"

   336  *			The script line

   337  *

   338  * @xxxx

   339  *

   340  */

   341 void CParseLine::TestComplete(const TDesC& aText)

   342 	{

   343 	// use Tlex to decode the cmd line

   344 	TLex lex(aText);

   345 

   346 	// start at the begining

   347 	TPtrC token = lex.NextToken();

   348 

   349 	// get suite name, if any

   350 	token.Set(lex.NextToken());

   351 

   352 	if (token.Length() != 0)

   353 		{

   354 		TBuf<KMaxLenTestSuiteName> currentSuiteName;

   355 		currentSuiteName = token;

   356 

   357 		// get step name, if any

   358 		token.Set(lex.NextToken());

   359 	

   360 		if (token.Length() != 0)

   361 			{	

   362 			iCurrentStepName = token;

   363 			iCurrentSuiteName = currentSuiteName;

   364 			}

   365 		else

   366 			{

   367 			// failed to decode line - require 0 or 2 parameters exactly

   368 			// use last suite/step name, return fail

   369 			ERR_PRINTF2(_L("Error in script line: \'%S\'"), &aText);

   370 			iTestVerdict = EFail;

   371 			}

   372 		}

   373 

   374 	if (!iSkip)

   375 		{

   376 		// add the current result to the script

   377 		iScript->AddResult(iTestVerdict);		

   378 		}

   379 		

   380 	// reset for next test

   381 	iTestVerdict = EPass;

   382 	}

   383 

   384 /**

   385  *

   386  * Implements the PRINT script command.

   387  *

   388  * @param	"const TDesC& aText"

   389  *			The script line

   390  *

   391  * @xxxx

   392  *

   393  */

   394 void CParseLine::ScriptPrint(const TDesC& aText)

   395 	{

   396 	// display the text after the PRINT and 1 space = 6

   397 	INFO_PRINTF2(_L("%s "), (aText.Ptr() + 6));

   398 	}

   399 

   400 /**

   401  *

   402  * Implements the DELAY script command.

   403  *

   404  * @param	"const TDesC& aText"

   405  *			The script line

   406  *

   407  * @xxxx

   408  *

   409  */

   410 void CParseLine::Delay(const TDesC& aText)

   411 	{

   412 	// if the test has already failed skip the delay

   413 	if (iTestVerdict != EPass)

   414 		{

   415 		WARN_PRINTF1(_L("Skipped delay as test has already failed"));

   416 		return;

   417 		}

   418 

   419 	// get the required time for the delay

   420 	// first get the value as a string

   421 	TLex timeOut(aText);

   422 	timeOut.NextToken();

   423 	TPtrC token = timeOut.NextToken();

   424 

   425 	// convert the value into a TInt

   426 	TLex lexTime(token);

   427 	TInt64 guardTimerValue;

   428 	if (lexTime.Val(guardTimerValue) != KErrNone  )

   429 		{

   430 		ERR_PRINTF2(_L("Error in guard timer value : could not decode \'%S\' as value"), 

   431 					&token);

   432 		return;

   433 		}

   434 

   435 	INFO_PRINTF2(_L("Delay for %ld mS"), guardTimerValue);

   436 

   437 	// wait for the required delay

   438 	User::After(I64INT(guardTimerValue) * 1000);

   439 	}

   440 	

   441 /**

   442  *

   443  * Implements the SEVERITY script command.

   444  *

   445  * @param	"const TDesC& aText"

   446  *			The script line

   447  *

   448  * @xxxx

   449  *

   450  */

   451 void CParseLine::SetSeverity(const TDesC& aText)

   452 	{

   453 	// get the required time for the delay

   454 	// first get the value as a string

   455 	TLex severityOut(aText);

   456 	severityOut.NextToken();

   457 	TPtrC token = severityOut.NextToken();

   458 

   459 	// convert the value into a TInt

   460 	TLex lexSeverity(token);

   461 	TInt severityValue = ESevrAll;

   462 	if (lexSeverity.Val(severityValue) != KErrNone)

   463 		{

   464 		ERR_PRINTF2(_L("Error in severity level value : could not decode \'%S\' as value"),

   465 					&token);

   466 		return;

   467 		}

   468 

   469 	// check severity value to ensure that only bitmasks in use are set...

   470 	if(!LogSeverity::IsValid(severityValue))

   471 		{

   472 		ERR_PRINTF1(_L("Error in severity value : out of range"));

   473 		return;

   474 		}

   475 	else

   476 		{

   477 		iSeverity = severityValue;

   478 

   479 		TInt noOfDlls = iArrayLoadedSuiteDll->Count();

   480 		for ( TInt i = 0; i < noOfDlls; i++)

   481 			{

   482 			CSuiteDll* ptrSuite = iArrayLoadedSuiteDll->At(i);

   483 			CTestSuite* testSuite = ptrSuite->Suite();

   484 			testSuite->SetSeverity(iSeverity);

   485 			}

   486 		}

   487 

   488 	INFO_PRINTF2(_L("Severity is set to %d"), severityValue);

   489 	}

   490 

   491 /**

   492  *

   493  * Implements the RUN_SCRIPT script command.

   494  *

   495  * @param	"const TDesC& aText"

   496  *			The script line

   497  *

   498  * @xxxx

   499  *

   500  */

   501 void CParseLine::RunScriptL(const TDesC& aText)

   502 	{

   503 	// use Tlex to decode the cmd line

   504 	TLex lex(aText);

   505 

   506 	// start at the begining

   507 	TPtrC token=lex.NextToken();

   508 

   509 	// step over the keyword

   510 	token.Set(lex.NextToken());

   511 

   512 	// format for printing

   513 	INFO_PRINTF2(_L("RUN_SCRIPT %S"), &token);

   514 

   515 	// create a new Script object (but use the current parser

   516 	// as it has the dll loaded record)

   517 	CScript* newScript=CScript::NewLC(this, iTestUtils, iLog, iGuardTimer, iMatchString);

   518 

   519 	// read in the script file

   520 	CFileName* scriptFileName = CFileName::NewLC();

   521 	*scriptFileName = token;

   522 

   523 	if (newScript->OpenScriptFile(scriptFileName))

   524 		{

   525 		// process it

   526 		iTestVerdict = newScript->ExecuteScriptL();

   527 

   528 		// don't bother logging verdicts for scripts - not really useful

   529 		// add results from the new script to the owner script

   530 		iScript->AddResult(newScript);

   531 		}

   532 	else

   533 		{

   534 		// failed to find script so verdict incloncusive

   535 		iTestVerdict = EInconclusive;

   536 		}

   537 

   538 	CleanupStack::PopAndDestroy(scriptFileName);

   539 	CleanupStack::PopAndDestroy(newScript);

   540 	}

   541 

   542 /**

   543  *

   544  * Implements the RUN_TEST_STEP script command.

   545  *

   546  * @param	"const TDesC& aText"

   547  *			The script line

   548  *

   549  * @xxxx

   550  *

   551  */

   552 void CParseLine::RunTestStep(const TDesC& aText)

   553 	{

   554 	// use TLex to decode the cmd line

   555 	TLex lex(aText);

   556 

   557 	// step over keyword

   558 	lex.NextToken();

   559 

   560 	// get guard timer

   561 	TPtrC timeout;

   562 	timeout.Set(lex.NextToken());

   563 

   564 	// get the other parameters

   565 	TPtrC suite, step, config, name, paramSet;

   566 	suite.Set(lex.NextToken());

   567 	step.Set(lex.NextToken());

   568 	config.Set(lex.NextToken());

   569 	name.Set(lex.NextToken());

   570 	if (name.Length()==0)

   571 		{

   572 		// name is optional, if not given use step 

   573 		name.Set(step);

   574 		}

   575 	paramSet.Set(lex.NextToken()); 

   576 	if (paramSet.Length()==0)

   577 		{

   578 		// paramSet is optional, if not given use name 

   579 		paramSet.Set(name);

   580 		}

   581 

   582 	// save the name of the current test suite / step

   583 	iCurrentSuiteName = suite;

   584 	iCurrentStepName = name;

   585 

   586 	TVerdict currentTestVerdict;

   587 

   588 	INFO_PRINTF2(_L("<a name=\"%S\"</a>"),&name);

   589 	

   590 	if (iMatchString.Length()>0 && name.Match(iMatchString)<0)

   591 		{

   592 		// we have a match string but no match - so skip

   593 		INFO_PRINTF2(_L("TEST_STEP:%S skipped"), &name);

   594 		iSkip = ETrue;

   595 		return;

   596 		}

   597 		

   598 	iSkip = EFalse;

   599 

   600 	// convert the guard timer value to a TInt64

   601 	TLex lexTimeOut(timeout);

   602 	TInt64 guardTimerValue;

   603 	if (lexTimeOut.Val(guardTimerValue) != KErrNone)

   604 		{

   605 		ERR_PRINTF2(_L("Error in guard timer value: %S"),

   606 					&timeout);

   607 		currentTestVerdict = EInconclusive;

   608 		}

   609 

   610 	else

   611 		{

   612 		// override guard timer if necessary

   613 		if((guardTimerValue == KNoGuardTimer) && (iGuardTimer != KNoGuardTimer))

   614 			{

   615 			INFO_PRINTF3(_L("Warning : Guard timer value overridden from %ld to %ld"),

   616 							guardTimerValue, iGuardTimer);

   617 			guardTimerValue = iGuardTimer;

   618 			}

   619 

   620 		// log the start of a test step

   621 		INFO_PRINTF7(_L("RUN_TEST_STEP:%S (step:%S suite:%S timeout:%ldmS config:%S(%S))"),

   622 					&name, &step, &suite, guardTimerValue, &config, &paramSet);

   623 

   624 		// NOTE. Now running multithreaded all the time.

   625 		currentTestVerdict = DoTestNewThread(suite, step, guardTimerValue, config, paramSet);

   626 		}

   627 

   628 	TPtrC verdictText = CLog::TestResultText(currentTestVerdict);

   629 	

   630 	INFO_PRINTF3(_L("TEST_STEP:%S returned:%S "), 

   631 				&name, &verdictText);

   632 

   633 	// this result is only significant if everything else has passed

   634 	if (iTestVerdict == EPass)

   635 		iTestVerdict = currentTestVerdict;

   636 

   637 	}

   638 

   639 /**

   640  *

   641  * Implements the RUN_PANIC_STEP script command.

   642  *

   643  * @param	"const TDesC& aText"

   644  *			The script line

   645  *

   646  * @xxxx

   647  *

   648  */

   649 void CParseLine::RunPanicTestStep(const TDesC& aText)

   650 	{

   651 	// NOTE. RUN_PANIC_STEP now incorporates the panic reason and category

   652 

   653 	// use Tlex to decode the cmd line

   654 	TLex lex(aText);

   655 

   656 	// start at the begining

   657 	TPtrC timeout=lex.NextToken();

   658 

   659 	// step over the keyword

   660 	timeout.Set(lex.NextToken());

   661 

   662 	// get the other parameters

   663 	TPtrC suite, step;

   664 	TPtrC category, reason;

   665 	TPtrC config, name, paramSet;

   666 

   667 	suite.Set(lex.NextToken());

   668 	step.Set(lex.NextToken());

   669 	category.Set(lex.NextToken());

   670 	reason.Set(lex.NextToken());

   671 	config.Set(lex.NextToken());

   672 	name.Set(lex.NextToken());

   673 	if (name.Length()==0)

   674 		{

   675 		// name is optional, if not given use step 

   676 		name.Set(step);

   677 		}

   678 	paramSet.Set(lex.NextToken()); 

   679 	if (paramSet.Length()==0)

   680 		{

   681 		// paramSet is optional, if not given use name 

   682 		paramSet.Set(name);

   683 		}

   684 

   685 	if (iMatchString.Length()>0 && name.Match(iMatchString)<0)

   686 		{

   687 		// we have a match string but no match - so skip

   688 		INFO_PRINTF2(_L("TEST_STEP:%S skipped"), &name);

   689 		iSkip = ETrue;

   690 		return;

   691 		}

   692 		

   693 	iSkip = EFalse;

   694 

   695 	// save the name of the current test suite / step

   696 	iCurrentSuiteName = suite;

   697 	iCurrentStepName = name;

   698 

   699 	// convert the guard timer value to a TInt

   700 	TLex lexTimeOut(timeout);

   701 	TInt64 guardTimerValue;

   702 	if (lexTimeOut.Val(guardTimerValue) != KErrNone)

   703 		{

   704 		ERR_PRINTF3(_L("Error in guard timer value:%S using default %dmS"), 

   705 					&timeout, KPanicGuardTimerDefault);

   706 		guardTimerValue = KPanicGuardTimerDefault;

   707 		}

   708 

   709 	// convert the exitReason value to a TInt

   710 	TLex lexReason(reason);

   711 	TInt exitReason;

   712 	if (lexReason.Val(exitReason) != KErrNone)

   713 		{

   714 		ERR_PRINTF3(_L("Error in exitReason value:%S using default %d"), 

   715 					&reason, KPanicExitReasonDefault);

   716 		exitReason = KPanicExitReasonDefault;

   717 		}

   718 

   719 	// override guard timer if necessary

   720 	if((guardTimerValue == KNoGuardTimer) && (iGuardTimer != KNoGuardTimer))

   721 		{

   722 		INFO_PRINTF3(_L("Warning : Guard timer value overridden from %ld to %ld"),

   723 						guardTimerValue, iGuardTimer);

   724 		guardTimerValue = iGuardTimer;

   725 		}

   726 

   727 	// log the start of a test step

   728 	INFO_PRINTF9(_L("RUN_PANIC_STEP:%S (step:%S suite:%S timeout:%ldmS category:%S reason:%d config:%S(%S))"),

   729 				&name, &step, &suite, guardTimerValue, &category, exitReason, &config, &paramSet);

   730 

   731 	// run the test step

   732 	TVerdict currentTestVerdict;

   733 

   734 	// now running multithreaded all the time

   735 	currentTestVerdict = DoPanicTest(suite, step, guardTimerValue,

   736 									 category, exitReason, config, paramSet);

   737 

   738 	TPtrC verdictText = CLog::TestResultText(currentTestVerdict);

   739 	INFO_PRINTF3(_L("TEST_STEP:%S returned:%S "), 

   740 				&name, &verdictText);

   741 

   742 	// this result is only significant if every thing else has passed

   743 	if (iTestVerdict == EPass)

   744 		iTestVerdict = currentTestVerdict;

   745 

   746 	}

   747 	

   748 /**

   749  *

   750  * Implements the RUN_TERMINATION_STEP script command.

   751  *

   752  * @param	"const TDesC& aText"

   753  *			The script line

   754  *

   755  * @xxxx

   756  *

   757  */

   758 void CParseLine::RunTerminationTestStep(const TDesC& aText)

   759 	{

   760 	// use Tlex to decode the cmd line

   761 	TLex lex(aText);

   762 

   763 	// start at the begining

   764 	TPtrC timeout=lex.NextToken();

   765 

   766 	// step over the keyword

   767 	timeout.Set(lex.NextToken());

   768 

   769 	// get the other parameters

   770 	TPtrC suite, step;

   771 	TPtrC reason;

   772 	TPtrC config;

   773 

   774 	suite.Set(lex.NextToken());

   775 	step.Set(lex.NextToken());

   776 	reason.Set(lex.NextToken());

   777 	config.Set(lex.NextToken());

   778 

   779 	// save the name of the current test suite / step

   780 	iCurrentSuiteName = suite;

   781 	iCurrentStepName = step;

   782 

   783 	// convert the guard timer value to a TInt

   784 	TLex lexTimeOut(timeout);

   785 	TInt64 guardTimerValue;

   786 	if (lexTimeOut.Val(guardTimerValue) != KErrNone)

   787 		{

   788 		ERR_PRINTF3(_L("Error in guard timer value:%S using default %dmS"), 

   789 					&timeout, KPanicGuardTimerDefault);

   790 		guardTimerValue = KPanicGuardTimerDefault;

   791 		}

   792 

   793 	// convert the exitReason value to a TInt

   794 	TLex lexReason(reason);

   795 	TInt exitReason;

   796 	if (lexReason.Val(exitReason) != KErrNone)

   797 		{

   798 		ERR_PRINTF3(_L("Error in exitReason value:%S using default %d"), 

   799 					&reason, KPanicExitReasonDefault);

   800 		exitReason = KPanicExitReasonDefault;

   801 		}

   802 

   803 	// override guard timer if necessary

   804 	if((guardTimerValue == KNoGuardTimer) && (iGuardTimer != KNoGuardTimer))

   805 	{

   806 		INFO_PRINTF3(_L("Warning : Guard timer value overridden from %ld to %ld"),

   807 						guardTimerValue, iGuardTimer);

   808 		guardTimerValue = iGuardTimer;

   809 	}

   810 

   811 	// log the start of a test step

   812 	INFO_PRINTF6(_L("RUN_TERMINATION_STEP:%S suite:%S timeout:%ldmS reason:%d config:%S"),

   813 				&step, &suite, guardTimerValue, exitReason, &config);

   814 

   815 	// run the test step

   816 	TVerdict currentTestVerdict;

   817 

   818 	// now running multithreaded all the time

   819 	currentTestVerdict = DoTerminationTest(suite, step, guardTimerValue,

   820 									 exitReason, config);

   821 

   822 	TPtrC verdictText = CLog::TestResultText(currentTestVerdict);

   823 	INFO_PRINTF3(_L("TEST_STEP:%S returned:%S "), 

   824 				&step, &verdictText);

   825 

   826 	// this result is only significant if every thing else has passed

   827 	if (iTestVerdict == EPass)

   828 		iTestVerdict = currentTestVerdict;

   829 

   830 	}

   831 

   832 /**

   833  *

   834  * Implements the RUN_UTILS script command.

   835  *

   836  * @param	"const TDesC& aText"

   837  *			The script line

   838  *

   839  * @xxxx

   840  *

   841  */

   842 void CParseLine::RunUtil(const TDesC& aText)

   843 	{

   844 	// Call the utils

   845 	iTestUtils->RunUtils(aText);

   846 	}

   847 

   848 /**

   849  *

   850  * Implements the REBOOT script command.

   851  *

   852  * @param	"const TDesC& aText"

   853  *			The script line

   854  *

   855  * @xxxx

   856  *

   857  */

   858 void CParseLine::Reboot()

   859 	{

   860 	WARN_PRINTF1(_L("Warning : REBOOT command not implemented"));

   861 	}

   862 

   863 /**

   864  *

   865  * Static function to call DoTestStep which is run

   866  * in a separate thread

   867  *

   868  * @param	"TAny* aPtr"

   869  *			The test step data

   870  *

   871  * @return "TInt"

   872  *			EPOC error code

   873  *

   874  * @xxxx

   875  *

   876  */

   877 TInt CParseLine::ThreadFunctionL(TAny* aPtr)

   878 	{

   879 	TInt result = KErrNone;

   880 

   881 	// get clean-up stack

   882   	CTrapCleanup* trapCleanup = CTrapCleanup::New();

   883 

   884 	TRAPD(err, result = ThreadTrapFunctionL(aPtr));

   885 

   886 	delete trapCleanup;

   887 	return((err != KErrNone) ? err : result);

   888 	}

   889 

   890 /**

   891  *

   892  * Main function to call DoTestStep, called from within

   893  * a trap

   894  *

   895  * @param	"TAny* aPtr"

   896  *			The test step data

   897  *

   898  * @return "TInt"

   899  *			EPOC error code

   900  *

   901  * @xxxx

   902  *

   903  */

   904 TInt CParseLine::ThreadTrapFunctionL(TAny* aPtr)

   905 	{

   906 	// get the data for the test

   907 	CStepData* data = REINTERPRET_CAST(CStepData*, aPtr);

   908 	CSuiteDll* suiteDll = data->SuiteDll();

   909 	CTestSuite* testSuite = suiteDll->Suite();

   910 

   911 	// setup local logger

   912 	CLog* logClient	= CLog::NewLC();

   913 	logClient->OpenLogFileL();

   914 	testSuite->SetLogSystem(logClient);

   915 

   916 	// do the test step 

   917 	TVerdict result =  testSuite->DoTestStep(data->Step(), data->Config(), data->ParamSet());

   918 

   919 	// NB it is the CALLING program's responsibility to save/restore the logger.

   920 	// If the thread terminates prematurely, the logger is in an undefined state.

   921 

   922 	CleanupStack::PopAndDestroy(logClient);

   923 	testSuite->SetLogSystem(NULL);

   924 

   925 	// return the test result

   926 	return result;

   927 	}

   928 

   929 /**

   930  *

   931  * Do a test step in a new thread.

   932  *

   933  * @param	"const TDesC& aSuite"

   934  *			The test suite

   935  *

   936  * @param	"const TDesC& aStep"

   937  *			The test step

   938  *

   939  * @param	"TInt aGuardTimerValue"

   940  *			The guard timer value

   941  *

   942  * @param	"const TDesC& aConfig"

   943  *			The config data

   944  *

   945  * @return  "TVerdict"

   946  *			The test result

   947  *

   948  * @xxxx

   949  *

   950  */

   951 TVerdict CParseLine::DoTestNewThread(const TDesC& aSuite, const TDesC& aStep, 

   952 							TInt64 aGuardTimerValue, const TDesC& aConfig, const TDesC& aParamSet)

   953 	{

   954 	//	get the number of suites loaded

   955 	TInt noOfDlls = iArrayLoadedSuiteDll->Count();

   956 

   957 	// search the list of loaded test suite DLLs for the required one

   958 	for (TInt i = 0; i < noOfDlls; i++)

   959 		{

   960 		CSuiteDll* ptrSuite = iArrayLoadedSuiteDll->At(i);

   961 		TPtrC name = ptrSuite->Name();

   962 

   963 		if (name.FindF(aSuite)!= KErrNotFound)

   964 			{

   965 			// reset step status

   966 			CTestSuite* testSuite = ptrSuite->Suite();

   967 			testSuite->SetStepStatus(EStepStatusNone);

   968 

   969 			// store old log status, for restore at thread exit

   970 			// NB we must do this here, as if thread times out, the log

   971 			// is in an undefined state

   972 			CLog* oldLogger = testSuite->LogSystem();

   973 

   974 			CStepData* data = NULL;

   975 			TRAPD(err, data = CStepData::NewL(aStep, aConfig, aParamSet, ptrSuite));

   976 			if (err != KErrNone)

   977 				{

   978 				ERR_PRINTF2(_L("CStepData::NewL() left with error %d : unable to create test data!"), err);

   979 				return EFail;

   980 				}

   981 			

   982 			// get step's own stack and heap sizes

   983 			TInt theHeapSize = KMaxTestThreadHeapSize;

   984 			TInt theStackSize = KTestStackSize;

   985 			GetHeapAndStackSize(data, &theHeapSize, &theStackSize);

   986 

   987 			TInt res = KErrAlreadyExists;

   988 			RThread newThread;

   989 

   990 			TPtrC threadBaseName(_L("DoTestThread"));

   991 			TBuf<32> threadName;

   992 			

   993 			// create a unique named test thread

   994 			// this will leave if creation is not successful

   995 			TRAP (res, CreateUniqueTestThreadL( threadBaseName, 

   996 												threadName, 

   997 												newThread, 

   998 												ThreadFunctionL,

   999 												theStackSize,

  1000 												KMinHeapSize,

  1001 												theHeapSize,

  1002 												data ) );

  1003 

  1004 			

  1005 			if (res != KErrNone)

  1006 				{

  1007 				ERR_PRINTF2(_L("CreateUniqueTestThreadL() left with error %d : unable to create test thread "), res);

  1008 				delete data;

  1009 				data = NULL;

  1010 				return EFail;

  1011 				}

  1012 

  1013 			// start clock

  1014 			TTime testStart, testStop;

  1015 			testStart.HomeTime();

  1016 			

  1017 			// start the thread and request the status

  1018 			TRequestStatus threadStatus;

  1019 			newThread.Logon(threadStatus);

  1020 

  1021 			// if there is no guard timer value, don't time at all

  1022 			if (aGuardTimerValue == KNoGuardTimer)

  1023 				{

  1024 				// no guard timer

  1025 				newThread.Resume();

  1026 				User::WaitForRequest(threadStatus);

  1027 				}

  1028 			else

  1029 				{

  1030 				// wait for either test thread or timer to end

  1031 				RTimer guardTimer;

  1032 				guardTimer.CreateLocal();			// create for this thread

  1033 				TRequestStatus timerStatus;

  1034 				newThread.Resume();

  1035 

  1036 				// NB now using At() to allow 64-bit timer values

  1037 				TInt64 guardTimerUsec = aGuardTimerValue * 1000;

  1038 				TInt64 totalTime = 0;

  1039 

  1040 				for (;;)

  1041 					{

  1042 					if (totalTime>=guardTimerUsec) // timeout has occured

  1043 						break;

  1044 					TInt timeout;

  1045 

  1046 					if (totalTime+KTimeIncrement >= guardTimerUsec)

  1047 						{

  1048 						TInt64 temp = guardTimerUsec-totalTime;

  1049 						timeout = I64INT(temp);

  1050 						}

  1051 					else

  1052 						timeout = KTimeIncrement;

  1053 					totalTime += timeout;

  1054 					guardTimer.After(timerStatus, timeout);

  1055 					User::WaitForRequest(threadStatus, timerStatus);

  1056 					if (threadStatus!=KRequestPending) // normal exit

  1057 						break;

  1058 					}

  1059 

  1060 				guardTimer.Cancel();

  1061 				guardTimer.Close();

  1062 				}

  1063 

  1064 			// reset any file server error simulations

  1065 			RFs fs;

  1066 			TInt fsError = fs.Connect();

  1067 			if (fsError == KErrNone)

  1068 				{

  1069 				fs.SetErrorCondition(KErrNone);

  1070 				}

  1071 			fs.Close();

  1072 

  1073 			// restore logger

  1074 			testSuite->SetLogSystem(oldLogger);

  1075 

  1076 			// get the test result

  1077 			TVerdict result = STATIC_CAST(TVerdict, threadStatus.Int());

  1078 

  1079 			// check terminated ok

  1080 			switch(newThread.ExitType())

  1081 				{

  1082 				case EExitTerminate:

  1083 				case EExitKill:

  1084 					break;

  1085 				case EExitPanic:

  1086 					{

  1087 					TExitCategoryName exitCategory = newThread.ExitCategory();

  1088 					TInt exitReason = newThread.ExitReason();

  1089  					ERR_PRINTF3(_L("Thread had a panic %S:%d"), &exitCategory, exitReason);

  1090 

  1091 					result = EFail;

  1092 					}

  1093 					break;

  1094 				case EExitPending:

  1095 					// if the thread is still pending then the guard timer must have expired

  1096 					ERR_PRINTF1(_L("Thread timed out"));

  1097 					// kill the test step thread

  1098 					newThread.Kill(1);

  1099 					// give the OS time to cleanup devices, etc.

  1100 					// NB if the thread dies, the postamble will NOT run

  1101 					User::After(2000000);

  1102 					result = EFail;

  1103 					break;

  1104 				default:

  1105 					break;

  1106 				}

  1107 

  1108 			// done with the test thread

  1109 			newThread.Close();

  1110 

  1111 			// stop clock

  1112 			testStop.HomeTime();

  1113 

  1114 			TUint testDuration = I64INT(testStop.MicroSecondsFrom(testStart).Int64());

  1115 			testDuration /= 1000; // to microseconds

  1116 			TUint testDurationMsec = testDuration % 1000;

  1117 			TUint testDurationSec = testDuration / 1000;

  1118 			INFO_PRINTF3(_L("Test took %d.%03d sec"), testDurationSec, testDurationMsec);

  1119 

  1120 			// return the test verdict

  1121 			delete data;

  1122 			data = NULL;

  1123 			return result;

  1124 			}

  1125 		}

  1126 

  1127 	// the required suite has not been found

  1128 	ERR_PRINTF3(_L("Error in test step:%S - cannot find suite:%S" ),

  1129 					&aStep, &aSuite);

  1130 

  1131 	return ETestSuiteError;

  1132 	}

  1133 

  1134 /**

  1135  *