Symaptic: os/persistentdata/loggingservices/eventlogger/test/src/t

     1 // Copyright (c) 2006-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 //

    16 #include <e32test.h>

    17 #include <bautils.h>

    18 #include <e32math.h>

    19 #include "LogServShared.h"

    20 #include "logservcli.h"

    21 #include "t_logutil.h"

    23 ///////////////////////////////////////////////////////////////////////////////////////

    25 RTest TheTest(_L("t_logbadclient test"));

    27 const TInt KTestIterCount = 5000;

    28 const TInt KMaxDesArgLen = 1000;

    29 enum TArgType

    30 	{

    31 	EIntArgType,

    32 	ETextArgType,

    33 	EBinArgType,

    34 	ELastArgType

    35 	};

    37 const TLogServFunction KLogIpcMsgCodes[] =

    38 	{

    39 	ELogOperationCancel, ELogOperationGetResult, ELogOperationInitiate, ELogNotify, ELogNotifyCancel, ELogViewCreate,

    40 	ELogViewDelete, ELogViewCount, ELogViewOperationInitiate, ELogViewChangeNotificationsRequest,

    41 	ELogViewChangeNotificationsCancel, ELogViewFetchChanges, ELogViewNotifyLockStatusChange,

    42 	ELogViewNotifyLockStatusChangeCancel, ELogNotifyExtended, ELogNotifyExtendedCancel, ELogNOTUSED

    43 	};

    45 const TLogOperationType KLogOpTypes[] =

    46 	{

    47 	ELogOperationEventAdd, ELogOperationEventGet, ELogOperationEventChange, ELogOperationEventDelete,

    48 	ELogOperationTypeAdd, ELogOperationTypeGet, ELogOperationTypeChange, ELogOperationTypeDelete,

    49 	ELogOperationClearLog,  ELogOperationClearRecent, ELogOperationConfigGet,  ELogOperationConfigChange,

    50 	ELogOperationMaintain, ELogOperationViewSetup, ELogOperationViewRemoveEvent, ELogOperationViewClearDuplicates,

    51 	ELogOperationViewSetFlags, ELogOperationViewWindowFetch, (TLogOperationType)-100

    52 	};

    54 //////////////////////////////////////////////////////////////////////////////////////

    56 //If the LogEng server crashes and the test receives KErrServerTerminated error, then the

    57 //next set will contain the last:

    58 // - iteration number;

    59 // - function code;

    60 // - IPC arguments values;

    61 struct TThreadData

    62 	{

    63 	TInt				iIteration;

    64 	TInt 				iFunction;

    65 	TArgType 			iArgType[KMaxMessageArguments];

    66 	TInt 				iIntArg[KMaxMessageArguments];

    67 	TBuf<KMaxDesArgLen> iTextArg[KMaxMessageArguments];

    68 	TBuf8<KMaxDesArgLen> iBinArg[KMaxMessageArguments];

    69 	TInt64 				iSeed;

    70 	};

    71 //////////////////////////////////////////////////////////////////////////////////////

    73 _LIT(KPanicCategory, "SrvTerm");

    74 _LIT(KPanicCategory2, "InvArg");

    75 const TInt KPanicCode = 1111;

    76 const TInt KPanicCode2 = 2222;

    78 static TLogClientServerData TheLogIpcData;

    79 static TPtrC8 TheLogIpcDataPtr((const TUint8*)&TheLogIpcData, sizeof(TheLogIpcData));

    81 ///////////////////////////////////////////////////////////////////////////////////////

    83 void PrintIterationCount(TInt aIteration)

    84 	{

    85 	if((aIteration % 100) == 0)

    86 		{

    87 		TTime time;

    88 		time.HomeTime();

    89 		TDateTime dt = time.DateTime();

    90 		TBuf<16> tbuf;

    91 		tbuf.Format(_L("%02d:%02d:%02d.%06d"), dt.Hour(), dt.Minute(), dt.Second(), dt.MicroSecond());

    92 		TheTest.Printf(_L("-----[%S] Test iterations: %d\r\n"), &tbuf, aIteration);

    93 		}

    94 	}

    96 //////////////////////////////////////////////////////////////////////////////////////////////////

    97 //////////////////////////////////////////////////////////////////////////////////////////////////

    99 //Worker thread function.

   100 //It behaves as a malicious client. Connects to the LogEng server. In each test iteration generates some random values

   101 //for the function number, handle, handle type, IPC arguments. Then sends a command to the server using these

   102 //randomly generated values. If the server crashes and the thread function receives KErrServerTerminated error,

   103 //then the thread kills itself and the main thread will get KPanicCategory and KPanicCode as a reason for the

   104 //worker thread's death. The last set of randomly generated values will be stored in the memory, pointed by aData argument.

   105 TInt ThreadFunc1(void* aData)

   106 	{

   107 	__UHEAP_MARK;

   109 	CTrapCleanup* tc = CTrapCleanup::New();

   110 	TTEST(tc != NULL);

   112 	TThreadData* p = static_cast <TThreadData*> (aData);

   113 	TTEST(p != NULL);

   114 	TThreadData& data = *p;

   116 	RLogSession sess;

   117 	TInt err = sess.Connect();

   118 	TTEST2(err, KErrNone);

   120 	while(++data.iIteration <= KTestIterCount)

   121 		{

   122 		TIpcArgs args;

   123 		const TInt KFnCnt = sizeof(KLogIpcMsgCodes) / sizeof(KLogIpcMsgCodes[0]);

   124 		TInt fnIdx = Math::Rand(data.iSeed) % KFnCnt;

   125 		data.iFunction = KLogIpcMsgCodes[fnIdx];

   126 		PrintIterationCount(data.iIteration);

   127 		for(TInt argIdx=0;argIdx<KMaxMessageArguments;++argIdx)

   128 			{

   129 			//Initialize arguments

   130 			data.iArgType[argIdx] = EBinArgType;

   131 			if(argIdx > 0)

   132 				{

   133 				data.iArgType[argIdx] = static_cast <TArgType> (Math::Rand(data.iSeed) % ELastArgType);

   134 				}

   135 			switch(data.iArgType[argIdx])

   136 				{

   137 				case EIntArgType:

   138 					data.iIntArg[argIdx] = Math::Rand(data.iSeed) % 9711;

   139 					args.Set(argIdx, data.iIntArg[argIdx]);

   140 					break;

   141 				case ETextArgType:

   142 					{

   143 					TInt len = Math::Rand(data.iSeed) % KMaxDesArgLen;

   144 					data.iTextArg[argIdx].SetLength(len);

   145 					args.Set(argIdx, &data.iTextArg[argIdx]);

   146 					}

   147 					break;

   148 				case EBinArgType:

   149 					{

   150 					if(argIdx == 0)

   151 						{

   152 						//The operations ids are guaranteed to be sequential by logeng.dll implementation.

   153 						TheLogIpcData.iOperationId = data.iIteration;

   154 						//if(Math::Rand(data.iSeed) & 1)

   155 						//	{

   156 						//	TheLogIpcData.iOperationId = 0;

   157 						//	}

   158 						const TInt KTypeCnt = sizeof(KLogOpTypes) / sizeof(KLogOpTypes[0]);

   159 						TInt typeIdx = Math::Rand(data.iSeed) % KTypeCnt;

   160 						TheLogIpcData.iOperationType = KLogOpTypes[typeIdx];

   161 						TheLogIpcData.iDataSlot1 = Math::Rand(data.iSeed);

   162 						TheLogIpcData.iDataSlot2 = Math::Rand(data.iSeed);

   163 						args.Set(argIdx, &TheLogIpcDataPtr);

   164 						}

   165 					else

   166 						{

   167 						TInt len = Math::Rand(data.iSeed) % KMaxDesArgLen;

   168 						data.iBinArg[argIdx].SetLength(len);

   169 						args.Set(argIdx, &data.iBinArg[argIdx]);

   170 						}

   171 					}

   172 					break;

   173 				default:

   174 					User::Panic(KPanicCategory2, KPanicCode2);

   175 					break;

   176 				}

   177 			}

   178 		//Send arguments

   179 		//RDebug::Print(_L("##data.iFunction=%d\r\n"), data.iFunction);

   180 		TRequestStatus stat;

   181 		sess.Send(data.iFunction, args, stat);

   182 		if(stat.Int() == KErrServerTerminated)

   183 			{

   184 			User::Panic(KPanicCategory, KPanicCode);

   185 			}

   186 		else if(stat.Int() == KRequestPending)

   187 			{

   188 			if(data.iFunction == ELogOperationInitiate)

   189 				{

   190 				//RDebug::Print(_L("##ELogOperationGetResult\r\n"));

   191 				err = sess.Send(ELogOperationGetResult, args);

   192 				if(err == KErrServerTerminated)

   193 					{

   194 					User::Panic(KPanicCategory, KPanicCode);

   195 					}

   196 				}

   197 			else

   198 				{

   199 				//Give some time to the LogEng server to do something with that async request, then cancel it.

   200 				//Otherwise, on a multi-core hardware, the LogEnd server will end up with a long queue of

   201 				//pending requests, not cleared if the client side thread is panic'd. It will be a complete chaos.

   202 				//RDebug::Print(_L("##data.iFunction=%d, wait and cancel async request\r\n"), data.iFunction);

   203 				User::After(100000);

   204 				TRequestStatus* s = &stat;

   205 				User::RequestComplete(s, KErrCancel);

   206 				}

   207 			//RDebug::Print(_L("##---err=%d\r\n"), err);

   208 			}

   209 		}

   211 	sess.Close();

   213 	delete tc;

   215 	__UHEAP_MARKEND;

   217 	return KErrNone;

   218 	}

   220 //////////////////////////////////////////////////////////////////////////////////////////////////

   221 //////////////////////////////////////////////////////////////////////////////////////////////////

   223 //Thread function to detect a crash in the server.

   224 //The server should run for the duration of the test.

   225 // return KErrAbort: If failure to start server

   226 // return KErrServerTerminated: If server process is terminated

   228 TInt ServerWatcherFunc(TAny* /*aData*/)

   229 	{

   230 	__UHEAP_MARK;

   232 	_LIT(KLogEngServerName,"LogServ*");

   234 	TInt err;

   236 	// Start the server if not already running

   237 	RLogSession sess;

   238 	err = sess.Connect();

   239 	if (err != KErrNone)

   240 		return KErrAbort;

   241 	sess.Close();

   243 	TFindProcess findProcess(KLogEngServerName);

   244 	TFullName result;

   245 	if ( findProcess.Next(result) != KErrNone )

   246 		return KErrAbort;

   248 	RProcess server;

   249 	if( server.Open(findProcess, EOwnerProcess) != KErrNone)

   250 		return KErrAbort;

   252 	TRequestStatus status;

   253 	server.Logon(status);

   254  	User::WaitForRequest(status);

   256 	server.Close();

   258 	__UHEAP_MARKEND;

   260 	return KErrServerTerminated;

   261 	}

   264 /**

   265 @SYMTestCaseID			PDS-LOGENG-UT-4045

   266 @SYMTestCaseDesc		In a loop, where the loop iterations are less than KTestIterCount (5000 at the moment),

   267 						the test creates a worker thread, which will behave as a malicious client.

   268 						If the worker thread crashes the LogEng server, then the worker thread

   269 						dies notifying the main thread about the LogEng server crash. The main thread prints the

   270 						values used in the last IPC call and crashes the test.

   271 @SYMTestPriority		High

   272 @SYMTestActions			LogEng, Malicious client simulation test.

   273 @SYMTestExpectedResults Test must not fail

   274 @SYMREQ					REQ12746

   275 */

   276 void BadClientTest()

   277 	{

   278 	// Start a thread to watch the server process

   279 	RThread serverWatcher;

   280 	TInt err = serverWatcher.Create(_L("ServerWatcher"), &ServerWatcherFunc, 0x2000, 0x1000, 0x10000, NULL, EOwnerProcess);

   281 	TRequestStatus serverStatus;

   282 	serverWatcher.Logon(serverStatus);

   283 	serverWatcher.Resume();

   285 	TThreadData* p = new TThreadData;

   286 	TEST(p != NULL);

   287 	TThreadData& data = *p;

   288 	data.iFunction = 0;

   289 	TTime now;

   290 	now.UniversalTime();

   291 	data.iSeed = now.Int64();

   293 	for(data.iIteration=0;data.iIteration<KTestIterCount;++data.iIteration)

   294 		{

   295 		PrintIterationCount(data.iIteration);

   297 		//Run the malicious client (one test thread which will try to crash the LogEng server)

   298 		User::After(200000);

   299 		_LIT(KTestThreadName, "TLBCThr");

   300 		RThread thread;

   301 		err = thread.Create(KTestThreadName, &ThreadFunc1, 0x2000, 0x1000, 0x10000, &data, EOwnerProcess);

   302 		if(err == KErrAlreadyExists)

   303 			{

   304 			TheTest.Printf(_L("##Iteration %d. Function %d. Thread \"%S\" already exists!\r\n"), data.iIteration, data.iFunction, &KTestThreadName);

   305 			for(TInt i=0;i<KMaxMessageArguments;++i)

   306 				{

   307 				TheTest.Printf(_L("##Arg %d, Type %d\r\n"), i + 1, data.iArgType[i]);

   308 				switch(data.iArgType[i])

   309 					{

   310 					case EIntArgType:

   311 					    TheTest.Printf(_L("Integer, value=%d\r\n"), data.iIntArg[i]);

   312 						break;

   313 					case ETextArgType:

   314 					    TheTest.Printf(_L("Text, length=%d\r\n"), data.iTextArg[i].Length());

   315 						break;

   316 					case EBinArgType:

   317 					    TheTest.Printf(_L("Binary, length=%d\r\n"), data.iBinArg[i].Length());

   318 						break;

   319 					default:

   320 					    TheTest.Printf(_L("Invalid argument type: %d\r\n"), data.iArgType[i]);

   321 						break;

   322 					}

   323 				}

   324 			break;

   325 			}

   326 		TEST2(err, KErrNone);

   327 		User::SetJustInTime(EFalse);

   328 		TRequestStatus status;

   329 		thread.Logon(status);

   330 		TEST2(status.Int(), KRequestPending);

   331 		thread.Resume();

   332 		User::WaitForRequest(status, serverStatus);

   334 		// If the Server has crashed then we must fail

   335 		if (serverStatus != KRequestPending)

   336 			{

   337 			TheTest.Printf(_L("##Iteration=%d, Function=%d, Status=%d, Server Status=%d\r\n"), data.iIteration, data.iFunction, status.Int(), serverStatus.Int());

   338 			}

   340 		TExitType exitType = thread.ExitType();

   341 		TInt exitReason = thread.ExitReason();

   342 		thread.Close();

   343 		User::SetJustInTime(ETrue);

   345 		if(exitType == EExitPanic || serverStatus != KRequestPending)

   346 			{

   347 			if(exitReason == KPanicCode || serverStatus != KRequestPending)

   348 				{

   349 				TheTest.Printf(_L("##Server terminated!\r\n"));

   350 				TheTest.Printf(_L("##Iteration=%d, Function=%d, iOperationType=%d, iDataSlot1=%d, iDataSlot2=%d\r\n"),

   351 						data.iIteration, data.iFunction,

   352 						TheLogIpcData.iOperationType,

   353 						TheLogIpcData.iDataSlot1,

   354 						TheLogIpcData.iDataSlot2);

   355 				for(TInt i=0;i<KMaxMessageArguments;++i)

   356 					{

   357 					TheTest.Printf(_L("##Arg %d, Type %d\r\n"), i + 1, data.iArgType[i]);

   358 					switch(data.iArgType[i])

   359 						{

   360 						case EIntArgType:

   361 						    TheTest.Printf(_L("Integer, value=%d\r\n"), data.iIntArg[i]);

   362 							break;

   363 						case ETextArgType:

   364 						    TheTest.Printf(_L("Text, length=%d\r\n"), data.iTextArg[i].Length());

   365 							break;

   366 						case EBinArgType:

   367 						    TheTest.Printf(_L("Binary, length=%d\r\n"), data.iBinArg[i].Length());

   368 							break;

   369 						default:

   370 						    TheTest.Printf(_L("Invalid argument type: %d\r\n"), data.iArgType[i]);

   371 							break;

   372 						}

   373 					}

   374 				TEST(0);

   375 				}

   376 			}

   377 		}//for

   378 	delete p;

   380 	// Check to see if the server crashed and not detected by client

   381 	TEST(serverStatus.Int() == KRequestPending);

   382 	serverWatcher.Kill(KErrCancel);

   383 	serverWatcher.Close();

   385 	}

   387 /**

   388 @SYMTestCaseID			PDS-LOGENG-UT-4044

   389 @SYMTestCaseDesc		LogEng server startup - file I/O error simulation test.

   390 						The test case shuts down the LogEng server in debug mode.

   391 						Then attempts to connect to the server in a file I/O error simulation

   392 						loop.

   393 @SYMTestPriority		High

   394 @SYMTestActions			LogEng server startup - file I/O error simulation test.

   395 @SYMTestExpectedResults Test must not fail

   396 @SYMREQ					REQ12746

   397 */

   398 void LogEngSrvStartupFileIoErrTest()

   399 	{

   400 	//Shut down the server if it is running

   401 	RLogSession sess;

   402 	TInt err = sess.Connect();

   403 	TEST2(err, KErrNone);

   405 	err = sess.Send(ELogMakeTransient, TIpcArgs(1));

   406 	TEST2(err, KErrNone);

   407 	sess.Close();

   409 	//The shutdown delay is 2 seconds (defined in LogServShutdownTimer.h file). In this csase 5 seconds is more than enough.

   410 	User::After(5000000);

   412 	RFs fs;

   413 	err = fs.Connect();

   414 	TEST2(err, KErrNone);

   416 	TBool finished = EFalse;

   417 	TInt failCount = 0;

   419 	while(!finished)

   420 		{

   421 		fs.SetErrorCondition(KErrCorrupt, ++failCount);

   422 		TInt err = sess.Connect();

   423 		fs.SetErrorCondition(KErrNone, 0);

   424 		sess.Close();

   425 		if(err == KErrNone)

   426 			{

   427 			finished = ETrue;

   428 			}

   429 		else

   430 			{

   431 			TEST2(err, KErrCorrupt);

   432 			}

   433 		}

   435 	fs.Close();

   436 	TheTest.Printf(_L("===LogEng Server Startup File I/O error simularion test succeeded at iteration %d\n"), failCount);

   437 	}

   439 void DoTests()

   440 	{

   441 	TheTest.Start(_L(" @SYMTestCaseID:PDS-LOGENG-UT-4045: Bad client test"));

   442 	BadClientTest();

   443 #ifdef _DEBUG

   444 	TheTest.Next(_L(" @SYMTestCaseID:PDS-LOGENG-UT-4044: LogEng Server Startup - File I/O error simulation test"));

   445 	LogEngSrvStartupFileIoErrTest();

   446 #endif

   447 	}

   449 TInt E32Main()

   450 	{

   451 	TheTest.Title();

   453 	CTrapCleanup* tc = CTrapCleanup::New();

   455 	__UHEAP_MARK;

   457 	DoTests();

   459 	__UHEAP_MARKEND;

   461 	TheTest.End();

   462 	TheTest.Close();

   464 	delete tc;

   466 	User::Heap().Check();

   467 	return KErrNone;

   468 	}

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200
changeset 1	260cb5ec6c19
permissions	-rw-r--r--