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/t_testactionspec.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 "t_testactionspec.h"

    20 #include "t_testsetup.h"

    21 #include "tScriptSetup.h"

    22 #include "t_input.h"

    23 #include "tScriptTests.h"

    24 #include "t_tefinput.h"

    25 

    26 _LIT8(KTrue, "true");

    27 _LIT8(KFalse, "false");

    28 

    29 _LIT8(KExOOMStart, "<exoom>");

    30 _LIT8(KExOOMEnd, "</exoom>");

    31 _LIT8(KInOOMStart, "<inoom>");

    32 _LIT8(KInOOMEnd, "</inoom>");

    33 _LIT8(KExCancelStart, "<excancel>");

    34 _LIT8(KExCancelEnd, "</excancel>");

    35 _LIT8(KInCancelStart, "<incancel>");

    36 _LIT8(KInCancelEnd, "</incancel>");

    37 _LIT8(KSkippedStart, "<skipped>");

    38 _LIT8(KSkippedEnd, "</skipped>");

    39 _LIT8(KSmokeStart, "<smoke>");

    40 _LIT8(KSmokeEnd, "</smoke>");

    41 _LIT8(KInteractiveStart, "<interactive>");

    42 _LIT8(KInteractiveEnd, "</interactive>");

    43 

    44 

    45 TTestActionSpec::TTestActionSpec()

    46 	{

    47 	}

    48 

    49 TTestActionSpec::~TTestActionSpec()

    50 	{

    51 	iniSectionResultBody.Close();

    52 	}

    53 

    54 TInt TTestActionSpec::Init(const TDesC8& aInput, 

    55 						   TInt& aPos,

    56 						   CConsoleBase& /*aConsole*/,

    57 						   Output& aOut,

    58 						   TInt& aBitFlag)

    59 	{

    60 	TInt err = KErrNone;

    61 	iActionName.Set(Input::ParseElement(aInput, KActionNameStart, KActionNameEnd, aPos, err));

    62 	if (err != KErrNone)

    63 		{

    64 		aOut.writeString(_L("Error couldn't find actionname in test case spec"));

    65 		aOut.writeNewLine();

    66 		return err;

    67 		}

    68 	

    69 	iActionType.Set(Input::ParseElement(aInput, KActionTypeStart, KActionTypeEnd, aPos, err));

    70 	if (err != KErrNone)

    71 		{

    72 		aOut.writeString(_L("Error couldn't find actiontype in test case spec"));

    73 		aOut.writeNewLine();

    74 		return err;

    75 		}

    76 	

    77 	iActionGroup.Set(Input::ParseElement(aInput, KActionGroupingStart, KActionGroupingEnd, aPos, err));

    78 	if (err == KErrNone)

    79 		{

    80 		//Do parsing of the returned groupings string

    81 		TInt relativePos=0;

    82 		TPtrC8 excludeOOM = Input::ParseElement(iActionGroup, KExOOMStart, KExOOMEnd, relativePos, err);

    83 		relativePos=0;

    84 		TPtrC8 includeOOM = Input::ParseElement(iActionGroup, KInOOMStart, KInOOMEnd, relativePos, err);

    85 		relativePos=0;

    86 		TPtrC8 excludeCancel = Input::ParseElement(iActionGroup, KExCancelStart, KExCancelEnd, relativePos, err);

    87 		relativePos=0;

    88 		TPtrC8 includeCancel = Input::ParseElement(iActionGroup, KInCancelStart, KInCancelEnd, relativePos, err);

    89 		relativePos=0;

    90 		TPtrC8 skipped = Input::ParseElement(iActionGroup, KSkippedStart, KSkippedEnd, relativePos, err);

    91 		relativePos=0;

    92 		TPtrC8 smoketest = Input::ParseElement(iActionGroup, KSmokeStart, KSmokeEnd, relativePos, err);

    93 		relativePos=0;

    94 		TPtrC8 interactive = Input::ParseElement(iActionGroup, KInteractiveStart, KInteractiveEnd, relativePos, err);

    95 

    96 		if (excludeOOM==KTrue)

    97 			{

    98 			aBitFlag|=EXOOM;

    99 			}

   100 		else if (excludeOOM==KFalse)

   101 			{

   102 			aBitFlag&= (~EXOOM);

   103 			}

   104 		

   105 		if (includeOOM==KTrue)

   106 			{

   107 			aBitFlag|=INOOM;

   108 			}

   109 		else if (includeOOM==KFalse)

   110 			{

   111 			aBitFlag&= (~INOOM);

   112 			}

   113 

   114 		if (excludeCancel==KTrue)

   115 			{

   116 			aBitFlag|=EXCANCEL;

   117 			}

   118 		else if (excludeCancel==KFalse)

   119 			{

   120 			aBitFlag&= (~EXCANCEL);

   121 			}

   122 

   123 		if (includeCancel==KTrue)

   124 			{

   125 			aBitFlag|=INCANCEL;

   126 			}

   127 		else if (includeCancel==KFalse)

   128 			{

   129 			aBitFlag&= (~INCANCEL);

   130 			}

   131 

   132 		if (skipped==KTrue)

   133 			{

   134 			aBitFlag|=SKIP;

   135 			}

   136 		else if (skipped==KFalse)

   137 			{

   138 			aBitFlag&= (~SKIP);

   139 			}

   140 	

   141 		if (smoketest==KTrue)

   142 			{

   143 			aBitFlag|=SMOKE;

   144 			}

   145 		else if (smoketest==KFalse)

   146 			{

   147 			aBitFlag&= (~SMOKE);

   148 			}

   149 

   150 		if (interactive==KTrue)

   151 			{

   152 			aBitFlag|=INTER;

   153 			}

   154 		else if (interactive==KFalse)

   155 			{

   156 			aBitFlag&= (~INTER);

   157 			}

   158 		}

   159 	

   160 	iActionBody.Set(Input::ParseElement(aInput, KActionBodyStart, KActionBodyEnd, aPos, err));

   161 	iActionResult.Set(Input::ParseElement(aInput, KActionResultStart, KActionResultEnd, aPos, err));

   162 	iTefScript = EFalse;

   163 	

   164 	return KErrNone; 

   165 	}

   166 

   167 

   168 // Extracts information from *.script and *.ini files to the appropriate member variables.

   169 

   170 TInt TTestActionSpec::TEFInit(RFs& aFs, 

   171 						   const TDesC8& aInput,

   172 						   const TDesC8& aTestCaseID,

   173 						   TDesC8& aPrevTestCaseID,

   174 						   TBool& tefFile,

   175 						   TBool& runtest,

   176 						   TBool& inifile,

   177 						   TDes8& aScriptResult,

   178 						   TDes8& aActionType,

   179 						   const TDesC& aScriptPath,

   180 						   CConsoleBase& /*aConsole*/,

   181 						   Output& aOut)

   182 	{

   183 	

   184 	TInt 		err = KErrNone;

   185 	TInt 		actionTypePos=3;

   186 	TBool 		scriptactionResultSet = EFalse;

   187 //	TBool 		iniactionResultSet = EFalse;

   188 	TBuf8<512> 	prevTestCaseID;

   189 	TBuf8<512> 	prevTestDescription;

   190 

   191 

   192 	

   193 // Checks if the first word from the script file is an error code

   194 // if(error code)

   195 //		sets 'actionResult' to the relevent error code with the <return></return> tags

   196 

   197 	TPtrC8 firstWord = Tefinput::ParseNthElement(aInput,1, err);

   198 	if(err == KErrNone)

   199 		{

   200 		TInt tmpno;

   201 		TLex8 lex8(firstWord); 

   202 		err = lex8.Val(tmpno);			

   203 		if(err != KErrNone)

   204 			{

   205 			actionTypePos = 4;

   206 			err = Tefinput::ParseActionResult(firstWord, aScriptResult);

   207 			scriptactionResultSet = ETrue;

   208 			}

   209 		}

   210 	

   211 //1. Extracts the .ini file name from the .script file

   212 //2. Reads in the [section] name from the .script file

   213 //3. Generates  .ini path from .script file path and .ini file name

   214 //4. Sets iActionBody with the info from .ini file

   215 	

   216 	TBuf<KMaxPath + KMaxFileName> 	iniFilePath;

   217 	TBuf<512> 						iniFileData;

   218 	TPtrC8 							iniSectionData;

   219 	

   220 	

   221 	TPtrC8 iniFileName = Tefinput::ParseNthElement(aInput,actionTypePos+1,err);

   222 	if(err == KErrNone)

   223 		{

   224 		TPtrC8 iniSectionName = Tefinput::ParseNthElement(aInput,actionTypePos+2,err);

   225 		if(err == KErrNone)

   226 			{

   227 			err = Tefinput::ParseiniPath(iniFileName, aScriptPath, iniFilePath);

   228 			if(err == KErrNone)

   229 				{

   230 				aTestIniFilePtr.Assign(Tefinput::GetiniFile(aFs, iniFilePath, err)); // Load up our local RBuf ptr to takeover the management of the inifile data in Heap

   231 				

   232 				if(err == KErrNone)

   233 					{

   234 					TPtrC8 iniFile = aTestIniFilePtr.Ptr();

   235 					inifile = ETrue;

   236 					err = Tefinput::ParseActionbody(iniFile, iniSectionName, iniSectionData);

   237 					if(err == KErrNone)

   238 						{

   239 						TInt pos = 0;

   240 						iActionBody.Set(Input::ParseElement(iniSectionData, KActionBodyStart, KActionBodyEnd, pos, err));

   241 						if (err == KErrNotFound)

   242 							{

   243 							aOut.writeString(_L("Error couldn't find actionbody in test case spec"));

   244 							aOut.writeNewLine();

   245 							return err;

   246 							}

   247 						}

   248 					}

   249 				else

   250 					{

   251 					inifile = EFalse;

   252 					}

   253 				}

   254 			}

   255 		}

   256 	else

   257 		{

   258 		inifile = EFalse;

   259 		}

   260 		

   261 	TInt pos = 0;

   262 

   263 // Extracts info b/w <actionresult> </actionresult> tags

   264 // 	Sets iActionResult with info both from .script and .ini file

   265 	TPtrC8 tempResult;

   266 	TPtrC8 scriptResult;

   267 	TInt resultlen ;

   268 	

   269 	if(scriptactionResultSet)

   270 		{

   271 		scriptResult.Set(aScriptResult);

   272 		tempResult.Set(Input::ParseElement(iniSectionData, KActionResultStart, KActionResultEnd, pos, err));

   273 		if (err == KErrNone)

   274 			{

   275 			resultlen = scriptResult.Length() + tempResult.Length();

   276 			iniSectionResultBody.Create(tempResult,resultlen);

   277 			iniSectionResultBody.Insert(0,scriptResult);			

   278 			iActionResult.Set(iniSectionResultBody);

   279 //			iniactionResultSet = ETrue;

   280 			}

   281 		else

   282 			{

   283 			iniSectionResultBody.Create(scriptResult);

   284 			iActionResult.Set(iniSectionResultBody);

   285 			}

   286 		}

   287 	else

   288 		{

   289 		tempResult.Set(Input::ParseElement(iniSectionData, KActionResultStart, KActionResultEnd, pos, err));

   290 		err = Tefinput::GetActionResult(KErrNone, aScriptResult);

   291 		if(err == KErrNone)

   292 			{

   293 			scriptResult.Set(aScriptResult);

   294 			resultlen = tempResult.Length() + scriptResult.Length();

   295 			iniSectionResultBody.Create(tempResult, resultlen);

   296 			iniSectionResultBody.Insert(0,aScriptResult);

   297 			iActionResult.Set(iniSectionResultBody);

   298 			}

   299 		else

   300 			{

   301 			iniSectionResultBody.Create(tempResult);

   302 			iActionResult.Set(iniSectionResultBody);

   303 			}

   304 		}

   305 	

   306 		

   307 //	aPrevTestCaseID = aTestCaseID;

   308 //Sets iActionName with the @SYMTestCaseID

   309 	if(!runtest)

   310 		{

   311 		iActionName.Set(aPrevTestCaseID);

   312 		}

   313 	else

   314 		{

   315 		iActionName.Set(aTestCaseID);

   316 		}

   317 

   318 	

   319 

   320 //Sets iActionType from .script file

   321 	

   322 	TBuf8<512> modifiedType;

   323 	TBuf8<512> modifiedTypeTemp;

   324 	TPtrC8 actionTypeTemp;

   325 	TPtrC8 actionType;

   326 	TPtrC8 TempType;

   327 	

   328 	

   329 	iActionType.Set(Tefinput::ParseNthElement(aInput,actionTypePos,err));

   330 	if (err == KErrNone)

   331 		{

   332 		modifiedType.Copy(iActionType);

   333 		modifiedType.Copy(Tefinput::TrimActionType(modifiedType, aActionType));

   334 

   335 		iActionType.Set(aActionType);

   336 		}

   337 	else

   338 		{

   339 		aOut.writeString(_L("Error couldn't find actiontype in test case spec"));

   340 		aOut.writeNewLine();

   341 		return err;

   342 		}

   343 

   344 	

   345 

   346 	iTefScript = tefFile;

   347 

   348 

   349 	

   350 	

   351 	return KErrNone; 

   352 	}

   353 

   354 

   355 void TTestActionSpec::HardcodedInit(const TDesC8& aInput)

   356 	{

   357 	iActionName.Set(aInput);

   358 	iActionType.Set(KNullDesC8);

   359 	iActionGroup.Set(KNullDesC8);

   360 	iActionBody.Set(KNullDesC8);

   361 	iActionResult.Set(KNullDesC8);

   362 	}
Symaptic