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

     1 // Copyright (c) 2002-2010 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 <s32file.h>

    17 #include <babackup.h>

    18 #include "t_logutil2.h"

    19 #include <logview.h>

    21 RTest TheTest(_L("t_logbackup"));

    23 CBaBackupSessionWrapper* theBackup = NULL;

    25 /////////////////////////////////////////////////////////////////////////////////////

    26 /////////////////////////////////////////////////////////////////////////////////////

    27 /////////////////////////////////////////////////////////////////////////////////////

    28 #ifdef __WINS__

    30 _LIT(KTestEventDesc, "Event Type Description");

    31 _LIT(KTestRemoteParty, "Remote Party");

    32 _LIT(KTestDirection, "Direction");

    33 const TLogDurationType KTestDurationType = 1;

    34 const TLogDuration KTestDuration = 0x1234;

    35 _LIT(KTestStatus, "Status");

    36 _LIT(KTestSubject, "Subject");

    37 _LIT(KTestNumber, "Number");

    38 const TLogContactItemId KTestContact = 0x1234;

    39 const TLogLink KTestLink = 0x1234;

    40 _LIT8(KTestData, "ABCDEFGH");

    41 _LIT(KTestNumber1, "TheNumber");

    42 _LIT(KTestNumber2, "Changed Number");

    44 class TClientObserverTestReceiver : public MLogClientChangeObserver

    45 	{

    46 public:

    47 	TClientObserverTestReceiver(TBool& aFlag) : iCallCount(0), iFlag(aFlag) { }

    49 public:

    50 	void HandleLogClientChangeEventL(TUid aChangeType, TInt /*aChangeParam1*/, TInt /*aChangeParam2*/, TInt /*aChangeParam3*/)

    51 		{

    52 		++iCallCount;

    53 		iFlag = (aChangeType == KLogClientChangeEventRefreshView);

    54 		}

    55 	inline TInt CallCount() const { return iCallCount; }

    56 	inline void Reset() { iCallCount = 0; iFlag = EFalse; }

    58 private:

    59 	TInt iCallCount;

    60 	TBool& iFlag;

    61 	};

    63 LOCAL_C TBool IsLogOpenL()

    64 	{

    65 	return TestUtils::IsDatabaseOpenL();

    66 	}

    68 /**

    69 @SYMTestCaseID          SYSLIB-LOGENG-CT-0993

    70 @SYMTestCaseDesc	    Tests for a file open

    71 @SYMTestPriority 	    High

    72 @SYMTestActions  	    Check for errors while testing for file open

    73 @SYMTestExpectedResults Test must not fail

    74 @SYMREQ                 REQ0000

    75 */

    76 LOCAL_C void TestLogOpenL()

    77 	{

    78 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0993 "));

    79 	TEST(IsLogOpenL());

    80 	}

    82 /**

    83 @SYMTestCaseID          SYSLIB-LOGENG-CT-0994

    84 @SYMTestCaseDesc	    Tests for file close

    85 @SYMTestPriority 	    High

    86 @SYMTestActions  	    Check for errors while testing for file close

    87 @SYMTestExpectedResults Test must not fail

    88 @SYMREQ                 REQ0000

    89 */

    90 LOCAL_C void TestLogClosedL()

    91 	{

    92 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0994 "));

    93 	TEST(!IsLogOpenL());

    94 	}

    96 LOCAL_C void StartBackupL()

    97 	{

    98 	User::InfoPrint(_L("Backup"));

   100 	TDriveUnit driveUnit(EDriveC);

   101 	TDriveName name = driveUnit.Name();

   103 	TParse parse;

   104 	LEAVE_IF_ERROR(parse.Set(KLogDatabaseName, &name, NULL));

   106 	delete theBackup;

   107 	theBackup = NULL;

   108 	theBackup = CBaBackupSessionWrapper::NewL();

   110 	theBackup->CloseFileL(parse.FullName(), MBackupObserver::EReleaseLockNoAccess);

   111 	User::After(1000000);

   112 	}

   114 LOCAL_C void DeleteLogDatabaseL()

   115 	{

   116 	User::InfoPrint(_L("delete"));

   117 	TestUtils::DeleteDatabaseL(EFalse);

   118 	}

   120 LOCAL_C void EndBackupL()

   121 	{

   122 	delete theBackup;

   123 	theBackup = NULL;

   124 	User::After(1000000);

   125 	}

   127 LOCAL_C void DelayL(TInt aDelay)

   128 	{

   129 	CTestTimer* timer = CTestTimer::NewL();

   130 	timer->After(aDelay);

   131 	CActiveScheduler::Start();

   132 	delete timer;

   133 	}

   136 const TUid KTestEventUid = {0x10005393};

   137 _LIT(KTestEventDesc1, "Event Type Description");

   138 _LIT(KTestEventDesc2, "Changed Event Description");

   140 LOCAL_C void ForceClientImplInstL(CLogClient& aClient)

   141 	{

   142 	CLogEventType* type = CLogEventType::NewL();

   143 	CleanupStack::PushL(type);

   144 	type->SetUid(KTestEventUid);

   145 	type->SetDescription(KTestEventDesc1);

   146 	type->SetLoggingEnabled(ETrue);

   148 	CTestActive* active = new(ELeave)CTestActive;

   149 	CleanupStack::PushL(active);

   150 	aClient.AddEventType(*type, active->iStatus);

   151 	active->StartL();

   152 	CActiveScheduler::Start();

   153 	CleanupStack::PopAndDestroy(2);//type, active

   155 	}

   157 /**

   158 @SYMTestCaseID          SYSLIB-LOGENG-CT-0995

   159 @SYMTestCaseDesc	    Tests for starting and ending the backup session

   160 @SYMTestPriority 	    High

   161 @SYMTestActions  	    Test for file open and close,start and end of the backup session

   162 @SYMTestExpectedResults Test must not fail

   163 @SYMREQ                 REQ0000

   164 */

   165 LOCAL_C void TestLockingL()

   166 	{

   167 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0995 "));

   168 	CLogClient* client = CLogClient::NewL(theFs);

   169 	CleanupStack::PushL(client);

   171 	ForceClientImplInstL(*client);

   174 	DelayL(1000000);

   175 	TestLogOpenL();

   176 	StartBackupL();

   177 	DelayL(1000000);

   179 	TestLogClosedL();

   181 	EndBackupL();

   182 	TestLogOpenL();

   184 	CleanupStack::PopAndDestroy(); // client

   185 	}

   187 /**

   188 @SYMTestCaseID          SYSLIB-LOGENG-CT-0996

   189 @SYMTestCaseDesc	    Tests for deleting the file when its locked

   190 @SYMTestPriority 	    High

   191 @SYMTestActions  	    Attempt for deleting the file when its locked

   192 @SYMTestExpectedResults Test must not fail

   193 @SYMREQ                 REQ0000

   194 */

   195 LOCAL_C void TestDeleteWhileLockedL()

   196 	{

   197 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0996 "));

   198 	CLogClient* client = CLogClient::NewL(theFs);

   199 	CleanupStack::PushL(client);

   200 	ForceClientImplInstL(*client);

   202 	TestLogOpenL();

   203 	StartBackupL();

   204 	DelayL(1000000);

   205 	TestLogClosedL();

   207 	CleanupStack::PopAndDestroy(); // client

   208 	TestLogClosedL();

   210 	client = CLogClient::NewL(theFs);

   211 	CleanupStack::PushL(client);

   212 	ForceClientImplInstL(*client);

   213 	EndBackupL();

   215 	TestLogOpenL();

   216 	StartBackupL();

   217 	DelayL(1000000);

   218 	TestLogClosedL();

   219 	EndBackupL();

   220 	TestLogOpenL();

   222 	CleanupStack::PopAndDestroy(); // client

   223 	}

   225 /**

   226 @SYMTestCaseID          SYSLIB-LOGENG-CT-0997

   227 @SYMTestCaseDesc	    Tests for deleting the view while its locked

   228 @SYMTestPriority 	    High

   229 @SYMTestActions  	    Delete the view when its locked

   230 @SYMTestExpectedResults Test must not fail

   231 @SYMREQ                 REQ0000

   232 */

   233 LOCAL_C void TestDeleteViewWhileLockedL()

   234 	{

   235 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0997 "));

   236 	CLogClient* client = CLogClient::NewL(theFs);

   237 	CleanupStack::PushL(client);

   238 	ForceClientImplInstL(*client);

   240 	CLogFilter* filter = CLogFilter::NewL();

   241 	CleanupStack::PushL(filter);

   243 	CLogViewEvent* view = CLogViewEvent::NewL(*client);

   244 	CleanupStack::PushL(view);

   246 	TestLogOpenL();

   247 	StartBackupL();

   248 	DelayL(1000000);

   249 	TestLogClosedL();

   251 	CleanupStack::PopAndDestroy(3); // view, filter, client

   252 	TestLogClosedL();

   254 	client = CLogClient::NewL(theFs);

   255 	CleanupStack::PushL(client);

   256 	ForceClientImplInstL(*client);

   258 	filter = CLogFilter::NewL();

   259 	CleanupStack::PushL(filter);

   261 	view = CLogViewEvent::NewL(*client);

   262 	CleanupStack::PushL(view);

   263 	EndBackupL();

   265 	TestLogOpenL();

   266 	StartBackupL();

   267 	DelayL(1000000);

   268 	TestLogClosedL();

   269 	EndBackupL();

   270 	TestLogOpenL();

   272 	CleanupStack::PopAndDestroy(3); // view, filter, client

   273 	}

   275 /**

   276 @SYMTestCaseID          SYSLIB-LOGENG-CT-0998

   277 @SYMTestCaseDesc	    Multiple client logging test

   278 @SYMTestPriority 	    High

   279 @SYMTestActions  	    Open multiple clients and test for starting and ending the backup

   280 @SYMTestExpectedResults Test must not fail

   281 @SYMREQ                 REQ0000

   282 */

   283 LOCAL_C void TestMultipleClientLockingL()

   284 	{

   285 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0998 "));

   286 	CLogClient* client1 = CLogClient::NewL(theFs);

   287 	CleanupStack::PushL(client1);

   288 	ForceClientImplInstL(*client1);

   290 	TestLogOpenL();

   292 	CLogClient* client2 = CLogClient::NewL(theFs);

   293 	CleanupStack::PushL(client2);

   294 	ForceClientImplInstL(*client2);

   296 	TestLogOpenL();

   298 	StartBackupL();

   299 	EndBackupL();

   300 	TestLogOpenL();

   302 	StartBackupL();

   303 	TestLogClosedL();

   305 	EndBackupL();

   306 	TestLogOpenL();

   308 	CleanupStack::PopAndDestroy(2); // client1, client2

   309 	}

   311 /**

   312 @SYMTestCaseID          SYSLIB-LOGENG-CT-0999

   313 @SYMTestCaseDesc	    Multiple view locking test

   314 @SYMTestPriority 	    High

   315 @SYMTestActions  	    Open multiple views and test for starting and ending of backup

   316 @SYMTestExpectedResults Test must not fail

   317 @SYMREQ                 REQ0000

   318 */

   319 LOCAL_C void TestMultipleViewLockingL()

   320 	{

   321 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0999 "));

   322 	CLogClient* client = CLogClient::NewL(theFs);

   323 	CleanupStack::PushL(client);

   324 	ForceClientImplInstL(*client);

   326 	CLogFilter* filter = CLogFilter::NewL();

   327 	CleanupStack::PushL(filter);

   329 	CLogViewEvent* view1 = CLogViewEvent::NewL(*client);

   330 	CleanupStack::PushL(view1);

   332 	CLogViewEvent* view2 = CLogViewEvent::NewL(*client);

   333 	CleanupStack::PushL(view2);

   335 	TestLogOpenL();

   336 	StartBackupL();

   337 	TestLogClosedL();

   338 	EndBackupL();

   339 	TestLogOpenL();

   341 	CleanupStack::PopAndDestroy(4); // view2, view1, filter, client

   342 	}

   344 LOCAL_C void DoTestLogL(CLogBase& aClient, TInt aError)

   345 	{

   346 	CTestActive* active = new(ELeave)CTestActive();

   347 	CleanupStack::PushL(active);

   349 	CLogEvent* event = CLogEvent::NewL();

   350 	CleanupStack::PushL(event);

   352 	TTime now;

   353 	now.UniversalTime();

   355 	event->SetEventType(KLogCallEventTypeUid);

   357 	active->StartL();

   358 	aClient.AddEvent(*event, active->iStatus);

   359 	CActiveScheduler::Start();

   360 	TEST2(active->iStatus.Int(), aError);

   362 	if (aError == KErrNone)

   363 		{

   364 		TEST(event->EventType() == KLogCallEventTypeUid);

   365 		TEST(event->Description().Length() > 0);

   366 		TEST(event->Time() >= now);

   367 		now = event->Time();

   368 		}

   369 	else

   370 		{

   371 		// User a dummy id to prevent assertion

   372 		event->SetId(123);

   373 		}

   375 	TLogId id = event->Id();

   377 	event->SetRemoteParty(KTestRemoteParty);

   378 	event->SetDirection(KTestDirection);

   379 	event->SetDurationType(KTestDurationType);

   380 	event->SetDuration(KTestDuration);

   381 	event->SetStatus(KTestStatus);

   382 	event->SetSubject(KTestSubject);

   383 	event->SetNumber(KTestNumber);

   384 	event->SetContact(KTestContact);

   385 	event->SetLink(KTestLink);

   386 	event->SetDataL(KTestData);

   388 	active->StartL();

   389 	aClient.ChangeEvent(*event, active->iStatus);

   390 	CActiveScheduler::Start();

   391 	TEST2(active->iStatus.Int(), aError);

   393 	if (aError == KErrNone)

   394 		{

   395 		TEST(event->Id() == id);

   396 		TEST(event->EventType() == KLogCallEventTypeUid);

   397 		TEST(event->Description().Length() > 0);

   398 		TEST(event->Time() == now);

   399 		TEST(event->RemoteParty() == KTestRemoteParty);

   400 		TEST(event->Direction() == KTestDirection);

   401 		TEST(event->DurationType() == KTestDurationType);

   402 		TEST(event->Duration() == KTestDuration);

   403 		TEST(event->Status() == KTestStatus);

   404 		TEST(event->Subject() == KTestSubject);

   405 		TEST(event->Number() == KTestNumber);

   406 		TEST(event->Contact() == KTestContact);

   407 		TEST(event->Link() == KTestLink);

   408 		TEST(event->Data() == KTestData);

   409 		}

   411 	CleanupStack::PopAndDestroy(); // event;

   413 	event = CLogEvent::NewL();

   414 	CleanupStack::PushL(event);

   416 	event->SetId(id);

   418 	active->StartL();

   419 	aClient.GetEvent(*event, active->iStatus);

   420 	CActiveScheduler::Start();

   421 	TEST2(active->iStatus.Int(), aError);

   423 	if (aError == KErrNone)

   424 		{

   425 		TEST(event->Id() == id);

   426 		TEST(event->EventType() == KLogCallEventTypeUid);

   427 		TEST(event->Description().Length() > 0);

   428 		TEST(event->Time() == now);

   429 		TEST(event->RemoteParty() == KTestRemoteParty);

   430 		TEST(event->Direction() == KTestDirection);

   431 		TEST(event->DurationType() == KTestDurationType);

   432 		TEST(event->Duration() == KTestDuration);

   433 		TEST(event->Status() == KTestStatus);

   434 		TEST(event->Subject() == KTestSubject);

   435 		TEST(event->Number() == KTestNumber);

   436 		TEST(event->Contact() == KTestContact);

   437 		TEST(event->Link() == KTestLink);

   438 		TEST(event->Data() == KTestData);

   439 		}

   441 	active->StartL();

   442 	aClient.DeleteEvent(id, active->iStatus);

   443 	CActiveScheduler::Start();

   444 	TEST2(active->iStatus.Int(), aError);

   446 	active->StartL();

   447 	aClient.GetEvent(*event, active->iStatus);

   448 	CActiveScheduler::Start();

   449 	TheTest.Printf(_L("*** active->iStatus.Int()=%d\n"), active->iStatus.Int());

   450 	TEST(active->iStatus.Int() == aError || active->iStatus.Int() == KErrNotFound);

   452 	CleanupStack::PopAndDestroy(2); // event, active

   453 	}

   455 /**

   456 @SYMTestCaseID          SYSLIB-LOGENG-CT-1000

   457 @SYMTestCaseDesc	    Client requests test

   458 @SYMTestPriority 	    High

   459 @SYMTestActions  	    Tests for client requests when the file is opened and check for no errors

   460 						Tests for client requests when the file is closed and check for access denied errors

   461 						Re-test for client requests when file is opened and check for no errors

   462 @SYMTestExpectedResults Test must not fail

   463 @SYMREQ                 REQ0000

   464 */

   465 LOCAL_C void TestClientRequestsL()

   466 	{

   467 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-1000 "));

   468 	CLogClient* client1 = CLogClient::NewL(theFs);

   469 	CleanupStack::PushL(client1);

   470 	ForceClientImplInstL(*client1);

   472 	TestLogOpenL();

   474 	CLogClient* client2 = CLogClient::NewL(theFs);

   475 	CleanupStack::PushL(client2);

   476 	ForceClientImplInstL(*client2);

   478 	TestLogOpenL();

   480 	DoTestLogL(*client1, KErrNone);

   481 	DoTestLogL(*client2, KErrNone);

   483 	StartBackupL();

   484 	DelayL(1000000);

   485 	TestLogClosedL();

   487 	DoTestLogL(*client1, KErrAccessDenied);

   488 	DoTestLogL(*client2, KErrAccessDenied);

   490 	EndBackupL();

   491 	TestLogOpenL();

   493 	DoTestLogL(*client1, KErrNone);

   494 	DoTestLogL(*client2, KErrNone);

   496 	CleanupStack::PopAndDestroy(2); // client1, client2

   497 	}

   499 /**

   500 @SYMTestCaseID          SYSLIB-LOGENG-CT-1001

   501 @SYMTestCaseDesc	    Tests for notification changes

   502 @SYMTestPriority 	    High

   503 @SYMTestActions  	    Set up for client log notification changes.

   504                         Change the log and unlock the log.Try and change the log again and check for access denied error.

   505 @SYMTestExpectedResults Test must not fail

   506 @SYMREQ                 REQ0000

   507 */

   508 LOCAL_C void TestNotificationsL()

   509 	{

   510 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-1001 "));

   511 	CTestActive* notify = new(ELeave)CTestActive;

   512 	CleanupStack::PushL(notify);

   514 	CTestTimer* timer = CTestTimer::NewL();

   515 	CleanupStack::PushL(timer);

   517 	CLogClient* client = CLogClient::NewL(theFs);

   518 	CleanupStack::PushL(client);

   519 	ForceClientImplInstL(*client);

   520 	EndBackupL();

   522 	// Setup change notification

   523 	notify->StartL();

   524 	client->NotifyChange(10000000, notify->iStatus);

   526 	// Wait a second

   527 	timer->After(1000000);

   528 	CActiveScheduler::Start();

   530 	// Change the log

   531 	DoTestLogL(*client, KErrNone);

   533 	// Unlock the log

   534 	TestLogOpenL();

   535 	StartBackupL();

   536 	DelayL(1000000);

   537 	TestLogClosedL();

   539 	// Try and change the log again

   540 	DoTestLogL(*client, KErrAccessDenied);

   542 	// Make sure the notifier doesn't complete

   543 	timer->After(15000000);

   544 	CActiveScheduler::Start();

   545 	TEST(notify->IsActive());

   547 	// Lock the log

   548 	EndBackupL();

   549 	TestLogOpenL();

   551 	// Wait for notification

   552 	CActiveScheduler::Start();

   553 	TEST(!notify->IsActive());

   555 	// Setup change notification

   556 	notify->StartL();

   557 	client->NotifyChange(10000000, notify->iStatus);

   559 	// Wait a second

   560 	timer->After(1000000);

   561 	CActiveScheduler::Start();

   563 	// Unlock the log

   564 	TestLogOpenL();

   565 	StartBackupL();

   566 	DelayL(1000000);

   567 	TestLogClosedL();

   569 	// Check notification is completed when client destroyed

   570 	TEST(notify->IsActive());

   571 	CleanupStack::PopAndDestroy(client);

   573 	// Wait for notification

   574 	CActiveScheduler::Start();

   575 	TEST(!notify->IsActive());

   576 	TEST2(notify->iStatus.Int(), KErrCancel);

   578 	// Recreate client

   579 	client = CLogClient::NewL(theFs);

   580 	CleanupStack::PushL(client);

   582 	// Setup change notification

   583 	notify->StartL();

   584 	client->NotifyChange(10000000, notify->iStatus);

   586 	// Wait a second

   587 	timer->After(1000000);

   588 	CActiveScheduler::Start();

   590 	// Check notification is completed when cancelled

   591 	TEST(notify->IsActive());

   592 	client->NotifyChangeCancel();

   594 	// Wait for notification

   595 	CActiveScheduler::Start();

   596 	TEST(!notify->IsActive());

   597 	TEST2(notify->iStatus.Int(), KErrCancel);

   599 	// Setup change notification

   600 	notify->StartL();

   601 	client->NotifyChange(10000000, notify->iStatus);

   603 	// Wait a second

   604 	timer->After(1000000);

   605 	CActiveScheduler::Start();

   607 	// Lock the log

   608 	EndBackupL();

   609 	TestLogOpenL();

   611 	// Wait for notification

   612 	TEST(notify->IsActive());

   613 	CActiveScheduler::Start();

   614 	TEST(!notify->IsActive());

   615 	TEST(notify->iStatus >= 0);

   617 	notify->StartL();

   618 	client->NotifyChange(10000000, notify->iStatus);

   620 	// Wait a second

   621 	timer->After(1000000);

   622 	CActiveScheduler::Start();

   624 	// Change the log

   625 	DoTestLogL(*client, KErrNone);

   627 	// Wait for notification

   628 	TEST(notify->IsActive());

   629 	CActiveScheduler::Start();

   630 	TEST(!notify->IsActive());

   631 	TEST(notify->iStatus >= 0);

   633 	CleanupStack::PopAndDestroy(3); // client, timer, notify

   634 	}

   636 /**

   637 @SYMTestCaseID          SYSLIB-LOGENG-CT-1002

   638 @SYMTestCaseDesc	    Tests for request in progress

   639 @SYMTestPriority 	    High

   640 @SYMTestActions  	    Add an event when backup is started and check for access denied error

   641 @SYMTestExpectedResults Test must not fail

   642 @SYMREQ                 REQ0000

   643 */

   644 LOCAL_C void TestRequestInProgressL()

   645 	{

   646 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-1002 "));

   647 	CLogClient* client = CLogClient::NewL(theFs);

   648 	CleanupStack::PushL(client);

   649 	ForceClientImplInstL(*client);

   650 	EndBackupL();

   652 	CTestActive* active = new(ELeave)CTestActive();

   653 	CleanupStack::PushL(active);

   655 	CLogEvent* event = CLogEvent::NewL();

   656 	CleanupStack::PushL(event);

   658 	event->SetEventType(KLogCallEventTypeUid);

   660 	active->StartL();

   661 	client->AddEvent(*event, active->iStatus);

   662 	StartBackupL();

   663 	CActiveScheduler::Start();

   664 	TEST2(active->iStatus.Int(), KErrAccessDenied);

   665 	DelayL(1000000);

   667 	// User a dummy id to prevent assertion

   668 	event->SetId(123);

   670 	EndBackupL();

   671 	active->StartL();

   672 	client->ChangeEvent(*event, active->iStatus);

   673 	StartBackupL();

   675 	CActiveScheduler::Start();

   676 	TEST2(active->iStatus.Int(), KErrAccessDenied);

   677 	DelayL(1000000);

   679 	EndBackupL();

   680 	active->StartL();

   681 	client->GetEvent(*event, active->iStatus);

   682 	StartBackupL();

   684 	CActiveScheduler::Start();

   685 	TEST2(active->iStatus.Int(), KErrAccessDenied);

   686 	DelayL(1000000);

   688 	EndBackupL();

   689 	active->StartL();

   690 	client->DeleteEvent(event->Id(), active->iStatus);

   691 	StartBackupL();

   693 	CActiveScheduler::Start();

   694 	TEST2(active->iStatus.Int(), KErrAccessDenied);

   695 	DelayL(1000000);

   697 	EndBackupL();

   698 	active->StartL();

   699 	client->GetEvent(*event, active->iStatus);

   700 	StartBackupL();

   702 	CActiveScheduler::Start();

   703 	TEST2(active->iStatus.Int(), KErrAccessDenied);

   704 	DelayL(1000000);

   706 	// Check the log is useable

   707 	EndBackupL();

   708 	DoTestLogL(*client, KErrNone);

   710 	CleanupStack::PopAndDestroy(3); // client, event, active

   711 	}

   713 /**

   714 @SYMTestCaseID          SYSLIB-LOGENG-CT-1003

   715 @SYMTestCaseDesc	    Tests for log view when request is in progress

   716 @SYMTestPriority 	    High

   717 @SYMTestActions  	    Add events to the log,set a filter on log view and start the backup session

   718                         and check for the request status for access denied.

   719 @SYMTestExpectedResults Test must not fail

   720 @SYMREQ                 REQ0000

   721 */

   722 LOCAL_C void TestViewRequestInProgressL()

   723 	{

   724 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-1003 "));

   725 	CLogClient* client = CLogClient::NewL(theFs);

   726 	CleanupStack::PushL(client);

   727 	ForceClientImplInstL(*client);

   728 	EndBackupL();

   730 	CTestActive* active = new(ELeave)CTestActive();

   731 	CleanupStack::PushL(active);

   733 	CLogFilter* filter = CLogFilter::NewL();

   734 	CleanupStack::PushL(filter);

   736 	CLogViewEvent* view = CLogViewEvent::NewL(*client);

   737 	CleanupStack::PushL(view);

   739 	CLogEvent* event = CLogEvent::NewL();

   740 	CleanupStack::PushL(event);

   741 	event->SetEventType(KLogCallEventTypeUid);

   743 	active->StartL();

   744 	client->AddEvent(*event, active->iStatus);

   745 	CActiveScheduler::Start();

   746 	TEST2(active->iStatus.Int(), KErrNone);

   748 	active->StartL();

   749 	client->AddEvent(*event, active->iStatus);

   750 	CActiveScheduler::Start();

   751 	TEST2(active->iStatus.Int(), KErrNone);

   753 	TestLogOpenL();

   754 	TEST(view->SetFilterL(*filter, active->iStatus));

   755 	active->StartL();

   756 	StartBackupL();

   758 	CActiveScheduler::Start();

   759 	TEST2(active->iStatus.Int(), KErrAccessDenied);

   760 	DelayL(1000000);

   761 	TestLogClosedL();

   763 	EndBackupL();

   764 	TestLogOpenL();

   766 	TEST(view->SetFilterL(*filter, active->iStatus));

   767 	active->StartL();

   768 	CActiveScheduler::Start();

   769 	TEST2(active->iStatus.Int(), KErrNone);

   771 	TEST(view->NextL(active->iStatus));

   772 	active->StartL();

   773 	StartBackupL();

   775 	CActiveScheduler::Start();

   776 	TEST2(active->iStatus.Int(), KErrAccessDenied);

   777 	DelayL(1000000);

   778 	TestLogClosedL();

   780 	EndBackupL();

   781 	TestLogOpenL();

   783 	TEST(view->SetFilterL(*filter, active->iStatus));

   784 	active->StartL();

   785 	CActiveScheduler::Start();

   786 	TEST2(active->iStatus.Int(), KErrNone);

   788 	TEST(view->NextL(active->iStatus));

   789 	active->StartL();

   790 	CActiveScheduler::Start();

   791 	TEST2(active->iStatus.Int(), KErrNone);

   793 	// Now check a view is no longer valid after a backup

   794 	TEST(view->SetFilterL(*filter, active->iStatus));

   795 	active->StartL();

   796 	CActiveScheduler::Start();

   797 	TEST2(active->iStatus.Int(), KErrNone);

   798 	TEST(view->CountL() > 1);

   800 	StartBackupL();

   801 	EndBackupL();

   803 	DelayL(1000000);

   805 	// Check the view can be setup again

   806 	TEST(view->SetFilterL(*filter, active->iStatus));

   807 	active->StartL();

   808 	CActiveScheduler::Start();

   809 	TEST2(active->iStatus.Int(), KErrNone);

   810 	TEST(view->CountL() > 1);

   812 	TEST(view->NextL(active->iStatus));

   813 	active->StartL();

   814 	CActiveScheduler::Start();

   815 	TEST2(active->iStatus.Int(), KErrNone);

   817 	CleanupStack::PopAndDestroy(5); // event, view, filter, active, client

   818 	}

   820 /**

   821 @SYMTestCaseID          SYSLIB-LOGENG-CT-1004

   822 @SYMTestCaseDesc	    Tests for view event log

   823 @SYMTestPriority 	    High

   824 @SYMTestActions  	    Create an event type and add the event to the log.

   825                         Close the log and try setting the filter on view.Check for access denied error.

   826 						Repeat the operation after opening the log and check for no error

   827 @SYMTestExpectedResults Test must not fail

   828 @SYMREQ                 REQ0000

   829 */

   830 LOCAL_C void TestViewSetup1L()

   831 	{

   832 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-1004 "));

   833 	CLogClient* client = CLogClient::NewL(theFs);

   834 	CleanupStack::PushL(client);

   835 	ForceClientImplInstL(*client);

   836 	EndBackupL();

   838 	CTestActive* active = new(ELeave)CTestActive();

   839 	CleanupStack::PushL(active);

   841 	CLogFilter* filter = CLogFilter::NewL();

   842 	CleanupStack::PushL(filter);

   844 	CLogViewEvent* view = CLogViewEvent::NewL(*client);

   845 	CleanupStack::PushL(view);

   847 	CLogEvent* event = CLogEvent::NewL();

   848 	CleanupStack::PushL(event);

   849 	event->SetEventType(KLogCallEventTypeUid);

   851 	active->StartL();

   852 	client->AddEvent(*event, active->iStatus);

   853 	CActiveScheduler::Start();

   854 	TEST2(active->iStatus.Int(), KErrNone);

   856 	TestLogOpenL();

   857 	StartBackupL();

   858 	DelayL(1000000);

   859 	TestLogClosedL();

   861 	TRAPD(error, view->SetFilterL(*filter, active->iStatus));

   862 	TEST2(error, KErrAccessDenied);

   864 	EndBackupL();

   865 	TestLogOpenL();

   867 	DelayL(1000000);

   868 	TEST(view->SetFilterL(*filter, active->iStatus));

   869 	active->StartL();

   870 	CActiveScheduler::Start();

   871 	TEST2(active->iStatus.Int(), KErrNone);

   873 	StartBackupL();

   874 	DelayL(1000000);

   875 	TestLogClosedL();

   876 	//

   877 	CleanupStack::PopAndDestroy(5); // event, view, filter, active, client

   878 	}

   880 /**

   881 @SYMTestCaseID          SYSLIB-LOGENG-CT-1005

   882 @SYMTestCaseDesc	    Tests for view event log

   883 @SYMTestPriority 	    High

   884 @SYMTestActions  	    Create an event type and add the event to the log.

   885                         Close the log and try setting the filter on view twice with an interval of one second.Check for access denied errors.

   886 						Repeat the operation after opening the log and check for no error

   887 @SYMTestExpectedResults Test must not fail

   888 @SYMREQ                 REQ0000

   889 */

   890 LOCAL_C void TestViewSetup2L()

   891  	{

   892 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-1005 "));

   893  	CLogClient* client = CLogClient::NewL(theFs);

   894  	CleanupStack::PushL(client);

   895  	ForceClientImplInstL(*client);

   896  	EndBackupL();

   898  	CTestActive* active = new(ELeave)CTestActive();

   899  	CleanupStack::PushL(active);

   901  	CLogFilter* filter = CLogFilter::NewL();

   902  	CleanupStack::PushL(filter);

   904  	CLogViewEvent* view = CLogViewEvent::NewL(*client);

   905  	CleanupStack::PushL(view);

   907  	CLogEvent* event = CLogEvent::NewL();

   908  	CleanupStack::PushL(event);

   909  	event->SetEventType(KLogCallEventTypeUid);

   911  	active->StartL();

   912  	client->AddEvent(*event, active->iStatus);

   913  	CActiveScheduler::Start();

   914  	TEST2(active->iStatus.Int(), KErrNone);

   916  	DelayL(1000000);

   917  	TEST(view->SetFilterL(*filter, active->iStatus));

   918  	active->StartL();

   919  	CActiveScheduler::Start();

   920  	TEST2(active->iStatus.Int(), KErrNone);

   922  	TestLogOpenL();

   923  	StartBackupL();

   924  	TestLogClosedL();

   926  	TRAPD(error, view->SetFilterL(*filter, active->iStatus));

   927  	TEST2(error, KErrAccessDenied);

   929  	DelayL(1000000);

   931  	TRAP(error, view->SetFilterL(*filter, active->iStatus));

   932  	TEST2(error, KErrAccessDenied);

   934  	EndBackupL();

   935  	TestLogOpenL();

   937  //	DelayL(1000000);

   938  	TEST(view->SetFilterL(*filter, active->iStatus));

   939  	active->StartL();

   940  	CActiveScheduler::Start();

   941  	TEST2(active->iStatus.Int(), KErrNone);

   943  	StartBackupL();

   944  	DelayL(1000000);

   945  	TestLogClosedL();

   946  	//

   947  	CleanupStack::PopAndDestroy(5); // event, view, filter, active, client

   948  	}

   950 /**

   951 Check that a KLogClientChangeEventRefreshView message is sent if the database is changed

   952 during a backup.  This could occur if the database is restored.

   954 This was added to test the fix for DEF051602 - Problems with MLogViewChangeObserver when a backup occurs

   956 @SYMTestCaseID          SYSLIB-LOGENG-CT-1006

   957 @SYMTestCaseDesc	    Check for any problems with MLogViewChangeObserver when a backup occurs

   958 @SYMTestPriority 	    High

   959 @SYMTestActions  	    Check that a KLogClientChangeEventRefreshView message is sent if the database is changed

   960 						during a backup.  This could occur if the database is restored.

   961 @SYMTestExpectedResults Test must not fail

   962 @SYMREQ                 REQ0000

   963 */

   964 LOCAL_C void TestRefreshViewL()

   965 {

   966     TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-1006 "));

   967 	CLogClient* client = CLogClient::NewL(theFs);

   968 	CleanupStack::PushL(client);

   970 	// Create a test observer MLogClientChangeObserver

   971 	TBool logRefreshViewFlag = EFalse;

   972 	TClientObserverTestReceiver testReceiver(logRefreshViewFlag);

   973 	client->SetGlobalChangeObserverL(&testReceiver);

   975 	// start a backup

   976 	TestLogOpenL();

   977 	StartBackupL();

   978 	DelayL(1000000);

   979 	TestLogClosedL();

   981 	// delete the database so a new empty db will be created

   982 	// This will cause a KLogClientChangeEventRefreshViewRefresh

   983 	// message to be sent

   984 	DeleteLogDatabaseL();

   986 	// end the backup

   987 	EndBackupL();

   988 	DelayL(1000000);

   991 	// check the obsever hs recieved a message

   992 	TEST(logRefreshViewFlag);

   993 	//

   995 	CleanupStack::PopAndDestroy(client);

   996 }

   999 #endif//__WINS__

  1000 /////////////////////////////////////////////////////////////////////////////////////

  1001 /////////////////////////////////////////////////////////////////////////////////////

  1002 /////////////////////////////////////////////////////////////////////////////////////

  1004 void doTestsL()

  1005 	{

  1006 	TestUtils::Initialize(_L("t_logbackup"));

  1007 	TestUtils::DeleteDatabaseL();

  1009     TheTest.Start(_L("t_logbackup"));

  1011 #ifndef __WINS__

  1012 	TheTest.Printf(_L("This test harness will only work on WINS\n"));

  1013 	User::After(5000000);

  1014 #else//__WINS__

  1015 	CLogChangeNotifier* notifier = CLogChangeNotifier::NewL();

  1016 	CleanupStack::PushL(notifier);

  1018 	TheTest.Next(_L("Locking"));

  1019 	TestLockingL();

  1020 	theLog.Write(_L8("Test 1 OK\n"));

  1022 	TheTest.Next(_L("Delete client while locked"));

  1023 	TestDeleteWhileLockedL();

  1024 	theLog.Write(_L8("Test 2 OK\n"));

  1026 	TheTest.Next(_L("Delete view while locked"));

  1027 	TestDeleteViewWhileLockedL();

  1028 	theLog.Write(_L8("Test 3 OK\n"));

  1030 	TheTest.Next(_L("Multiple clients"));

  1031 	TestMultipleClientLockingL();

  1032 	theLog.Write(_L8("Test 4 OK\n"));

  1034 	TheTest.Next(_L("Multiple views"));

  1035 	TestMultipleViewLockingL();

  1036 	theLog.Write(_L8("Test 5 OK\n"));

  1038 	TheTest.Next(_L("Client Requests"));

  1039 	TestClientRequestsL();

  1040 	theLog.Write(_L8("Test 6 OK\n"));

  1042 	TheTest.Next(_L("View setup"));

  1043 	TestViewSetup1L();

  1044 	TestViewSetup2L();

  1045 	theLog.Write(_L8("Test 7 OK\n"));

  1047 	TheTest.Next(_L("Notifications"));

  1048 	TestNotificationsL();

  1049 	theLog.Write(_L8("Test 8 OK\n"));

  1051 	TheTest.Next(_L("Request in progress"));

  1052 	TestRequestInProgressL();

  1053 	theLog.Write(_L8("Test 9 OK\n"));

  1055 	TheTest.Next(_L("View request in progress"));

  1056 	TestViewRequestInProgressL();

  1057 	theLog.Write(_L8("Test 10 OK\n"));

  1059 	TheTest.Next(_L("Refresh view"));

  1060 	TestRefreshViewL();

  1061 	theLog.Write(_L8("Test 11 OK\n"));

  1063 	CleanupStack::PopAndDestroy(notifier);

  1064 #endif//__WINS__

  1065 	}

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