1 // Copyright (c) 2008-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 the License "Symbian Foundation License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 

    17 

    18 /**

    19  @file

    20  @test

    21  @internalComponent - Internal Symbian test code  

    22 */

    23 

    24 #include "t_servicebasestep.h"

    25 #include <apaserverapp.h>

    26 #include <w32std.h>

    27 #include <appfwk_test.h>

    28 #include "testableapalssession.h"

    29 #include "../tef/TNonNative/TNNApp1.h"

    30 

    31 TInt PanicTest(TAny* aOption);

    32 

    33 // RTstServiceApp

    34 

    35 TInt RTstServiceApp::DoTestTransferSessionL(TUid aServiceUid, TBool aPassingFileByHandle, const TDesC& aFileNameWithoutDriveOrPath)

    36 	{ // static

    37 	//create the first session object

    38 	RTstServiceApp appServiceFirst(aServiceUid);

    39 	CleanupClosePushL(appServiceFirst);

    40 	//connecting first session object

    41 	appServiceFirst.ConnectL();

    42 	

    43 	//create the second session object

    44 	RTstServiceApp appServiceSecond(aServiceUid);

    45 	//transfer session for first session object to the second session object

    46 	appServiceSecond.TransferExistingSessionL(appServiceFirst);

    47 	CleanupClosePushL(appServiceSecond);

    48 	

    49 	TRequestStatus requestStatus;

    50 	//request for a service from the second session object

    51 	appServiceSecond.ReceiveTestResult(requestStatus, aPassingFileByHandle, aFileNameWithoutDriveOrPath);

    52 	User::WaitForRequest(requestStatus);

    53 	const TInt result=User::LeaveIfError(requestStatus.Int());

    54 

    55 	CleanupStack::PopAndDestroy(&appServiceSecond);

    56 	CleanupStack::PopAndDestroy(&appServiceFirst);

    57 	User::After(5 * 1000000); //Wait 5sec for Apparc update due to paging

    58 	

    59 	return result;

    60 	}

    61 	

    62 TInt RTstServiceApp::DoTestTransferSessionAndBackL(TUid aServiceUid, TBool aPassingFileByHandle, const TDesC& aFileNameWithoutDriveOrPath)

    63 	{ // static

    64 	//create the first session object

    65 	RTstServiceApp appServiceFirst(aServiceUid);

    66 	CleanupClosePushL(appServiceFirst);

    67 	//connecting first session object

    68 	appServiceFirst.ConnectL();

    69 	

    70 	//create the second session object

    71 	RTstServiceApp appServiceSecond(aServiceUid);

    72 	//transfer session from first session object to the second session object

    73 	appServiceSecond.TransferExistingSessionL(appServiceFirst);

    74 	CleanupClosePushL(appServiceSecond);

    75 	

    76 	//transfer session back to  first session object from the second session object

    77 	appServiceFirst.TransferExistingSessionL(appServiceSecond);

    78 	TRequestStatus requestStatus;

    79 	//request for a service from the first session object

    80 	appServiceFirst.ReceiveTestResult(requestStatus, aPassingFileByHandle, aFileNameWithoutDriveOrPath);

    81 	User::WaitForRequest(requestStatus);

    82 	const TInt result=User::LeaveIfError(requestStatus.Int());

    83 

    84 	CleanupStack::PopAndDestroy(&appServiceSecond);

    85 	CleanupStack::PopAndDestroy(&appServiceFirst);

    86 	User::After(5 * 1000000); //Wait 5sec for Apparc update due to paging

    87 	

    88 	return result;

    89 	}

    90 	

    91 TInt RTstServiceApp::DoTestTransferWithUnconnectedSessionL(TUid aServiceUid, TBool aPassingFileByHandle, const TDesC& aFileNameWithoutDriveOrPath)

    92 	{ // static

    93 	//create the first session object

    94 	RTstServiceApp appServiceFirst(aServiceUid);

    95 	CleanupClosePushL(appServiceFirst);

    96 		

    97 	//create the second session object

    98 	RTstServiceApp appServiceSecond(aServiceUid);

    99 	//transfer session for first session object to the second session object

   100 	appServiceSecond.TransferExistingSessionL(appServiceFirst);

   101 	CleanupClosePushL(appServiceSecond);

   102 	

   103 	TRequestStatus requestStatus;

   104 	//request for a service from the second session object

   105 	appServiceSecond.ReceiveTestResult(requestStatus, aPassingFileByHandle, aFileNameWithoutDriveOrPath);

   106 	User::WaitForRequest(requestStatus);

   107 	const TInt result=User::LeaveIfError(requestStatus.Int());

   108 

   109 	CleanupStack::PopAndDestroy(&appServiceSecond);

   110 	CleanupStack::PopAndDestroy(&appServiceFirst);

   111 	User::After(5 * 1000000); //Wait 5sec for Apparc update due to paging

   112 	

   113 	return result;

   114 	}

   115 	

   116 RTstServiceApp::RTstServiceApp(TUid aServiceUid)

   117 	:iServiceUid(aServiceUid)

   118 	{

   119 	}

   120 

   121 void RTstServiceApp::ConnectL()

   122 	{

   123 	ConnectExistingByNameL(KLitServerName);

   124 	}

   125 

   126 void RTstServiceApp::ReceiveTestResult(TRequestStatus& aRequestStatus, TBool aPassingFileByHandle, const TDesC& aFileNameWithoutDriveOrPath)

   127 	{

   128 	SendReceive(EOpcode_receiveTestResult, TIpcArgs(aPassingFileByHandle, &aFileNameWithoutDriveOrPath), aRequestStatus);

   129 	}

   130 

   131 TUid RTstServiceApp::ServiceUid() const

   132 	{

   133 	return iServiceUid;

   134 	}

   135 

   136 //CT_ServiceBaseStep

   137 	

   138 void CT_ServiceBaseStep::ClosePanicWindowL()

   139 	{

   140 	RWsSession	ws;

   141 	User::LeaveIfError(ws.Connect());

   142 

   143 	TInt wgFocus = ws.GetFocusWindowGroup();

   144 

   145 	const TUint32 KClientHandle = 0xFFFFFFFF;	// Events delivered to this handle are thrown away

   146 	RWindowGroup wg = RWindowGroup(ws);

   147 

   148 	wg.Construct(KClientHandle);

   149 	TInt wgId = wg.Identifier();

   150 

   151 	TWsEvent event;

   152 	event.SetType(EEventKey);

   153 	TKeyEvent *keyEvent = event.Key();

   154 	keyEvent->iCode = EKeyEscape;

   155 	keyEvent->iScanCode = EStdKeyEscape;

   156 	keyEvent->iModifiers = 0;

   157 

   158 	TInt limit = 0;

   159 	for(limit = 0; wgFocus != wgId && (limit < 50); limit++)

   160 		{

   161 		ws.SendEventToAllWindowGroups(event);

   162 		wgFocus = ws.GetFocusWindowGroup();

   163 		RDebug::Print(_L("ClosePanicWindowL() - EKeyEscape sent to Windows Group"));

   164 		}

   165 

   166 	// close everything

   167 	wg.Close();

   168 	ws.Close();

   169 	}

   170 	

   171 void PanicFirstInstanceAfterTransferL()

   172 	{

   173 	TPtrC fullFileName = _L("z:\\private\\101F289C\\GIF.NNA1");

   174 	TPtrC fileNameWithoutDriveOrPath(TParsePtrC(fullFileName).NameAndExt());

   175 	const TUid serviceUid = {0x10207f97};

   176 	

   177 	RTestableApaLsSession apparcServer;

   178 	CleanupClosePushL(apparcServer);

   179 	User::LeaveIfError(apparcServer.Connect());

   180 

   181 	RFs fileServer;

   182 	CleanupClosePushL(fileServer);

   183 	User::LeaveIfError(fileServer.Connect());

   184 	User::LeaveIfError(fileServer.ShareProtected());

   185 

   186 	apparcServer.FlushRecognitionCache();

   187 	

   188 	RFile file;

   189 	CleanupClosePushL(file);

   190 	User::LeaveIfError(file.Open(fileServer, fullFileName, EFileShareReadersOnly|EFileStream|EFileRead));

   191 		

   192 	TThreadId threadId2;

   193 	TRequestStatus requestStatusForRendezvous2;

   194 	User::LeaveIfError(apparcServer.StartDocument(file, threadId2, &requestStatusForRendezvous2));

   195 	User::WaitForRequest(requestStatusForRendezvous2);

   196 	

   197 	//create the first session object

   198 	RTstServiceApp appServiceFirst(serviceUid);

   199 	CleanupClosePushL(appServiceFirst);

   200 	appServiceFirst.ConnectL();

   201 	

   202 	//create the second session object

   203 	RTstServiceApp appServiceSecond(serviceUid);

   204 	//transfer session from first session object to the second session object

   205 	appServiceSecond.TransferExistingSessionL(appServiceFirst);

   206 	CleanupClosePushL(appServiceSecond);

   207 	TRequestStatus requestStatus;

   208 	//request for a service from the first session object

   209 	appServiceFirst.ReceiveTestResult(requestStatus, ETrue, fileNameWithoutDriveOrPath);

   210 	//code should have panicked by now

   211 	User::WaitForRequest(requestStatus);

   212 	const TInt result=User::LeaveIfError(requestStatus.Int());

   213 	

   214 	CleanupStack::PopAndDestroy(&appServiceSecond);

   215 	CleanupStack::PopAndDestroy(&appServiceFirst);

   216 	}

   217 		

   218 void PanicSecondInstanceAfterTransferBackL()

   219 	{

   220 	TPtrC fullFileName = _L("z:\\private\\101F289C\\GIF.NNA1");

   221 	TPtrC fileNameWithoutDriveOrPath(TParsePtrC(fullFileName).NameAndExt());

   222 	const TUid serviceUid = {0x10207f97};

   223 	

   224 	RTstServiceApp appServiceFirst(serviceUid);

   225 	CleanupClosePushL(appServiceFirst);

   226 	appServiceFirst.ConnectL();

   227 	

   228 	RTstServiceApp appServiceSecond(serviceUid);

   229 	//transfer session from first session object to the second session object

   230 	appServiceSecond.TransferExistingSessionL(appServiceFirst);

   231 	CleanupClosePushL(appServiceSecond);

   232 	

   233 	//Transfer ownership back to first instance

   234 	appServiceFirst.TransferExistingSessionL(appServiceSecond);

   235 	

   236 	TRequestStatus requestStatus;

   237 	//request for a service from the first session object

   238 	appServiceSecond.ReceiveTestResult(requestStatus, ETrue, fileNameWithoutDriveOrPath);

   239 	//code should have panicked by now

   240 	User::WaitForRequest(requestStatus);

   241 	const TInt result=User::LeaveIfError(requestStatus.Int());

   242 	

   243 	CleanupStack::PopAndDestroy(&appServiceSecond);

   244 	CleanupStack::PopAndDestroy(&appServiceFirst);

   245 	}

   246 	

   247 TInt PanicTest(TAny* aOption)

   248 	{

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

   250 	if (!trapCleanup)

   251 		{

   252 		return KErrNoMemory;

   253 		}

   254 	TInt option = (TInt)aOption;

   255 	TInt err = KErrNone;	

   256 	if (option == 1)

   257 		{

   258 		TRAP(err, PanicFirstInstanceAfterTransferL());

   259 		}

   260 	else

   261 		{

   262 		TRAP(err, PanicSecondInstanceAfterTransferBackL());

   263 		}

   264 		

   265 	delete trapCleanup;

   266 	return err;

   267 	}	

   268 	

   269 void CT_ServiceBaseStep::OpenFileLC(RFile& aFile, RFs& aFileServer, const TDesC& aFullFileName)

   270 	{

   271 	CleanupClosePushL(aFile);

   272 	User::LeaveIfError(aFile.Open(aFileServer, aFullFileName, EFileShareReadersOnly|EFileStream|EFileRead));

   273 	}

   274 	

   275 /**

   276    @SYMTestCaseID APPFWK-APPARC-0092

   277   

   278    @SYMCR CR1555

   279   

   280    @SYMTestCaseDesc Transfer ownership of session from one instance of RApaAppServiceBase to another

   281   

   282    @SYMTestPriority High

   283   

   284    @SYMTestStatus Implemented

   285    

   286    @SYMTestActions Start the server application.

   287 				   Create an instance of RApaAppServiceBase and connect to server.

   288 				   Create another instance of RApaAppServiceBase and take the ownership of the connected session.

   289 			       Request a service from the second instance.

   290 

   291    @SYMTestExpectedResults Check if request has been serviced correctly.

   292  */	

   293 void CT_ServiceBaseStep::TestServiceAppL(RApaLsSession& aApparcServer, RFs& aFileServer)

   294 	{

   295 	TPtrC fullFileName = _L("z:\\private\\101F289C\\GIF.NNA1");

   296 	TPtrC fileNameWithoutDriveOrPath(TParsePtrC(fullFileName).NameAndExt());

   297 	const TUid serviceUid = {0x10207f97};

   298 

   299 	//Transfer session from one RApaAppServiceBase instance to another and request for service from the latter

   300 	__UHEAP_MARK;

   301 	RFile file;

   302 	OpenFileLC(file, aFileServer, fullFileName);

   303 	TThreadId threadId;

   304 	TRequestStatus requestStatusForRendezvous;

   305 	User::LeaveIfError(aApparcServer.StartDocument(file, threadId, &requestStatusForRendezvous));

   306 	User::WaitForRequest(requestStatusForRendezvous);

   307 	INFO_PRINTF1(_L("App started....\n"));

   308 	TEST(RTstServiceApp::DoTestTransferSessionL(serviceUid, ETrue, fileNameWithoutDriveOrPath) == KCheckPass);

   309   	INFO_PRINTF1(_L("Requested service completed successfully....\n"));					

   310 	CleanupStack::PopAndDestroy(&file);

   311 	__UHEAP_MARKEND;

   312 	}

   313 

   314 /**

   315    @SYMTestCaseID APPFWK-APPARC-0093 APPFWK-APPARC-0095

   316   

   317    @SYMCR CR1555

   318   

   319    @SYMTestCaseDesc Testing if requesting service with the wrong instance will panic

   320   

   321    @SYMTestPriority High

   322   

   323    @SYMTestStatus Implemented

   324    

   325    @SYMTestActions Start the server application.

   326 				   Create two instances of RApaAppServiceBase and connect to server.

   327 				   Request service with the wrong instance(which does not have the session).

   328    

   329    @SYMTestExpectedResults Requesting service with the wrong instance should raise a KERN-EXEC 0 panic.

   330  */	

   331 void CT_ServiceBaseStep::TestPanicWithWrongInstanceL()

   332 	{

   333 	RThread thread;

   334 	TRequestStatus stat;

   335 	TBuf<32> threadNameBuf;

   336 	// Give each thread a unique name to avoid KErrAlreadyExists error on thread creation

   337 	_LIT(KThreadNameFormat, "CT_ServiceBaseStep%d");

   338 	threadNameBuf.Format(KThreadNameFormat, 1);

   339 	

   340 	//Transfer session from one RApaAppServiceBase instance to another and request for service from the first, this should panic with KERN-EXEC 0

   341 	TInt threadCreationVal = thread.Create(threadNameBuf,PanicTest,KDefaultStackSize,0x2000,0x20000,(TAny*)1);

   342 	TEST(threadCreationVal==KErrNone);	

   343 

   344 	TRequestStatus status;

   345 	thread.Logon(status);

   346 	TBool jit =	User::JustInTime();

   347 	User::SetJustInTime(EFalse);

   348 	thread.Resume();

   349 	User::WaitForRequest(status);

   350 

   351 	// we are always expecting the same panic category

   352 	TExitCategoryName category = thread.ExitCategory();

   353 	TEST(category.Compare(_L("KERN-EXEC")) == 0);

   354 	INFO_PRINTF2(_L("Expected exit category:KERN-EXEC, Actual exit category:  '%S'..."), &category);

   355 

   356 	TInt exitReason = thread.ExitReason();

   357 	TEST(exitReason == 0);

   358 	INFO_PRINTF2(_L("Expected exit reason: 0, Actual exit reason:, %d \n"), exitReason);

   359 	

   360 	thread.Close();

   361 	

   362 	threadNameBuf.Format(KThreadNameFormat, 2);

   363 	//Transfer session from one RApaAppServiceBase instance to another and back, request for service from the second instance, this should panic with KERN-EXEC 0

   364 	threadCreationVal = thread.Create(threadNameBuf,PanicTest,KDefaultStackSize,0x2000,0x20000,(TAny*)2);

   365 	TEST(threadCreationVal==KErrNone);	

   366 

   367 	thread.Logon(status);

   368 	User::SetJustInTime(EFalse);

   369 	thread.Resume();

   370 	User::WaitForRequest(status);

   371 

   372 	// we are always expecting the same panic category

   373 	category = thread.ExitCategory();

   374 	TEST(category.Compare(_L("KERN-EXEC")) == 0);

   375 	INFO_PRINTF2(_L("Expected exit category:KERN-EXEC, Actual exit category:  '%S'..."), &category);

   376 	

   377 	exitReason = thread.ExitReason();

   378 	TEST(exitReason == 0);

   379 	INFO_PRINTF2(_L("Expected exit reason: 0, Actual exit reason:, %d \n"), exitReason);

   380 	

   381 	thread.Close();

   382 	User::SetJustInTime(jit);

   383 	ClosePanicWindowL();

   384 	}

   385 	

   386 /**

   387    @SYMTestCaseID APPFWK-APPARC-0094

   388   

   389    @SYMCR CR1555

   390   

   391    @SYMTestCaseDesc Transfer ownership of session from one instance of RApaAppServiceBase to another and transfer back to first instance

   392   

   393    @SYMTestPriority High

   394   

   395    @SYMTestStatus Implemented

   396    

   397    @SYMTestActions	Start the server application.

   398 				    Create an instance of RApaAppServiceBase and connect to server.

   399 				    Create another instance of RApaAppServiceBase and take the ownership of the connected session.

   400 				    Transfer back the ownership to the first instance.

   401 			        Request a service from the first instance.

   402 			        

   403    @SYMTestExpectedResults Check if request has been serviced correctly.

   404  */	

   405 void CT_ServiceBaseStep::TestTransferBackL(RApaLsSession& aApparcServer, RFs& aFileServer)

   406 	{

   407 	TPtrC fullFileName = _L("z:\\private\\101F289C\\GIF.NNA1");

   408 	TPtrC fileNameWithoutDriveOrPath(TParsePtrC(fullFileName).NameAndExt());

   409 	const TUid serviceUid = {0x10207f97};

   410 	

   411 	__UHEAP_MARK;

   412 	RFile file;

   413 	OpenFileLC(file, aFileServer, fullFileName);

   414 	TThreadId threadId;

   415 	TRequestStatus requestStatusForRendezvous;

   416 	User::LeaveIfError(aApparcServer.StartDocument(file, threadId, &requestStatusForRendezvous));

   417 	User::WaitForRequest(requestStatusForRendezvous);

   418 	INFO_PRINTF1(_L("App started....\n"));	

   419 	TEST(RTstServiceApp::DoTestTransferSessionAndBackL(serviceUid, ETrue, fileNameWithoutDriveOrPath) == KCheckPass);

   420   	INFO_PRINTF1(_L("Requested service completed successfully....\n"));						

   421 	CleanupStack::PopAndDestroy(&file);

   422 	__UHEAP_MARKEND;

   423 	}

   424 

   425 /**

   426    @SYMTestCaseID APPFWK-APPARC-0097

   427   

   428    @SYMCR CR1555

   429   

   430    @SYMTestCaseDesc Transfer ownership of session from one instance of RApaAppServiceBase which is not connected to another

   431   

   432    @SYMTestPriority High

   433   

   434    @SYMTestStatus Implemented

   435    

   436    @SYMTestActions	Start the server application.

   437 				    Create an instance of RApaAppServiceBase.

   438 				    Create another instance of RApaAppServiceBase and take the ownership of unconnected session.

   439 				    			        

   440    @SYMTestExpectedResults Check if function leaves with KErrArgument.

   441  */	

   442 void CT_ServiceBaseStep::TestTransferWithUnconnectedSessionL()

   443 	{

   444 	TPtrC fullFileName = _L("z:\\private\\101F289C\\GIF.NNA1");

   445 	TPtrC fileNameWithoutDriveOrPath(TParsePtrC(fullFileName).NameAndExt());

   446 	const TUid serviceUid = {0x10207f97};

   447 	

   448 	__UHEAP_MARK;

   449 	TInt err;

   450 	TRAP(err, RTstServiceApp::DoTestTransferWithUnconnectedSessionL(serviceUid, ETrue, fileNameWithoutDriveOrPath));

   451 	TEST(err == KErrArgument);

   452   	INFO_PRINTF2(_L("Expected error code: -6, Actual error code:, %d \n"), err);						

   453 	__UHEAP_MARKEND;	

   454 	}

   455 	

   456 // CTestStep derived functions

   457 	

   458 CT_ServiceBaseStep::~CT_ServiceBaseStep()

   459 	{

   460 	}

   461 

   462 CT_ServiceBaseStep::CT_ServiceBaseStep()

   463 	{

   464 	SetTestStepName(KT_ServiceBaseStep);

   465 	}

   466 

   467 TVerdict CT_ServiceBaseStep::doTestStepPreambleL()

   468 	{

   469 	SetTestStepResult(EPass);

   470 	return TestStepResult();

   471 	}

   472 

   473 TVerdict CT_ServiceBaseStep::doTestStepPostambleL()

   474 	{

   475 	return TestStepResult();

   476 	}

   477 

   478 TVerdict CT_ServiceBaseStep::doTestStepL()

   479 	{

   480 	INFO_PRINTF1(_L("Test ServiceBase starting....\n"));

   481 

   482 	RTestableApaLsSession apparcServer;

   483 	CleanupClosePushL(apparcServer);

   484 	User::LeaveIfError(apparcServer.Connect());

   485 

   486 	RFs fileServer;

   487 	CleanupClosePushL(fileServer);

   488 	User::LeaveIfError(fileServer.Connect());

   489 	User::LeaveIfError(fileServer.ShareProtected());

   490 

   491 	apparcServer.FlushRecognitionCache();

   492 

   493 	HEAP_TEST_LS_SESSION(apparcServer, 0, DONT_CHECK, TestServiceAppL(apparcServer, fileServer), apparcServer.FlushRecognitionCache());

   494 	HEAP_TEST_LS_SESSION(apparcServer, 0, 0, TestPanicWithWrongInstanceL(), apparcServer.FlushRecognitionCache());

   495 	HEAP_TEST_LS_SESSION(apparcServer, 0, DONT_CHECK, TestTransferBackL(apparcServer, fileServer), apparcServer.FlushRecognitionCache());

   496 	HEAP_TEST_LS_SESSION(apparcServer, 0, 0, TestTransferWithUnconnectedSessionL(), apparcServer.FlushRecognitionCache());

   497 	

   498 	CleanupStack::PopAndDestroy(2, &apparcServer);

   499 

   500 	INFO_PRINTF1(_L("....Test ServiceBase completed!"));

   501 	return TestStepResult();

   502 	}