MercurialSymaptic / file revision
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
os/security/cryptomgmtlibs/securitytestfw/test/testhandler2/tScriptSetup.cpp
author sl
Tue, 10 Jun 2014 14:32:02 +0200
changeset 1 260cb5ec6c19
permissions -rw-r--r--
Update contrib. 
     1 /*

     2 * Copyright (c) 1998-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 the License "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 *

    16 */

    17 

    18 

    19 #include "tScriptSetup.h"

    20 #include "tScriptTests.h"

    21 

    22 #include "t_testactionspec.h"

    23 #include "t_input.h"

    24 #include "t_tefinput.h"

    25 #include "t_certstoreactionmemfail.h"

    26 #include "tcancel.h"

    27 #include "t_sleep.h"

    28 #include "t_message.h"

    29 #include "t_output.h"

    30 #include "tTestSpec.h"

    31 

    32 #include <s32file.h>

    33 

    34 #include "t_logger.h"

    35 

    36 _LIT8(KStartMemFail, "startmemfailure");

    37 _LIT8(KStopMemFail, "stopmemfailure");

    38 _LIT8(KCancelStart, "startcancellation");

    39 _LIT8(KCancelStop, "stopcancellation");

    40 _LIT8(KMessage, "message");

    41 _LIT8(KSleep, "sleep");

    42 

    43 #include "t_policy.h"

    44 _LIT8(KPolicyTest, "policytest");

    45 

    46 EXPORT_C CScriptSetup* CScriptSetup::NewLC(CConsoleBase* aConsole)

    47 	{

    48 	CScriptSetup* self = new (ELeave) CScriptSetup(aConsole);

    49 	CleanupStack::PushL(self);

    50 	self->ConstructL();

    51 	return self;

    52 	}

    53 

    54 CScriptSetup::CScriptSetup(CConsoleBase* aConsole) : CTestSetup(aConsole)

    55 	{

    56 	}

    57 

    58 EXPORT_C CScriptSetup::~CScriptSetup()

    59 	{

    60 	delete iTestInput;

    61 	delete iScriptPath;

    62 	}

    63 

    64 EXPORT_C void CScriptSetup::SetupTestsL(RFs& aFs,

    65 										CTestSpec& aTestSpec, 

    66 										TScriptTests theTestTypes[], 

    67 										const CTestHandlerSettings& aCommandLineSettings)

    68 	{

    69 	TInt pos = 0;

    70 	TInt err = KErrNone;

    71 	TBuf8<256> testCaseID;

    72 	TBuf8<256> prevtestCaseID;

    73 	TBuf8<512> scriptResult;

    74 	TBuf8<512> actionType;

    75 	TBool runtest = EFalse;

    76 	TBool iniFile = EFalse;

    77 	TBool startTest = EFalse;

    78 	TBool endTest = EFalse;

    79 	

    80 	for (TInt i = 1 ; ; ++i)

    81 		{

    82 		TPtrC8 runTestStep;

    83 		TPtrC8 testDescription;

    84 		TPtrC8 actionData;

    85 		

    86 		if (iTefScript)

    87 			{

    88 			

    89 			if(endTest)

    90 				{

    91 				startTest = EFalse;

    92 				runtest = EFalse;

    93 				testCaseID.Copy(Tefinput::ParseTestCaseID(*iTestInput, KStartTestStep, prevtestCaseID, pos, err, runtest, startTest));

    94 				prevtestCaseID.Copy(testCaseID);

    95 				}

    96 			if(runtest)

    97 				{

    98 				if(endTest && startTest)

    99 					{

   100 					startTest = ETrue;

   101 					}

   102 				else

   103 					{

   104 					startTest = EFalse;

   105 					}

   106 				endTest = EFalse;

   107 				testCaseID.Copy(prevtestCaseID);

   108 				}

   109 			else

   110 				{

   111 				testCaseID.Copy(Tefinput::ParseTestCaseID(*iTestInput, KStartTestStep, prevtestCaseID, pos, err, runtest, startTest));

   112 				prevtestCaseID.Copy(testCaseID);

   113 				}

   114 			runTestStep.Set(Tefinput::ParseRunTestStep(*iTestInput, KRunTestStep, pos, err));

   115 			endTest = Tefinput::EndTestCase(*iTestInput, runTestStep, KEndTestStep, pos);

   116 			}

   117 		else

   118 			{

   119 			actionData.Set(Input::ParseElement(*iTestInput, KActionStart, KActionEnd, pos, err));

   120 			}

   121 		if (err != KErrNone)

   122 		  	{

   123 			break;

   124 			} 

   125 			 

   126 		TInt relativePos = 0;

   127 		TInt scriptGroupings= DEFAULTGROUPING;

   128 		TTestActionSpec actionSpec;

   129 		//Parse the file to create action name, type , body and result

   130 		if (iTefScript)

   131 			{

   132 			User::LeaveIfError(actionSpec.TEFInit(aFs, runTestStep, testCaseID, prevtestCaseID, iTefScript, runtest, iniFile, scriptResult, actionType, *iScriptPath, *iConsole, *iLogFile));

   133 			}

   134 		else

   135 			{

   136 			User::LeaveIfError(actionSpec.Init(actionData, relativePos, *iConsole, *iLogFile, scriptGroupings));

   137 			}

   138 		

   139 		//Start off checking Exhaustive and Smoke flags, then calls groupings

   140 		if (!CheckAllFlags(aCommandLineSettings, scriptGroupings))

   141 			//The current test should not be run

   142 			continue;

   143 	

   144 		

   145 		CTestAction* newAction = 0;

   146 		TRAP(err, newAction = CreateActionL(aFs, actionSpec, theTestTypes));

   147 		

   148 	

   149 		

   150 

   151 		if (err != KErrNone)

   152 			{

   153 			iLogFile->write(_L("CScriptSetup::CreateActionL failed: "));

   154 			iLogFile->writeError(err);		

   155 			iLogFile->writeNewLine();

   156 			

   157 			iLogFile->write(_L("Action name: "));

   158 			iLogFile->writeString(actionSpec.iActionName);				

   159 			iLogFile->writeNewLine();

   160 

   161 			iLogFile->write(_L("Action type: "));

   162 			iLogFile->writeString(actionSpec.iActionType);				

   163 			iLogFile->writeNewLine();

   164 			

   165 			iLogFile->write(_L("1 tests failed out of 1\r\n"));

   166 			

   167 			User::Leave(err);

   168 			}

   169 		

   170 		if(newAction->ScriptError() != CTestAction::ENone)

   171 			{

   172 			TBuf<KMaxErrorSize> scriptError;

   173 			newAction->ScriptError(scriptError);

   174 			

   175 			iLogFile->write(_L("Script error \"%S\" in test %s\r\n"), &scriptError, i);

   176 				

   177 			delete newAction;

   178 			User::Leave(KErrArgument);

   179 			}

   180 		

   181 		CleanupStack::PushL(newAction);

   182 		User::LeaveIfError(aTestSpec.AddNextTest(newAction));

   183 		CleanupStack::Pop(newAction);

   184 	

   185 		if(iniFile)

   186 			{

   187 			CleanupStack::PopAndDestroy(1);

   188 			}

   189 		}

   190 	}

   191 

   192 EXPORT_C TBool CScriptSetup::InitialiseL(RFs &aFs, const TDesC& aDefaultScript, const TDesC& aDefaultLog, TBool aUseCommandLine)

   193 	{

   194 	// gets the script file argument

   195 	iScriptPath = NULL;

   196 	iTefScript = EFalse;

   197 

   198 	if (aUseCommandLine)

   199 		{

   200 		iScriptPath = GetArgument();

   201 		if(iScriptPath->Length()==0)

   202 			{

   203 			delete iScriptPath;  

   204 			iScriptPath = NULL;

   205 			}

   206 		else

   207 			{

   208 			TPtr scriptFileNameDes = iScriptPath->Des();

   209 			if (scriptFileNameDes.Right(8) == _L(".script1") || scriptFileNameDes.Right(7) == _L(".script"))

   210 				{

   211 				iTefScript = ETrue;

   212 				}

   213 			}

   214 		}

   215 

   216 	if(iScriptPath == NULL)

   217 		{

   218 		if(aDefaultScript.Length() == 0)

   219 			{

   220 			PRINTANDLOG(_L("No script file specified on command line and no default given"));

   221 			return(EFalse);

   222 			}

   223 		else

   224 			{

   225 			iScriptPath = aDefaultScript.AllocLC();

   226 			}

   227 		};

   228 

   229 	PRINTANDLOG1(_L("Script file: %S"), iScriptPath);

   230 

   231 	// open the script file

   232 	RFile scriptFile;

   233 	TInt err = scriptFile.Open(aFs, *iScriptPath, EFileStream | EFileRead | EFileShareReadersOnly);

   234 	if (err != KErrNone)

   235 		{

   236 		PRINTANDLOG1(_L("Error opening script file: %d"), err);

   237 		delete iScriptPath;

   238 		iScriptPath = NULL;

   239 		return(EFalse);

   240 		}

   241 	CleanupClosePushL(scriptFile);

   242 	

   243 	TRAP(err, OpenLogFileL(aFs, 1, aDefaultLog, aUseCommandLine));	

   244 	if (err != KErrNone)

   245 		{

   246 		PRINTANDLOG1(_L("Error opening log file: %d"), err);	

   247 		delete iScriptPath;

   248 		iScriptPath = NULL;

   249 		CleanupStack::PopAndDestroy(1);// scripFile

   250 		return(EFalse);

   251 		}

   252 		

   253 	// gets size of script file

   254 	TInt size;

   255 	scriptFile.Size(size);

   256 	CleanupStack::PopAndDestroy(); // scriptFile

   257 		

   258 	// reads script into iTestInput

   259 	iTestInput = HBufC8::NewL(size);

   260 	TPtr8 pInput(iTestInput->Des()); 

   261 	pInput.SetLength(size); 

   262 

   263 	RFileReadStream stream;

   264 	User::LeaveIfError(stream.Open(aFs, *iScriptPath, EFileStream | EFileRead | EFileShareReadersOnly));

   265 	CleanupClosePushL(stream);

   266 	stream.ReadL(pInput, size);

   267 	CleanupStack::PopAndDestroy(1); // stream

   268 	return(ETrue);

   269 	}

   270 

   271 EXPORT_C CTestAction* CScriptSetup::CreateActionL(RFs& aFs,

   272 												  const TTestActionSpec& aTestActionSpec,

   273 												  const TScriptTests theTestTypes[]) const

   274 	{

   275 	// Instantiate built in test actions

   276 	if (aTestActionSpec.iActionType == KStartMemFail)

   277 		{

   278 		return CMemFailStart::NewL(*iTestConsole, *iLogFile, aTestActionSpec);

   279 		}

   280 	else if (aTestActionSpec.iActionType == KStopMemFail)

   281 		{

   282 		return CMemFailStop::NewL(*iTestConsole, *iLogFile, aTestActionSpec);

   283 		}

   284 	else if (aTestActionSpec.iActionType == KCancelStart)

   285 		{

   286 		return CCancelStart::NewL(*iTestConsole, *iLogFile, aTestActionSpec);

   287 		}

   288 	else if (aTestActionSpec.iActionType == KCancelStop)

   289 		{

   290 		return CCancelStop::NewL(*iTestConsole, *iLogFile, aTestActionSpec);

   291 		}

   292 	else if (aTestActionSpec.iActionType == KMessage)

   293 		{

   294 		return CTestActionMessage::NewL(*iTestConsole, *iLogFile, aTestActionSpec);

   295 		}

   296 	else if (aTestActionSpec.iActionType == KSleep)

   297 		{

   298 		return CSleep::NewL(*iTestConsole, *iLogFile, aTestActionSpec);

   299 		}

   300 	else if (aTestActionSpec.iActionType == KPolicyTest)

   301 		{

   302 		return CPolicyTest::NewL(*iTestConsole, *iLogFile, aTestActionSpec);

   303 		}

   304 

   305 	// Look through the array of tests in order to find the correct class to return

   306 	TInt loop=0;

   307 	while (theTestTypes[loop].action!=NULL)

   308 		{

   309 		if (aTestActionSpec.iActionType == theTestTypes[loop].name)

   310 			{

   311 			return theTestTypes[loop].action(aFs, *iTestConsole, *iLogFile, aTestActionSpec);

   312 			}

   313 		loop++;

   314 		}

   315 

   316 	User::Leave(KErrNotSupported);

   317 	return NULL;

   318 	}
Symaptic