1 /*

     2 * Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

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

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  

    15 * Contains the CTestStep base class implementation

    16 *

    17 */

    18 

    19 

    20 

    21 /**

    22  @file TestStepBase.cpp

    23 */

    24 

    25 #include "testexecutestepbase.h"

    26 

    27 /**

    28  * Default virtual implementation for pre-processing  within test steps

    29  * Virtual - May be overidden by subclass

    30  * @return One of TVerdict enum values defined

    31  */

    32 EXPORT_C enum TVerdict CTestStep::doTestStepPreambleL(void)

    33 	{

    34 	SetTestStepResult(EPass);

    35 	SetTestStepError(0);

    36 	return TestStepResult();

    37 	}

    38 

    39 /**

    40  * Default virtual implementation for post-processing within test steps

    41  * Virtual - May be overidden by subclass

    42  * @return One of TVerdict enum values defined

    43  */

    44 EXPORT_C enum TVerdict CTestStep::doTestStepPostambleL(void)

    45 	{

    46 	return TestStepResult();

    47 	}

    48 

    49 /**

    50  * Sets the current heap's to fail upon the subsequent "aFailureIndex" attempt

    51  * Virtual - may be overridden by derived test step

    52  * @param aFailureIndex - Index within heap allocation table that needs to be failed

    53  */

    54 EXPORT_C void CTestStep::SetHeapFailNext(TInt aFailureIndex)

    55 	{

    56 	if (aFailureIndex >= 0)

    57 		{

    58 		__UHEAP_FAILNEXT(aFailureIndex);

    59 		}

    60 	}

    61 

    62 /**

    63  * Resets the the current heap's simulated "fail next" mode (if active)

    64  * Virtual - may be overridden by derived test step

    65  */

    66 EXPORT_C void CTestStep::ResetHeapFailNext()

    67 	{

    68 	__UHEAP_RESET;

    69 	}

    70 

    71 /**

    72  * Tests whether the current heap is in "fail next" mode. Used to check whether 

    73  * the code-under-test has "consumed" the simulated failure when OOM looping.

    74  * Virtual - may be overridden by derived test step

    75  * @return Boolean true if code has comsumed a simulated failure, false otherwise

    76  */

    77 EXPORT_C TBool CTestStep::CheckForHeapFailNext()

    78 	{

    79 	TBool finishedCorrectly(EFalse);

    80 	TInt* myInt = new TInt;

    81 	if (myInt == NULL)

    82 		finishedCorrectly = ETrue; // NULL means no memory

    83 	delete myInt;

    84 	return finishedCorrectly;

    85 	}

    86 

    87 /**

    88  * Destructor

    89  * Only heap resource is the Ini file data

    90  */

    91 EXPORT_C CTestStep::~CTestStep()

    92 	{

    93 	CloseLogger();

    94 	delete iConfigData;

    95 	delete iIniFileName;

    96 	delete iLogger ; 

    97 	}

    98 

    99 /**

   100  * Constructor

   101  */

   102 EXPORT_C CTestStep::CTestStep()

   103 	{

   104 	// current logger can't using to log infomation.

   105 	// because SetLoggerL must called before write logs.

   106 	// the initial operation codes at SetLoggerL()

   107 	iLogger = new CTestExecuteLogger();

   108 	}

   109 

   110 /**

   111  * Called by server base code that loads the test step

   112  * Can be called multiple times for any loaded test step instance.

   113  * Sets up the instance variables

   114  * @param aStepArgs - The arguments to the RUN_TEST_STEP command

   115  * @param aServerName - Name of the server that requested initialisation of its test step object

   116  * @param aSharedDataMode - Boolean true or false indicating the mode in which the test step is running

   117  * @Leave system wide errors

   118  */

   119 void CTestStep::InitialiseL(const TDesC& aStepArgs, const TDesC& aServerName, TBool& aSharedDataMode)

   120 	{

   121 	// Assume pass

   122 	iTestStepResult = EPass;

   123 	iSharedDataMode = aSharedDataMode;

   124 	iSection.SetLength(0);

   125 	// In the case of re-initialise we need to free the existing resource

   126 	if(iIniFileName)

   127 		{

   128 		delete iIniFileName;

   129 		iIniFileName = NULL;

   130 		}

   131 	if(iConfigData)

   132 		{

   133 		delete iConfigData;

   134 		iConfigData = NULL;

   135 		}

   136 

   137 	TLex lex(aStepArgs);

   138 

   139 	// Extract the first token for OOM request status

   140 	TPtrC oomRequestString(lex.NextToken());

   141 	_LIT(KTEFOomOff,"OOM=0");

   142 	if (oomRequestString.CompareF(KTEFOomOff) == 0)

   143 		{

   144 		// Not required to run OOM tests if OOM=0

   145 		iOOMRequestStatus = EFalse;

   146 		}

   147 	else

   148 		{

   149 		// Required to run OOM tests if OOM=1

   150 		iOOMRequestStatus = ETrue;

   151 		}

   152 

   153 	// Extract the second token for !Setup value

   154 	TLex setupParamValue(lex.NextToken().Mid(7));

   155 	TInt err = setupParamValue.Val(iSetupParamValue);

   156 	if (err != KErrNone)

   157 		{

   158 		iSetupParamValue = TTestSetupState(ESetupNone);

   159 		}

   160 	

   161 	// Extract the third token from aStepArgs for loop index

   162 	TLex loopIndex(lex.NextToken());

   163 	loopIndex.Val(iLoopIndex);

   164 

   165 	iTestCaseID.Copy(lex.NextToken());

   166 

   167 	TPtrC path(lex.NextToken());

   168 	iScriptDriveName.Copy(path);

   169 

   170 	path.Set(lex.NextToken());

   171 	iSystemDrive.Copy(path);

   172 

   173 	path.Set(lex.NextToken());

   174 	iSystemDriveForTest.Copy(path);

   175 	

   176 	// Set the logger instance

   177 	//before SetLogger(). iSystemDrive is needed, because SetLogger() will using iSystemDrive

   178 	//before LoadConfigFileL(). SetLogger() is needed, because LoadConfigFileL() may needs write logs.

   179 	SetLoggerL();

   180 	// Get the ini file name if any

   181 	TPtrC configFile(lex.NextToken());

   182 	if(configFile.Length())

   183 		{

   184 		LoadConfigFileL(configFile);

   185 		TPtrC iniSection(lex.NextToken());

   186 		// In the case of re-initialise zero the old one

   187 		ConfigSection().SetLength(0);

   188 		// Get the ini section name if any

   189 		if(iniSection.Length() && iniSection.Length() <= ConfigSection().MaxLength())

   190 			ConfigSection().Copy(iniSection);

   191 		}

   192 	// Set the inifile name.

   193 	iIniFileName = configFile.AllocL();

   194 	// Set the server name

   195 	iServerName = aServerName;

   196 	}

   197 

   198 /**

   199  * Creates a Cinidata instance for the ini file path specified for a particular test step

   200  * @param aFilePath - Full pathname of the ini file

   201  * @Leave system wide errors

   202  */

   203 void CTestStep::LoadConfigFileL(const TDesC& aFilePath)

   204 	{

   205 	if(!aFilePath.Length())

   206 		User::Leave(KErrNotFound);

   207 

   208 		// Pass the system drive letter finalised to the Cinidata construction

   209 		// So, that the ini files can be expanded for the ${SYSDRIVE} variables

   210 		TRAPD(err,iConfigData = CIniData::NewL(aFilePath, GetSystemDrive()));		

   211 		if(err != KErrNone)

   212 			{

   213 			//defect 121613: TEF will report ini file too large

   214 			ERR_PRINTF3(_L("Leave when loading %S . Error Code = %d"),&aFilePath,err);

   215 			// This is a hit message to user to split ini file to smaller one

   216 			if (err == KErrNoMemory ) // -4

   217 				{

   218 				_LIT(KTEFLOADINIFILENOENOUGHMEM,"The configuration file is too large that TEF don't have enough memory to load. Please consider split the configuration file into smaller one or load the file in your own test codes.");

   219 				INFO_PRINTF1(KTEFLOADINIFILENOENOUGHMEM);

   220 				}

   221 			User::Leave(err);

   222 			}

   223 	}

   224 

   225 /**

   226  * Reads the value present from the test steps ini file within the mentioned section name and key name

   227  * Copies the value to the TBool reference passed in

   228  * @param aSectName - Section within the test steps ini file

   229  * @param aKeyName - Name of a key within a section

   230  * @return aResult - The value of the boolean

   231  * @return TBool - ETrue for found, EFalse for not found 

   232  */

   233 EXPORT_C TBool CTestStep::GetBoolFromConfig(const TDesC& aSectName,const TDesC& aKeyName,TBool& aResult) 

   234 	{

   235 	TPtrC result;

   236 	if(!iConfigData)

   237 		return EFalse;

   238 	if(!iConfigData->FindVar(aSectName, aKeyName, result))

   239 		return EFalse;

   240 	_LIT(KTrue,"true");

   241 	if (result.FindF(KTrue) == KErrNotFound) 

   242 		aResult = EFalse;

   243 	else

   244 		aResult = ETrue;

   245 

   246 	if (iEnableIniAccessLog)

   247 		{

   248 		INFO_PRINTF5(KTEFIniReadInteger,iIniFileName, &aSectName, &aKeyName , aResult);

   249 		}

   250 	return(ETrue);

   251 	}

   252 

   253 /**

   254  * Reads the value present from the test steps ini file within the mentioned section name and key name

   255  * Copies the value to the TInt reference passed in

   256  * @param aSectName - Section within the test steps ini file

   257  * @param aKeyName - Name of a key within a section

   258  * @return aResult - The value of the integer

   259  * @return TBool - ETrue for found, EFalse for not found 

   260  */

   261 EXPORT_C TBool CTestStep::GetIntFromConfig(const TDesC& aSectName, const TDesC& aKeyName, TInt& aResult) 

   262 	{

   263 	if(!iConfigData)

   264 		return EFalse;

   265 	if(!iConfigData->FindVar(aSectName, aKeyName, aResult))

   266 		return EFalse;

   267 	if (iEnableIniAccessLog)

   268 		{

   269 		INFO_PRINTF5(KTEFIniReadInteger,iIniFileName, &aSectName, &aKeyName , aResult);

   270 		}

   271 	return ETrue;

   272 	}

   273 /**

   274  * Reads the value present from the test steps ini file within the mentioned section name and key name

   275  * Copies the value to the TInt64 reference passed in

   276  * @param aSectName - Section within the test steps ini file

   277  * @param aKeyName - Name of a key within a section

   278  * @return aResult - The value of the 64-bit integer

   279  * @return TBool - ETrue for found, EFalse for not found 

   280  */

   281 EXPORT_C TBool CTestStep::GetIntFromConfig(const TDesC& aSectName, const TDesC& aKeyName, TInt64& aResult)

   282 	{

   283 	if(!iConfigData)

   284 		return EFalse;

   285 	if(!iConfigData->FindVar(aSectName, aKeyName, aResult))

   286 		return EFalse;

   287 	if (iEnableIniAccessLog)

   288 		{

   289 		INFO_PRINTF5(KTEFIniReadInt64,iIniFileName, &aSectName, &aKeyName , aResult);

   290 		}

   291 	return ETrue;

   292 	}

   293 	

   294 /**

   295  * Reads the value present from the test steps ini file within the mentioned section name and key name

   296  * Copies the value to the TPtrC reference passed in

   297  * @param aSectName - Section within the test steps ini file

   298  * @param aKeyName - Name of a key within a section

   299  * @return aResult - Reference to the string on the heap

   300  * @return TBool - ETrue for found, EFalse for not found 

   301  */

   302 EXPORT_C TBool CTestStep::GetStringFromConfig(const TDesC& aSectName, const TDesC& aKeyName, TPtrC& aResult) 

   303 	{

   304 	if(!iConfigData)

   305 		return EFalse;

   306 	if(!iConfigData->FindVar(aSectName, aKeyName, aResult))

   307 		return EFalse;

   308 	if (iEnableIniAccessLog)

   309 		{

   310 		INFO_PRINTF5(KTEFIniReadString,iIniFileName, &aSectName, &aKeyName , &aResult);

   311 		}

   312 	return ETrue;

   313 	}

   314 

   315 /**

   316  * Reads the value present from the test steps ini file within the mentioned section name and key name

   317  * Copies the value to the TInt reference passed in

   318  * @param aSectName - Section within the test steps ini file

   319  * @param aKeyName - Name of a key within a section

   320  * @return aResult - The integer value of the Hex input

   321  * @return TBool - ETrue for found, EFalse for not found 

   322  */	

   323 EXPORT_C TBool CTestStep::GetHexFromConfig(const TDesC& aSectName,const TDesC& aKeyName,TInt& aResult)

   324 	{

   325 	TPtrC result;

   326 	if(!iConfigData)

   327 		return EFalse;

   328 	if(!iConfigData->FindVar(aSectName, aKeyName, result))

   329 		return EFalse;

   330 	TLex lex(result);

   331 	TInt err = lex.Val((TUint &)aResult, EHex);

   332 	if(err)

   333 		return EFalse;

   334 	if (iEnableIniAccessLog)

   335 		{

   336 		INFO_PRINTF5(KTEFIniReadInteger,iIniFileName, &aSectName, &aKeyName , aResult);

   337 		}

   338 	return(ETrue);

   339 	}

   340 

   341 /**

   342  * Writes the integer value  passed in to the test steps ini file under the section and key name mentioned

   343  * Creates a new section or key name if it does not existing already

   344  * @param aSectName - Section within the test steps ini file

   345  * @param aKeyName - Name of a key within a section

   346  * @return aValue - Reference to the integer to be written on to the test steps ini file

   347  * @return TBool - ETrue for found, EFalse for not found 

   348  */

   349 EXPORT_C TBool CTestStep::WriteIntToConfig(const TDesC& aSectName, const TDesC& aKeyName, const TInt& aValue)

   350 	{

   351 	TBuf<KMaxTestExecuteNameLength> value;

   352 	TBool retVal(ETrue);

   353 	TInt err(KErrNone);

   354 	value.AppendNum(aValue);

   355 			

   356 	if(!iConfigData)

   357 		{

   358 		retVal = EFalse;

   359 		}

   360 	else if(iConfigData->SetValue(aSectName,aKeyName,value)==KErrNotFound)

   361 		{

   362 		err = iConfigData->AddValue(aSectName,aKeyName,value);

   363 		}

   364 	

   365 	if(retVal && KErrNone==err)

   366 		{

   367 		TRAP(err, iConfigData->WriteToFileL());

   368 		if (iEnableIniAccessLog)

   369 			{

   370 			if (KErrNone == err)

   371 				{

   372 				INFO_PRINTF5(KTEFIniWriteInteger,iIniFileName, &aSectName, &aKeyName , aValue);

   373 				}

   374 			}

   375 		}

   376 

   377 	if (!retVal || KErrNone!=err)

   378 		{

   379 		retVal = EFalse;

   380 		if (iEnableIniAccessLog)

   381 			{

   382 			_LIT(KWriteIntegerError, "Error occurs when writing integer to file, error code=%d");

   383 			ERR_PRINTF2(KWriteIntegerError, err);

   384 			}

   385 		}

   386 	return retVal;

   387 	}

   388 /**

   389  * Writes the 64-bit integer value  passed in to the test steps ini file under the section and key name mentioned

   390  * Creates a new section or key name if it does not existing already

   391  * @param aSectName - Section within the test steps ini file

   392  * @param aKeyName - Name of a key within a section

   393  * @return aValue - Reference to the 64-bit integer to be written on to the test steps ini file

   394  * @return TBool - ETrue for found, EFalse for not found 

   395  */

   396 EXPORT_C TBool CTestStep::WriteIntToConfig(const TDesC& aSectName, const TDesC& aKeyName, const TInt64& aValue)

   397 	{

   398 	TBuf<KMaxTestExecuteNameLength> value;

   399 	TBool retVal(ETrue);

   400 	TInt err(KErrNone);

   401 	value.AppendNum(aValue);

   402 			

   403 	if(!iConfigData)

   404 		{

   405 		retVal = EFalse;

   406 		}

   407 	else if(iConfigData->SetValue(aSectName,aKeyName,value)==KErrNotFound)

   408 		{

   409 		err = iConfigData->AddValue(aSectName,aKeyName,value);

   410 		}

   411 	

   412 	if(retVal && KErrNone==err)

   413 		{

   414 		TRAP(err, iConfigData->WriteToFileL());

   415 		if (iEnableIniAccessLog)

   416 			{

   417 			if (KErrNone == err)

   418 				{

   419 				INFO_PRINTF5(KTEFIniWriteInt64,iIniFileName, &aSectName, &aKeyName , aValue);

   420 				}

   421 			}

   422 		}

   423 

   424 	if (!retVal || KErrNone!=err)

   425 		{

   426 		retVal = EFalse;

   427 		if (iEnableIniAccessLog)

   428 			{

   429 			_LIT(KWriteIntegerError, "Error occurs when writing integer to file, error code=%d");

   430 			ERR_PRINTF2(KWriteIntegerError, err);

   431 			}

   432 		}

   433 	return retVal;	

   434 	}

   435 

   436 /**

   437  * Writes the string value  passed in to the test steps ini file under the section and key name mentioned

   438  * Creates a new section or key name if it does not existing already

   439  * @param aSectName - Section within the test steps ini file

   440  * @param aKeyName - Name of a key within a section

   441  * @return aValue - Reference to the string to be written on to the test steps ini file

   442  * @return TBool - ETrue for found, EFalse for not found 

   443  */

   444 EXPORT_C TBool CTestStep::WriteStringToConfig(const TDesC& aSectName, const TDesC& aKeyName, const TPtrC& aValue)

   445 	{

   446 	TBool retVal(ETrue);

   447 	TInt err(KErrNone);

   448 			

   449 	if(!iConfigData)

   450 		{

   451 		retVal = EFalse;

   452 		}

   453 	else if(iConfigData->SetValue(aSectName,aKeyName,aValue)==KErrNotFound)

   454 		{

   455 		err = iConfigData->AddValue(aSectName,aKeyName,aValue);

   456 		}

   457 	

   458 	if(retVal && KErrNone==err)

   459 		{

   460 		TRAP(err, iConfigData->WriteToFileL());

   461 		if (iEnableIniAccessLog)

   462 			{

   463 			if (KErrNone == err)

   464 				{

   465 				INFO_PRINTF5(KTEFIniWriteString,iIniFileName, &aSectName, &aKeyName , &aValue);

   466 				}

   467 			}

   468 		}

   469 

   470 	if (!retVal || KErrNone!=err)

   471 		{

   472 		retVal = EFalse;

   473 		if (iEnableIniAccessLog)

   474 			{

   475 			_LIT(KWriteIntegerError, "Error occurs when writing string to file, error code=%d");

   476 			ERR_PRINTF2(KWriteIntegerError, err);

   477 			}

   478 		}

   479 	return retVal;

   480 	}

   481 	

   482 /**

   483  * Writes the boolean value  passed in to the test steps ini file under the section and key name mentioned

   484  * Creates a new section or key name if it does not existing already

   485  * @param aSectName - Section within the test steps ini file

   486  * @param aKeyName - Name of a key within a section

   487  * @return aValue - Reference to the boolean value to be written onto the test steps ini file

   488  * @return TBool - ETrue for found, EFalse for not found 

   489  */	

   490 EXPORT_C TBool CTestStep::WriteBoolToConfig(const TDesC& aSectName, const TDesC& aKeyName, const TBool& aValue)

   491 	{

   492 	TBuf<KMaxTestExecuteNameLength> value;

   493 	TBool retVal(ETrue);

   494 	TInt err(KErrNone);

   495 	if(aValue==1)

   496 		{

   497 		_LIT(KTrue,"True");

   498 		value.Append(KTrue);

   499 		}

   500 	else if(aValue==0) 

   501 		{

   502 		_LIT(KFalse,"False");

   503 		value.Append(KFalse);

   504 		}

   505 	else 

   506 		{

   507 		return(EFalse);

   508 		}

   509 		

   510 	if(!iConfigData)

   511 		{

   512 		retVal = EFalse;

   513 		}

   514 	else if(iConfigData->SetValue(aSectName,aKeyName,value)==KErrNotFound)

   515 		{

   516 		err = iConfigData->AddValue(aSectName,aKeyName,value);

   517 		}

   518 	

   519 	if(retVal && KErrNone==err)

   520 		{

   521 		TRAP(err, iConfigData->WriteToFileL());

   522 		if (iEnableIniAccessLog)

   523 			{

   524 			if (KErrNone == err)

   525 				{

   526 				INFO_PRINTF5(KTEFIniWriteInteger,iIniFileName, &aSectName, &aKeyName , aValue);

   527 				}

   528 			}

   529 		}

   530 

   531 	if (!retVal || KErrNone!=err)

   532 		{

   533 		retVal = EFalse;

   534 		if (iEnableIniAccessLog)

   535 			{

   536 			_LIT(KWriteIntegerError, "Error occurs when writing bool to file, error code=%d");

   537 			ERR_PRINTF2(KWriteIntegerError, err);

   538 			}

   539 		}

   540 	return retVal;

   541 	}

   542 	

   543 /**

   544  * Writes the hex equivalent of the integer value  passed in to the test steps ini file 

   545  * under the section and key name mentioned

   546  * Creates a new section or key name if it does not existing already

   547  * @param aSectName - Section within the test steps ini file

   548  * @param aKeyName - Name of a key within a section

   549  * @return aValue - Reference to the integer equivalent of the hex value to be written onto the test steps ini file

   550  * @return TBool - ETrue for found, EFalse for not found 

   551  */	

   552 EXPORT_C TBool CTestStep::WriteHexToConfig(const TDesC& aSectName, const TDesC& aKeyName, const TInt& aValue)

   553 	{

   554 	TBuf<KMaxTestExecuteNameLength> value;

   555 	TBool retVal(ETrue);

   556 	TInt err(KErrNone);

   557 	value.Num(aValue,EHex);

   558 	

   559 	if(!iConfigData)

   560 		{

   561 		retVal = EFalse;

   562 		}

   563 	else if(iConfigData->SetValue(aSectName,aKeyName,value)==KErrNotFound)

   564 		{

   565 		iConfigData->AddValue(aSectName,aKeyName,value);

   566 		}

   567 	

   568 	if(retVal && KErrNone==err)

   569 		{

   570 		TRAP(err, iConfigData->WriteToFileL());

   571 		if (iEnableIniAccessLog)

   572 			{

   573 			if (KErrNone == err)

   574 				{

   575 				INFO_PRINTF5(KTEFIniWriteInteger,iIniFileName, &aSectName, &aKeyName , aValue);

   576 				}

   577 			}

   578 		}

   579 

   580 	if (!retVal || KErrNone!=err)

   581 		{

   582 		retVal = EFalse;

   583 		if (iEnableIniAccessLog)

   584 			{

   585 			_LIT(KWriteIntegerError, "Error occurs when writing hex to file, error code=%d");

   586 			ERR_PRINTF2(KWriteIntegerError, err);

   587 			}

   588 		}

   589 	return retVal;

   590 	}

   591 

   592 /**

   593  * Updates the data to the shared data name passed either in Copy Mode/Append Mode

   594  * @param aShareName - Shared data name to be written

   595  * @param aSharedDataVal - Descriptor value to be used for updating the shared data

   596  * @param aModeCopy - Enum value indicating the descriptor value to be overwritten/appended

   597  * @Leave system wide errors

   598  */

   599 EXPORT_C void CTestStep::WriteSharedDataL(const TDesC& aShareName, TDesC& aSharedDataVal, TModeCopy aModeCopy)

   600 	{

   601 	CTestSharedData* sharedObject = NULL;

   602 	CTEFSharedData<CTestSharedData>* sharedData1 = CTEFSharedData<CTestSharedData>::NewLC(sharedObject, aShareName);

   603 	sharedData1->EnterCriticalSection();

   604 	switch(aModeCopy)

   605 		{

   606 		case ESetText:

   607 			{

   608 			sharedObject->SetText(aSharedDataVal);

   609 			break;

   610 			}

   611 		case EAppendText:

   612 			{

   613 			sharedObject->AppendText(aSharedDataVal);

   614 			break;

   615 			}

   616 		default:

   617 			break;

   618 		}

   619 	sharedData1->ExitCriticalSection();

   620 	CleanupStack::PopAndDestroy(sharedData1);

   621 	}

   622 

   623 /**

   624  * Reads the data from the specified shared data object

   625  * Copies it to the reference descriptor passed in

   626  * @param aShareName - Shared Data Name to be read

   627  * @param aSharedDataVal - Descriptor reference passed in for reading the data from shared data

   628  * @Leave system wide errors

   629  */

   630 EXPORT_C void CTestStep::ReadSharedDataL(const TDesC& aShareName, TDes& aSharedDataVal)

   631 	{

   632 	CTestSharedData* sharedObject = NULL;

   633 	CTEFSharedData<CTestSharedData>* sharedData1 = CTEFSharedData<CTestSharedData>::NewLC(sharedObject, aShareName);

   634 	sharedData1->EnterCriticalSection();

   635 	sharedObject->GetText(aSharedDataVal);

   636 	sharedData1->ExitCriticalSection();

   637 	CleanupStack::PopAndDestroy(sharedData1);

   638 	}

   639 

   640 /**

   641  * Sets the test step class with a user-friendly name to be referred from the script file

   642  * @param aStepName - Name of the test step

   643  */

   644 EXPORT_C void CTestStep::SetTestStepName(const TDesC& aStepName)

   645 	{

   646 	iTestStepName.Copy(aStepName);

   647 	}

   648 

   649 /**

   650  * Used to set the actual error value within the test step object

   651  * @param aStepError - Test Step Error

   652  */

   653 EXPORT_C void CTestStep::SetTestStepError(const TInt& aStepError)

   654 	{

   655 	iTestStepError = aStepError;

   656 	if (aStepError < 0)

   657 		SetTestStepResult(EFail);

   658 	}

   659 

   660 /**

   661  * Initialise the File Logger server

   662  * Secure and Non-secure variants

   663  * @Leave system wide errors

   664  */

   665 void CTestStep::SetLoggerL()

   666 	{

   667 	if(iLogger)

   668 		{

   669 		CloseLogger();

   670 		delete iLogger  ;

   671 		iLogger = NULL;

   672 		}

   673 	TRAPD(err1,iLogger = CTestExecuteLogger::NewL());

   674 	if(err1 != KErrNone)

   675 		{

   676 		User::Leave(err1);

   677 		}

   678 

   679 	// Create a cinidata object for parsing the testexecute.ini

   680 	CTestExecuteIniData* parseTestExecuteIni = NULL;

   681 	TBuf<KMaxTestExecuteNameLength> resultFilePath;

   682 	TBuf<KMaxTestExecuteNameLength> xmlFilePath;

   683 	TInt logMode;

   684 	TInt loggerChannel ; 

   685 	TInt logLevel;

   686 	TInt ChanneloutPort;// serial port

   687 	

   688 	TRAPD(err,parseTestExecuteIni = CTestExecuteIniData::NewL(iSystemDrive));

   689 	if (err == KErrNone)

   690 		{

   691 		CleanupStack::PushL(parseTestExecuteIni);

   692 		parseTestExecuteIni->ExtractValuesFromIni();

   693 		parseTestExecuteIni->GetKeyValueFromIni(KTEFHtmlKey, resultFilePath);

   694 		parseTestExecuteIni->GetKeyValueFromIni(KTEFXmlKey, xmlFilePath);

   695 		parseTestExecuteIni->GetKeyValueFromIni(KTEFLogMode, logMode);

   696 		parseTestExecuteIni->GetKeyValueFromIni(KTEFLogSeverityKey, logLevel);

   697 		parseTestExecuteIni->GetKeyValueFromIni(KTEFEnableIniAccessLog, iEnableIniAccessLog);

   698 		parseTestExecuteIni->GetKeyValueFromIni(KTEFLogChannel, loggerChannel);

   699 		parseTestExecuteIni->GetKeyValueFromIni(KTEFOutputPort,ChanneloutPort);

   700 		}

   701 	else

   702 		{

   703 		TBuf<KMaxTestExecuteNameLength> testExecuteLogPath(KTestExecuteLogPath);

   704 		testExecuteLogPath.Replace(0, 2, iSystemDrive);

   705 		resultFilePath.Copy(testExecuteLogPath);

   706 		xmlFilePath.Copy(testExecuteLogPath);

   707 		logMode = TLoggerOptions(ELogHTMLOnly);

   708 		logLevel = RFileFlogger::TLogSeverity(ESevrAll);

   709 		iEnableIniAccessLog = ETrue;

   710 		}

   711 	Logger().SetLoggerOptions(logMode);

   712 	Logger().SetLoggerChannel(loggerChannel) ; 

   713 	if( loggerChannel == ESerial || loggerChannel == EBoth)		

   714 		{

   715 		//InitialiseLoggingL

   716 		Logger().OpenSerialPortL(ChanneloutPort);

   717 		}

   718 	

   719 	// Initialise a handle to the file logger

   720 	User::LeaveIfError(Logger().Connect());

   721 	RFs fS;

   722 	User::LeaveIfError(fS.Connect());

   723 	CleanupClosePushL(fS);

   724 	RFile file;

   725 	TBuf<KMaxTestExecuteNameLength> xmlLogFile(xmlFilePath);

   726 	TBuf<KMaxTestStepNameLength> logFile;

   727 	TBuf<KMaxTestExecuteNameLength> logFileNameFile(resultFilePath);

   728 	logFileNameFile.Append(KTestExecuteScheduleTestLogCompatibilityNameFile);

   729 	if(file.Open(fS,logFileNameFile,EFileRead | EFileShareAny) != KErrNone)

   730 		{

   731 		// For the old flogger we have to create an individual file

   732 		logFile.Copy(iTestStepName);

   733 		_LIT(KTxtExtension,".txt");

   734 		logFile.Append(KTxtExtension);

   735 		logMode = TLoggerOptions(0);

   736 		Logger().SetLoggerOptions(logMode);

   737 		}

   738 	else

   739 		{

   740 		CleanupClosePushL(file);

   741 		TBuf8<KMaxTestExecuteNameLength> logFile8;

   742 		TInt fileSize;

   743 		User::LeaveIfError(file.Size(fileSize));

   744 		User::LeaveIfError(file.Read(logFile8,fileSize));

   745 		logFile.Copy(logFile8);

   746 		xmlLogFile.Append(logFile);

   747 		_LIT(KXmlExtension,".xml");

   748 		xmlLogFile.Append(KXmlExtension);

   749 		_LIT(KHtmExtension,".htm");

   750 		logFile.Append(KHtmExtension);

   751 		CleanupStack::Pop(&file);

   752 		file.Close();

   753 		}

   754 	TBuf<KMaxTestExecuteLogFilePath> logFilePath(resultFilePath);

   755 	logFilePath.Append(logFile);

   756 	CleanupStack::Pop(&fS);

   757 	fS.Close();

   758 	

   759 	if (logMode == 0 || logMode == 2)

   760 		{

   761 		TRAPD(err1,Logger().HtmlLogger().CreateLog(logFilePath,RTestExecuteLogServ::ELogModeAppend));

   762 		if(err1 != KErrPathNotFound)

   763 			{

   764 			User::LeaveIfError(err1) ;

   765 			}

   766 		else

   767 			{

   768 			// if its other than an htm file , ignore it

   769 			_LIT(KHtmExtension,".htm");

   770 			if(logFilePath.Find(KHtmExtension)>-1)

   771 				{

   772 				User::LeaveIfError(err1) ;

   773 				}

   774 			}

   775 

   776 		Logger().HtmlLogger().SetLogLevel(TLogSeverity(logLevel));

   777 		}

   778 	if (logMode == 1 || logMode == 2)

   779 		{

   780 		User::LeaveIfError(Logger().XmlLogger().CreateLog(xmlLogFile,RFileFlogger::ELogModeAppend));

   781 		Logger().XmlLogger().SetLogLevel(RFileFlogger::TLogSeverity(logLevel));

   782 		}

   783 	if (parseTestExecuteIni != NULL)

   784 		{

   785 		CleanupStack::PopAndDestroy(parseTestExecuteIni);

   786 		}

   787 	}

   788 

   789 /**

   790  * Just close our handle to Flogger

   791  */

   792 void CTestStep::CloseLogger()

   793 	{

   794 	Logger().Close();

   795 //	if(iLogger)

   796 //		{

   797 //		delete iLogger;

   798 //		iLogger = NULL;

   799 //		}

   800 	}

   801 

   802 ///////

   803 // LEGACY methods from scheduletest & autotest

   804 ///////

   805 EXPORT_C void CTestStep::testBooleanTrue(TBool aCondition, const TText8* aFile, TInt aLine)

   806 ///< TEST(a)

   807 	{

   808 	if(TestStepResult() == EPass && !aCondition)			// If not true, change to fail!

   809 		{

   810 		SetTestStepResult(EFail);

   811 		_LIT(KMessage,"ERROR: Test Failed");

   812 		Logger().LogExtra(aFile, aLine, ESevrErr,KMessage);

   813 		}

   814 	}

   815 

   816 EXPORT_C void CTestStep::testBooleanTrue(TBool aCondition, const TText8* aFile, TInt aLine, TBool aIgnoreStepResult)

   817 ///< TEST(a)

   818 	{

   819 	if (aIgnoreStepResult)

   820 		{

   821 		if (!aCondition)

   822 			{

   823 			SetTestStepResult(EFail);

   824 			_LIT(KMessage,"ERROR: Test Failed");

   825 			Logger().LogExtra(aFile, aLine, ESevrErr,KMessage);

   826 			}

   827 		}

   828 	else

   829 		{

   830 		testBooleanTrue(aCondition, aFile, aLine);

   831 		}

   832 	}

   833 

   834 EXPORT_C void CTestStep::testBooleanTrueL(TBool aCondition, const TText8* aFile, TInt aLine)

   835 ///< TESTL(a)

   836 	{

   837 	testBooleanTrue(aCondition, aFile, aLine);

   838 	if(!aCondition)

   839 		User::Leave(TEST_ERROR_CODE);	// leave with standard error code

   840 	}

   841 

   842 EXPORT_C void CTestStep::testBooleanTrueL(TBool aCondition, const TText8* aFile, TInt aLine, TBool aIgnoreStepResult)

   843 ///< TESTL(a)

   844 	{

   845 	testBooleanTrue(aCondition, aFile, aLine, aIgnoreStepResult);

   846 	if(!aCondition)

   847 		User::Leave(TEST_ERROR_CODE);	// leave with standard error code

   848 	}

   849 

   850 EXPORT_C void CTestStep::testBooleanTrueWithErrorCodeL(TBool aCondition, TInt aErrorCode, const TText8* aFile, TInt aLine)

   851 ///< TESTEL(a,b)

   852 	{

   853 	testBooleanTrueWithErrorCode(aCondition, aErrorCode, aFile, aLine);

   854 	if(!aCondition)

   855 		User::Leave(aErrorCode);

   856 	}

   857 

   858 EXPORT_C void CTestStep::testBooleanTrueWithErrorCodeL(TBool aCondition, TInt aErrorCode, const TText8* aFile, TInt aLine, TBool aIgnoreStepResult)

   859 ///< TESTEL(a,b)

   860 	{

   861 	testBooleanTrueWithErrorCode(aCondition, aErrorCode, aFile, aLine, aIgnoreStepResult);

   862 	if(!aCondition)

   863 		User::Leave(aErrorCode);

   864 	}

   865 

   866 EXPORT_C void CTestStep::testBooleanTrueWithErrorCode(TBool aCondition, TInt aErrorCode, const TText8* aFile, TInt aLine)

   867 ///< TESTE(a,b)

   868 	{

   869 	if(TestStepResult() == EPass && !aCondition)			// If not true, change to fail!

   870 		{

   871 		SetTestStepResult(EFail);

   872 		_LIT(KMessage,"Test Failed with error [%d]");

   873 		//START defect 116178

   874 		Logger().LogExtra(aFile, aLine, ESevrErr, KMessage, aErrorCode);

   875 		//END defect 116178

   876 		}

   877 	}

   878 

   879 EXPORT_C void CTestStep::testBooleanTrueWithErrorCode(TBool aCondition, TInt aErrorCode, const TText8* aFile, TInt aLine, TBool aIgnoreStepResult)

   880 ///< TESTE(a,b)

   881 	{

   882 	if (aIgnoreStepResult)

   883 		{

   884 		if(!aCondition)			

   885 			{

   886 			SetTestStepResult(EFail);

   887 			_LIT(KMessage,"Test Failed with error [%d]");

   888 		//	START defect 116178

   889 			Logger().LogExtra(aFile, aLine, ESevrErr, KMessage, aErrorCode);

   890 		//	END defect 116178

   891 			}

   892 		}

   893 	else

   894 		{

   895 		testBooleanTrueWithErrorCode(aCondition, aErrorCode, aFile, aLine);

   896 		}

   897 	}

   898 

   899 EXPORT_C void CTestStep::TestCheckPointCompareL(TInt aVal,TInt aExpectedVal, const TDesC& aText, const TText8* aFile,TInt aLine)

   900 	{

   901 	if(aVal != aExpectedVal)

   902 		{

   903 		// decode formated data for display on console

   904 		TBuf <KMaxTestExecuteLogLineLength> LineBuf;

   905 		_LIT(KMessage,"FAILED test:  Val = %d Exp Val = %d %S");

   906 		LineBuf.AppendFormat(KMessage,aVal,aExpectedVal,&aText);

   907 		// send the data to the log system via the suite

   908 		Logger().LogExtra((TText8*)aFile, aLine, ESevrErr, LineBuf );

   909 		User::Leave(aVal);

   910 		}

   911 	}

   912 

   913 /**

   914  * Returns the server name that instantiated the test step

   915  * @return TDesC - CTestServer name

   916  */

   917 EXPORT_C const TDesC& CTestStep::GetServerName() const

   918 	{

   919 	return iServerName;

   920 	}

   921 

   922 /**

   923  * TestCaseName

   924  * Returns boolean true if testcase name is available, false otherwise.

   925  * Updates the TDes& to the testcase name if available, blank string otherwise.

   926  * @param aTestCaseName - TDes reference to update the test case name

   927  * @return TBool - Boolean value indicating presense of test case name

   928  */

   929 EXPORT_C TBool CTestStep::TestCaseName(TDes& aTestCaseName)

   930 	{

   931 	if (iTestCaseID.CompareF(KTEFTestCaseDefault) == 0)

   932 		{

   933 		aTestCaseName.Copy(KTEFNull);

   934 		return EFalse;

   935 		}

   936 	else

   937 		{

   938 		aTestCaseName.Copy(iTestCaseID);

   939 		return ETrue;

   940 		}

   941 	}