Symaptic: os/ossrv/lowlevellibsandfws/pluginfw/Framework/NotificationTest/t

     1 // Copyright (c) 2003-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 <ecom/ecom.h>

    18 #include <f32file.h>

    19 #include <e32base.h>

    20 #include <bautils.h>

    21 #include <e32ldr.h>

    23 #include "../EcomTestUtils/EcomTestUtils.h"

    24 #include "HeapTestInterface.h"

    26 LOCAL_D RTest TheTest(_L("t_ecomcancel"));

    27 LOCAL_D RFs TheFs;

    29 const TInt KWaitDuration = 30000000; // retry delay in usecs

    31 _LIT(KHTI_PluginAtRootOfZ,  "z:\\HeapTestImpl.dll");

    32 _LIT(KHTI_PluginAtRootOfC,  "c:\\HeapTestImpl.dll");

    33 _LIT(KHTIr_PluginAtRootOfZ, "z:\\HeapTestImpl.rsc");

    34 _LIT(KHTIr_PluginAtRootOfC, "c:\\HeapTestImpl.rsc");

    35 _LIT(KHTI_PluginInstalledOnC,  "c:\\sys\\bin\\HeapTestImpl.dll");

    36 _LIT(KHTIr_PluginInstalledOnC, "c:\\resource\\plugins\\HeapTestImpl.rsc");

    38 _LIT(KExample5DllOnC, "C:\\sys\\bin\\EComExample5.dll");

    39 _LIT(KExample5DllOnZ, "z:\\RAMOnly\\EComExample5.dll");

    40 _LIT(KExample5RscOnC, "C:\\resource\\plugins\\EComExample5.rsc");

    41 _LIT(KExample5RscOnZ, "z:\\RAMOnly\\EComExample5.rsc");

    42 _LIT(KExample5TmpRscOnC, "C:\\resource\\plugins\\EComExample5tmp.rsc");

    44 void CleanupFiles()

    45 	{

    46 	TRAPD(ignoreErr, EComTestUtils::FileManDeleteFileL(KHTI_PluginInstalledOnC));

    47 	TRAP(ignoreErr, EComTestUtils::FileManDeleteFileL(KHTIr_PluginInstalledOnC));

    49 	TRAP(ignoreErr, EComTestUtils::FileManDeleteFileL(KExample5TmpRscOnC));

    50 	TRAP(ignoreErr, EComTestUtils::FileManDeleteFileL(KExample5RscOnC));

    51 	TRAP(ignoreErr, EComTestUtils::FileManDeleteFileL(KExample5DllOnC));

    53 	WAIT_FOR3s;

    54 	}

    56 //

    57 //

    58 //Test macroses and functions

    59 LOCAL_C void Check(TInt aValue, TInt aLine)

    60 	{

    61 	if(!aValue)

    62 		{

    63 		::CleanupFiles();

    64 		TheTest(EFalse, aLine);

    65 		}

    66 	}

    67 LOCAL_C void Check(TInt aValue, TInt aExpected, TInt aLine)

    68 	{

    69 	if(aValue != aExpected)

    70 		{

    71 		RDebug::Print(_L("*** Expected error: %d, got: %d\r\n"), aExpected, aValue);

    72 		::CleanupFiles();

    73 		TheTest(EFalse, aLine);

    74 		}

    75 	}

    76 #define TEST(arg) ::Check((arg), __LINE__)

    77 #define TEST2(aValue, aExpected) ::Check(aValue, aExpected, __LINE__)

    78 //

    79 //

    82 // Setup files for test

    83 void SetUpPlugins()

    84 	{

    86 	TInt err;

    87 	TRAP(err, EComTestUtils::FileManCopyFileL(KHTI_PluginAtRootOfZ, KHTI_PluginAtRootOfC));

    88 	TEST2(err, KErrNone);

    89 	TRAP(err, EComTestUtils::FileManCopyFileL(KHTIr_PluginAtRootOfZ, KHTIr_PluginAtRootOfC));

    90 	TEST2(err, KErrNone);

    91 	TRAP(err, EComTestUtils::FileManCopyFileL(KHTI_PluginAtRootOfZ, KHTI_PluginInstalledOnC));

    92 	TEST2(err, KErrNone);

    93 	TRAP(err, EComTestUtils::FileManCopyFileL(KHTIr_PluginAtRootOfZ, KHTIr_PluginInstalledOnC));

    94 	TEST2(err, KErrNone);

    95 	WAIT_FOR3s;

    97 	}

    99 // Copying plugin to the RAM for test purposes

   100 void CopyTestPlugin()

   101 	{

   102 	TRAPD(err, EComTestUtils::FileManCopyFileL(KExample5RscOnZ, KExample5RscOnC));

   103 	TEST2(err, KErrNone);

   104 	TRAP(err, EComTestUtils::FileManCopyFileL(KExample5DllOnZ, KExample5DllOnC));

   105 	TEST2(err, KErrNone);

   106 	WAIT_FOR3s;

   107 	}

   109 void ResetEComEnvironmentL()

   110 	{

   111     ECOMTU_KILL_SERVER_L(TheTest);

   112 	}

   115 /**

   116 @SYMTestCaseID          SYSLIB-ECOM-CT-0657

   117 @SYMTestCaseDesc	    De-Registering for notification of messages test

   118                         Test for REComSession class

   119 @SYMTestPriority 	    High

   120 @SYMTestActions  	    Test for no side effects on trying to cancel a request that has been already cancelled

   121 						Test for updation of right status value after cancel request.

   122 @SYMTestExpectedResults The test must not fail.

   123 @SYMREQ                 REQ0000

   124 */

   125 void TestCancelL()

   126 	{

   127 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-0657 TestCancelL "));

   129     // Test normal cancelling

   130     REComSession& session = REComSession::OpenL();

   131     TRequestStatus status;

   132     session.NotifyOnChange(status);

   133     session.CancelNotifyOnChange(status);

   134     User::WaitForRequest(status);

   135     TEST(status == KErrCancel);

   136     session.Close();

   138 	// Test no side effects on trying to cancel a request

   139 	//  that has already been cancelled

   140     session = REComSession::OpenL();

   141     session.NotifyOnChange(status);

   142     session.CancelNotifyOnChange(status);

   143     User::WaitForRequest(status);

   144     TEST(status == KErrCancel);

   145     session.CancelNotifyOnChange(status);

   146     session.CancelNotifyOnChange(status);

   147     TEST(status == KErrCancel);

   149 	// Make sure the right status value is updated after a cancel request.

   150     TRequestStatus status1, status2, status3;

   151     session.NotifyOnChange(status);

   152     TEST(status==KRequestPending);

   153     session.NotifyOnChange(status1);

   154     TEST(status1==KRequestPending);

   155     session.NotifyOnChange(status2);

   156     TEST(status2==KRequestPending);

   157     session.NotifyOnChange(status3);

   158     TEST(status3==KRequestPending);

   159     session.CancelNotifyOnChange(status);

   160     User::WaitForRequest(status);

   161     TEST(status==KErrCancel);

   162     session.CancelNotifyOnChange(status3);

   163     session.CancelNotifyOnChange(status2);

   164     User::WaitForRequest(status3);

   165     TEST(status3==KErrCancel);

   166     User::WaitForRequest(status2);

   167     TEST(status2==KErrCancel);

   168     session.CancelNotifyOnChange(status1);

   169     User::WaitForRequest(status1);

   170     TEST(status1==KErrCancel);

   171    	session.Close();

   173 	// Test Ends...

   174 	REComSession::FinalClose();

   175 	}

   178 void SimulateDiskChangeL()

   179 	{

   180 	// Set up for heap leak checking

   181 	__UHEAP_MARK;

   183 	// Make sure the file is not read-only

   184 	TRAPD(err, EComTestUtils::MakeFileWriteableL(KHTI_PluginAtRootOfC));

   185 	TRAP(err, EComTestUtils::MakeFileWriteableL(KHTIr_PluginAtRootOfC));

   187 	// Simulate that the implementation dll is changed - change resouce file timestamp

   188 	RFile file;

   189 	User::LeaveIfError(file.Open(TheFs, KHTIr_PluginAtRootOfC, EFileRead | EFileWrite));

   190 	TTime time;

   191 	User::LeaveIfError(file.Modified(time));

   192 	TTimeIntervalSeconds interval = 100;

   193 	time += interval;

   194 	User::LeaveIfError(file.SetModified(time));

   195 	file.Close();

   197 	// Replace the resource file with the newer version (newer timestamp)

   198 	// The ECOM server will run the discovery process and will unload the old dll

   199 	// and replace it with the newer dll

   200 	TRAP(err, EComTestUtils::FileManCopyFileL(KHTI_PluginAtRootOfC, KHTI_PluginInstalledOnC));

   201 	TEST2(err, KErrNone);

   202 	TRAP(err, EComTestUtils::FileManCopyFileL(KHTIr_PluginAtRootOfC, KHTIr_PluginInstalledOnC));

   203 	TEST2(err, KErrNone);

   205 	WAIT_FOR3s; // wait for copy to complete

   207 	__UHEAP_MARKEND;

   208 	}

   210 // This test step no longer uses bafl to move files as it does not have high

   211 // enough capability - uses CFileMan helper process instead.

   212 void SimulatePluginDeleteBaflL()

   213 	{

   214 	// Set up for heap leak checking

   215 	__UHEAP_MARK;

   217 	// Make sure the file is not read-only

   218 	TRAPD(err, EComTestUtils::MakeFileWriteableL(KExample5DllOnC));

   219 	TRAP(err, EComTestUtils::MakeFileWriteableL(KExample5RscOnC));

   221 	// Delete the plugins

   222 	// The ECOM server will send the notification to its clients for change.

   223 	TRAPD(ignoreErr, EComTestUtils::FileManDeleteFileL(KExample5RscOnC));

   224 	TRAP(ignoreErr, EComTestUtils::FileManDeleteFileL(KExample5DllOnC));

   225 	WAIT_FOR3s;

   227 	__UHEAP_MARKEND;

   228 	}

   230 // This test step no longer uses bafl to move files as it does not have high

   231 // enough capability - uses CFileMan helper process instead.

   232 void SimulatePluginCopyBaflL()

   233 	{

   234 	// Set up for heap leak checking

   235 	__UHEAP_MARK;

   238 	// Make sure the file is not read-only

   239 	TRAPD(err, EComTestUtils::MakeFileWriteableL(KExample5DllOnC));

   240 	TRAP(err, EComTestUtils::MakeFileWriteableL(KExample5RscOnC));

   242 	// Copy the plugins.

   243 	// The ECOM server will send the notification to its clients for change.

   244 	TRAP(err, EComTestUtils::FileManCopyFileL(KExample5RscOnZ, KExample5RscOnC));

   245 	TEST2(err, KErrNone);

   246 	TRAP(err, EComTestUtils::FileManCopyFileL(KExample5DllOnZ, KExample5DllOnC));

   247 	TEST2(err, KErrNone);

   249 	WAIT_FOR5s; // wait for copy to complete

   251 	__UHEAP_MARKEND;

   252 	}

   254 void SimulatePluginDeleteFileManL()

   255 	{

   256 	// Set up for heap leak checking

   257 	__UHEAP_MARK;

   259 	// Make sure the file is read-only

   260 	TRAPD(err, EComTestUtils::MakeFileWriteableL(KExample5DllOnC));

   261 	TRAP(err, EComTestUtils::MakeFileWriteableL(KExample5RscOnC));

   264 	// Delete the plugins.

   265 	// The ECOM server will send the notification to its clients for change.

   266 	TRAP(err, EComTestUtils::FileManDeleteFileL(KExample5RscOnC));

   267 	TRAP(err, EComTestUtils::FileManDeleteFileL(KExample5DllOnC));

   269 	WAIT_FOR5s; // wait for copy to complete

   271 	__UHEAP_MARKEND;

   272 	}

   274 void SimulatePluginCopyFileManL()

   275 	{

   276 	// Set up for heap leak checking

   277 	__UHEAP_MARK;

   279 	// Make sure the file is not read-only

   280 	TRAPD(err, EComTestUtils::MakeFileWriteableL(KExample5DllOnC));

   281 	TRAP(err, EComTestUtils::MakeFileWriteableL(KExample5RscOnC));

   283 	// Copy the plugins.

   284 	// The ECOM server will send the notification to its clients for change.

   285 	TRAP(err, EComTestUtils::FileManCopyFileL(KExample5RscOnZ, KExample5RscOnC));

   286 	TEST2(err, KErrNone);

   287 	TRAP(err, EComTestUtils::FileManCopyFileL(KExample5DllOnZ, KExample5DllOnC));

   288 	TEST2(err, KErrNone);

   290 	WAIT_FOR5s; // wait for copy to complete

   292 	__UHEAP_MARKEND;

   293 	}

   295 void SimulatePluginDeleteRFsL()

   296 	{

   297 	// Set up for heap leak checking

   298 	__UHEAP_MARK;

   300 	// Make sure the file is read-only

   301 	TRAPD(err, EComTestUtils::MakeFileWriteableL(KExample5DllOnC));

   302 	TRAP(err, EComTestUtils::MakeFileWriteableL(KExample5RscOnC));

   304 	// Delete the plugins using RFs.

   305 	// The ECOM server will send the notification to its clients for change.

   306 	TRAP(err, EComTestUtils::RfsDeleteFileL(KExample5RscOnC));

   307 	TRAP(err, EComTestUtils::RfsDeleteFileL(KExample5DllOnC));

   309 	WAIT_FOR5s; // wait for copy to complete

   311 	__UHEAP_MARKEND;

   312 	}

   314 void SimulatePluginReplaceRFsL()

   315 	{

   316 	// Set up for heap leak checking

   317 	__UHEAP_MARK;

   319 	// Make sure the file is not read-only

   320 	TRAPD(err, EComTestUtils::MakeFileWriteableL(KExample5DllOnC));

   322 	// Replace the plugins using RFs.

   323 	// The ECOM server will send the notification to its clients for change.

   324 	TRAP(err, EComTestUtils::RfsReplaceFileL(KExample5RscOnC,KExample5TmpRscOnC));

   325 	TEST2(err, KErrNone);

   327 	WAIT_FOR5s; // wait for operation to complete

   329 	__UHEAP_MARKEND;

   330 	}

   333 /**

   334 @SYMTestCaseID          SYSLIB-ECOM-CT-0658

   335 @SYMTestCaseDesc	    Tests for REComSession::NotifyOnChange() function

   336 @SYMTestPriority 	    High

   337 @SYMTestActions  	    Tests for changing the implementation dll(timestamp change) and checks for the notify status

   338 @SYMTestExpectedResults The test must not fail.

   339 @SYMREQ                 REQ0000

   340 */

   341 void TestNotifyL()

   342 	{

   343 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-0658 TestNotifyL "));

   345 	// Set up for heap leak checking

   346 	__UHEAP_MARK;

   348 	// and leaking thread handles

   349 	TInt startProcessHandleCount;

   350 	TInt startThreadHandleCount;

   351 	TInt endProcessHandleCount;

   352 	TInt endThreadHandleCount;

   354 	// Test Starts...

   355 	RThread thisThread;

   356 	thisThread.HandleCount(startProcessHandleCount, startThreadHandleCount);

   359 	//-----

   360     REComSession& ecomSession = REComSession::OpenL();

   361 	CleanupClosePushL(ecomSession);

   363 	RTimer timer;

   364 	CleanupClosePushL(timer);

   365 	User::LeaveIfError(timer.CreateLocal());

   367 	TRequestStatus timerStatus;

   368 	TRequestStatus notifyStatus;

   370 	// 1st disk change

   371 	// Issue the requests

   372 	timer.After(timerStatus, KWaitDuration);

   373 	ecomSession.NotifyOnChange(notifyStatus);

   375 	// simulate a disk change

   376 	SimulateDiskChangeL();

   378 	User::WaitForAnyRequest();

   380 	TEST(notifyStatus==KErrNone);

   381 	TEST(timerStatus==KRequestPending);

   383 	timer.Cancel();

   385 	// 2nd disk change

   386 	// Issue the requests

   387 	timer.After(timerStatus, KWaitDuration);

   388 	ecomSession.NotifyOnChange(notifyStatus);

   390 	// simulate a disk change

   391 	SimulateDiskChangeL();

   393 	User::WaitForAnyRequest();

   395 	TEST(notifyStatus==KErrNone);

   396 	TEST(timerStatus==KRequestPending);

   398 	timer.Cancel();

   400 	// 3rd disk change

   401 	// Issue the requests

   402 	timer.After(timerStatus, KWaitDuration);

   403 	ecomSession.NotifyOnChange(notifyStatus);

   405 	// simulate a disk change

   406 	SimulateDiskChangeL();

   408 	User::WaitForAnyRequest();

   410 	TEST(notifyStatus==KErrNone);

   411 	TEST(timerStatus==KRequestPending);

   413 	timer.Cancel();

   415 	// 4th disk change

   416 	// Issue the requests

   417 	timer.After(timerStatus, KWaitDuration);

   418 	ecomSession.NotifyOnChange(notifyStatus);

   420 	// simulate a disk change

   421 	SimulateDiskChangeL();

   423 	User::WaitForAnyRequest();

   425 	TEST(notifyStatus==KErrNone);

   426 	TEST(timerStatus==KRequestPending);

   428 	timer.Cancel();

   430 	// 5th disk change

   431 	// Issue the requests

   432 	timer.After(timerStatus, KWaitDuration);

   433 	ecomSession.NotifyOnChange(notifyStatus);

   435 	// simulate a disk change

   436 	SimulateDiskChangeL();

   438 	User::WaitForAnyRequest();

   440 	TEST(notifyStatus==KErrNone);

   441 	TEST(timerStatus==KRequestPending);

   443 	timer.Cancel();

   445 	// 6th disk change

   446 	// Issue the requests

   447 	timer.After(timerStatus, KWaitDuration);

   448 	ecomSession.NotifyOnChange(notifyStatus);

   450 	// simulate a disk change

   451 	SimulateDiskChangeL();

   453 	User::WaitForAnyRequest();

   455 	TEST(notifyStatus==KErrNone);

   456 	TEST(timerStatus==KRequestPending);

   458 	timer.Cancel();

   460 	// 7th disk change

   461 	// Issue the requests

   462 	timer.After(timerStatus, KWaitDuration);

   463 	ecomSession.NotifyOnChange(notifyStatus);

   465 	// simulate a disk change

   466 	SimulateDiskChangeL();

   468 	User::WaitForAnyRequest();

   470 	TEST(notifyStatus==KErrNone);

   471 	TEST(timerStatus==KRequestPending);

   473 	timer.Cancel();

   475 	// 8th disk change

   476 	// Issue the requests

   477 	timer.After(timerStatus, KWaitDuration);

   478 	ecomSession.NotifyOnChange(notifyStatus);

   480 	// simulate a disk change

   481 	SimulateDiskChangeL();

   483 	User::WaitForAnyRequest();

   485 	TEST(notifyStatus==KErrNone);

   486 	TEST(timerStatus==KRequestPending);

   488 	timer.Cancel();

   490 	// 9th disk change

   491 	// Issue the requests

   492 	timer.After(timerStatus, KWaitDuration);

   493 	ecomSession.NotifyOnChange(notifyStatus);

   495 	// simulate a disk change

   496 	SimulateDiskChangeL();

   498 	User::WaitForAnyRequest();

   500 	TEST(notifyStatus==KErrNone);

   501 	TEST(timerStatus==KRequestPending);

   503 	timer.Cancel();

   505 	// 10th disk change

   506 	// Issue the requests

   507 	timer.After(timerStatus, KWaitDuration);

   508 	ecomSession.NotifyOnChange(notifyStatus);

   510 	// simulate a disk change

   511 	SimulateDiskChangeL();

   513 	User::WaitForAnyRequest();

   515 	TEST(notifyStatus==KErrNone);

   516 	TEST(timerStatus==KRequestPending);

   518 	timer.Cancel();

   520 	// 11th disk change

   521 	// Issue the requests

   522 	timer.After(timerStatus, KWaitDuration);

   523 	ecomSession.NotifyOnChange(notifyStatus);

   525 	// simulate a disk change

   526 	SimulatePluginDeleteBaflL();

   528 	User::WaitForAnyRequest();

   530 	TEST(notifyStatus==KErrNone);

   531 	TEST(timerStatus==KRequestPending);

   533 	timer.Cancel();

   535 	//Copy back the deleted plugin for the next test

   536 	CopyTestPlugin();

   538 	// 12th disk change

   539 	// Issue the requests

   540 	timer.After(timerStatus, KWaitDuration);

   541 	ecomSession.NotifyOnChange(notifyStatus);

   543 	// simulate a disk change, but no regigstry data changed

   544 	SimulatePluginCopyBaflL();

   546 	User::WaitForAnyRequest();

   548 	//since the file copied is same as before, no notify will be send

   549 	TEST(notifyStatus==KRequestPending);

   550 	TEST(timerStatus==KRequestPending);

   552 	timer.Cancel();

   555 	// 13th disk change

   556 	// Issue the requests

   557 	timer.After(timerStatus, KWaitDuration);

   558 	ecomSession.NotifyOnChange(notifyStatus);

   560 	// simulate a disk change

   561 	SimulatePluginDeleteFileManL();

   563 	User::WaitForAnyRequest();

   565 	TEST(notifyStatus==KErrNone);

   566 	TEST(timerStatus==KRequestPending);

   568 	timer.Cancel();

   570 	//Copy back the deleted plugin for the next test

   571 	CopyTestPlugin();

   573 	// 14th disk change

   574 	// Issue the requests

   575 	timer.After(timerStatus, KWaitDuration);

   576 	ecomSession.NotifyOnChange(notifyStatus);

   578 	// simulate a disk change

   579 	SimulatePluginCopyFileManL();

   581 	User::WaitForAnyRequest();

   583 	//since the file copied is same as before, no notify will be send

   584 	TEST(notifyStatus==KRequestPending);

   585 	TEST(timerStatus==KRequestPending);

   587 	timer.Cancel();

   590 	// 15th disk change

   591 	// Issue the requests

   592 	timer.After(timerStatus, KWaitDuration);

   593 	ecomSession.NotifyOnChange(notifyStatus);

   595 	// simulate a disk change

   596 	SimulatePluginDeleteRFsL();

   598 	User::WaitForAnyRequest();

   600 	TEST(notifyStatus==KErrNone);

   601 	TEST(timerStatus==KRequestPending);

   603 	timer.Cancel();

   605 	//Copy back the deleted plugin for the next test

   606 	CopyTestPlugin();

   608 	// 16th disk change

   609 	// Issue the requests

   610 	timer.After(timerStatus, KWaitDuration);

   611 	ecomSession.NotifyOnChange(notifyStatus);

   613 	// simulate a disk change

   614 	SimulatePluginReplaceRFsL();

   616 	User::WaitForAnyRequest();

   618 	TEST(notifyStatus==KErrNone);

   619 	TEST(timerStatus==KRequestPending);

   621 	timer.Cancel();

   623 	//Replace back the deleted plugin.

   624 	TRAPD(err, EComTestUtils::FileManCopyFileL(KExample5TmpRscOnC, KExample5RscOnC));

   625 	TEST2(err, KErrNone);

   627 	CleanupStack::PopAndDestroy(&timer);

   628 	CleanupStack::PopAndDestroy(&ecomSession);

   629 	//-----

   631 	// Test Ends...

   632 	REComSession::FinalClose();

   634 	// Check for open handles

   635 	thisThread.HandleCount(endProcessHandleCount, endThreadHandleCount);

   636 	TEST(startThreadHandleCount == endThreadHandleCount);

   638 	__UHEAP_MARKEND;

   640 	}

   642 /**

   643 @SYMTestCaseID          SYSLIB-ECOM-CT-1808

   644 @SYMTestCaseDesc	    Tests the uninstallation of an active plugin

   645 @SYMTestPriority 	    High

   646 @SYMTestActions  	    Creates a plugin implementation and then uninstalls the

   647                         plugin's files from the C: Drive and waits for an ECOM

   648                         notification completion, upon which it deletes the

   649                         plugin.

   650 @SYMTestExpectedResults The test must not fail.

   651 @SYMREQ                 REQ0000

   652 */

   653 void TestUninstallL()

   654 	{

   655 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-1808 TestUninstallL "));

   657 	// Set up for heap leak checking and leaking thread handles

   658 	__UHEAP_MARK;

   659 	TInt startProcessHandleCount;

   660 	TInt startThreadHandleCount;

   661 	TInt endProcessHandleCount;

   662 	TInt endThreadHandleCount;

   663 	RThread thisThread;

   664 	thisThread.HandleCount(startProcessHandleCount, startThreadHandleCount);

   666     // Step 1: Setup the session to ECOM

   667     TInt err = KErrNone;

   668     REComSession& ecomSession = REComSession::OpenL();

   669 	CleanupClosePushL(ecomSession);

   671     // Step 2: Register for ECOM Server notification.

   672 	TRequestStatus notifyStatus;

   673     ecomSession.NotifyOnChange(notifyStatus);

   674 	TEST2(notifyStatus.Int(), KRequestPending);

   676     // Step 3. Create the plugin implementation we will uninstall

   677     TheTest.Printf(_L("CHeapTestInterface::NewL()\n"));

   678     CHeapTestInterface* implPtr = 0;

   679     TRAP(err, implPtr = CHeapTestInterface::NewL());

   680 	TEST2(err, KErrNone);

   682     // Step 4. Simulate the uninstall of the plugin files

   683     TheTest.Printf(_L("Deleting HTI plugin - attempt 1, wait 5s...\n"));

   684   	//TRAP(err, EComTestUtils::FileManDeleteFileL(KHTI_PluginInstalledOnC));

   685   	TRAP(err, EComTestUtils::RLoaderDeleteFileL(KHTI_PluginInstalledOnC));

   686 #if defined(__WINS__) || defined (__WINSCW__)

   687    	TEST2(err, KErrAccessDenied); // DLL File locked under Windows emulator due to it being demand paged

   688    	TheTest.Printf(_L("Error -21 (KErrAccessDenied) expected due to Windows keeping the DLL mapped in the emulator process adress space due to Windows demand paging/virtual memory system\n"));

   689 #elif defined(__EPOC32__)

   690    	TEST2(err, KErrNone); // DLL File not locked on target hardware under SOS

   691 //#else Do no test at all as its an unexpected platform.

   692 #endif

   694  	TRAP(err, EComTestUtils::FileManDeleteFileL(KHTIr_PluginInstalledOnC));

   695    	TEST2(err, KErrNone);

   697     // Step 5. Wait for ECOM Server notification to arrive, with precautionary hang timer.

   698 	RTimer timer;

   699 	CleanupClosePushL(timer);

   700 	User::LeaveIfError(timer.CreateLocal());

   701 	TRequestStatus timerStatus;

   702 	timer.After(timerStatus, KWaitDuration);

   703 	TEST2(timerStatus.Int(), KRequestPending);

   705     TheTest.Printf(_L("Before calling WaitForAnyRequest(): Timer Status: %d; ECOM Notif Status: %d\n"), timerStatus.Int(), notifyStatus.Int());

   706     TheTest.Printf(_L("Checking notification recieved for ECOM Server...\n"));

   707     User::WaitForRequest(timerStatus, notifyStatus);

   709 	TEST2(timerStatus.Int(), KRequestPending);

   710 	TEST2(notifyStatus.Int(), KErrNone);

   711 	timer.Cancel();

   713     // Step 6. Destroy the plugin

   714     TheTest.Printf(_L("DELETE implPtr\n"));

   715     delete implPtr;

   718 	//CleanupStack::PopAndDestroy(&timer);

   719     TheTest.Printf(_L("Test over, cleanup...\n"));

   720    	CleanupStack::PopAndDestroy(&timer);

   721 	CleanupStack::PopAndDestroy(&ecomSession);

   722 	REComSession::FinalClose();

   724 	// Check for open handles

   725 	thisThread.HandleCount(endProcessHandleCount, endThreadHandleCount);

   726 	TEST(startThreadHandleCount == endThreadHandleCount);

   728 	// Test Ends...

   729 	__UHEAP_MARKEND;

   731 	}

   733 void DoTestsL()

   734 	{

   735 	TestNotifyL();

   736 	TestCancelL();

   737     TestUninstallL();

   738 	}

   740 GLDEF_C TInt E32Main()

   741 	{

   742 	__UHEAP_MARK;

   743 	TheTest.Title();

   744 	TheTest.Start(_L("Starting tests..."));

   745 	TInt err = KErrNone;

   746 	TInt r = KErrNone;

   748 	CTrapCleanup* cleanup = CTrapCleanup::New();

   749 	CActiveScheduler* scheduler = new(ELeave)CActiveScheduler;

   750 	CActiveScheduler::Install(scheduler);

   751 	r = TheFs.Connect();

   752 	if (r != KErrNone)

   753 		{

   754 			return r;

   755 		}

   757     // Reset the test environment under textshell in emulator/ROM

   758 	TRAP(err, ResetEComEnvironmentL());

   759 	TEST2(err, KErrNone);

   761 	// Initial setup, runtests, cleanup

   762 	SetUpPlugins();

   763 	CopyTestPlugin();

   764 	TRAP(err,DoTestsL());

   765 	TEST2(err, KErrNone);

   766 	CleanupFiles();

   768     // Reset the environment for next test executable

   769 	TRAP(err, ResetEComEnvironmentL());

   770 	TEST2(err, KErrNone);

   772 	TheFs.Close();

   773 	delete scheduler;

   774 	delete cleanup;

   775 	TheTest.End();

   776 	TheTest.Close();

   778 	__UHEAP_MARKEND;

   779 	return(0);

   780 	}

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