diff -r 000000000000 -r 08ec8eefde2f loggingservices/eventlogger/test/src/t_logbackup.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/loggingservices/eventlogger/test/src/t_logbackup.cpp Fri Jan 22 11:06:30 2010 +0200 @@ -0,0 +1,1068 @@ +// Copyright (c) 2002-2009 Nokia Corporation and/or its subsidiary(-ies). +// All rights reserved. +// This component and the accompanying materials are made available +// under the terms of "Eclipse Public License v1.0" +// which accompanies this distribution, and is available +// at the URL "http://www.eclipse.org/legal/epl-v10.html". +// +// Initial Contributors: +// Nokia Corporation - initial contribution. +// +// Contributors: +// +// Description: +// + +#include +#include + +#include "TEST.H" +#include + +#undef test //there is a "test" macro which hides "RTest test" declaration. + +RTest test(_L("Log Backup Test Harness")); +CBaBackupSessionWrapper* theBackup = NULL; + +///////////////////////////////////////////////////////////////////////////////////// +///////////////////////////////////////////////////////////////////////////////////// +///////////////////////////////////////////////////////////////////////////////////// +#ifdef __WINS__ + +_LIT(KTestEventDesc, "Event Type Description"); +_LIT(KTestRemoteParty, "Remote Party"); +_LIT(KTestDirection, "Direction"); +const TLogDurationType KTestDurationType = 1; +const TLogDuration KTestDuration = 0x1234; +_LIT(KTestStatus, "Status"); +_LIT(KTestSubject, "Subject"); +_LIT(KTestNumber, "Number"); +const TLogContactItemId KTestContact = 0x1234; +const TLogLink KTestLink = 0x1234; +_LIT8(KTestData, "ABCDEFGH"); +_LIT(KTestNumber1, "TheNumber"); +_LIT(KTestNumber2, "Changed Number"); + +class TClientObserverTestReceiver : public MLogClientChangeObserver + { +public: + TClientObserverTestReceiver(TBool& aFlag) : iCallCount(0), iFlag(aFlag) { } + +public: + void HandleLogClientChangeEventL(TUid aChangeType, TInt /*aChangeParam1*/, TInt /*aChangeParam2*/, TInt /*aChangeParam3*/) + { + ++iCallCount; + iFlag = (aChangeType == KLogClientChangeEventRefreshView); + } + inline TInt CallCount() const { return iCallCount; } + inline void Reset() { iCallCount = 0; iFlag = EFalse; } + +private: + TInt iCallCount; + TBool& iFlag; + }; + +LOCAL_C TBool IsLogOpenL() + { + return TestUtils::IsDatabaseOpenL(); + } + +/** +@SYMTestCaseID SYSLIB-LOGENG-CT-0993 +@SYMTestCaseDesc Tests for a file open +@SYMTestPriority High +@SYMTestActions Check for errors while testing for file open +@SYMTestExpectedResults Test must not fail +@SYMREQ REQ0000 +*/ +LOCAL_C void TestLogOpenL() + { + test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0993 ")); + TEST(IsLogOpenL()); + } + +/** +@SYMTestCaseID SYSLIB-LOGENG-CT-0994 +@SYMTestCaseDesc Tests for file close +@SYMTestPriority High +@SYMTestActions Check for errors while testing for file close +@SYMTestExpectedResults Test must not fail +@SYMREQ REQ0000 +*/ +LOCAL_C void TestLogClosedL() + { + test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0994 ")); + TEST(!IsLogOpenL()); + } + +LOCAL_C void StartBackupL() + { + User::InfoPrint(_L("Backup")); + + TDriveUnit driveUnit(EDriveC); + TDriveName name = driveUnit.Name(); + + TParse parse; + LEAVE_IF_ERROR(parse.Set(KLogDatabaseName, &name, NULL)); + + delete theBackup; + theBackup = NULL; + theBackup = CBaBackupSessionWrapper::NewL(); + + theBackup->CloseFileL(parse.FullName(), MBackupObserver::EReleaseLockNoAccess); + User::After(1000000); + } + +LOCAL_C void DeleteLogDatabaseL() + { + User::InfoPrint(_L("delete")); + TestUtils::DeleteDatabaseL(EFalse); + } + +LOCAL_C void EndBackupL() + { + delete theBackup; + theBackup = NULL; + User::After(1000000); + } + +LOCAL_C void DelayL(TInt aDelay) + { + CTestTimer* timer = CTestTimer::NewL(); + timer->After(aDelay); + CActiveScheduler::Start(); + delete timer; + } + + +const TUid KTestEventUid = {0x10005393}; +_LIT(KTestEventDesc1, "Event Type Description"); +_LIT(KTestEventDesc2, "Changed Event Description"); + +LOCAL_C void ForceClientImplInstL(CLogClient& aClient) + { + CLogEventType* type = CLogEventType::NewL(); + CleanupStack::PushL(type); + type->SetUid(KTestEventUid); + type->SetDescription(KTestEventDesc1); + type->SetLoggingEnabled(ETrue); + + CTestActive* active = new(ELeave)CTestActive; + CleanupStack::PushL(active); + aClient.AddEventType(*type, active->iStatus); + active->StartL(); + CActiveScheduler::Start(); + CleanupStack::PopAndDestroy(2);//type, active + + } + +/** +@SYMTestCaseID SYSLIB-LOGENG-CT-0995 +@SYMTestCaseDesc Tests for starting and ending the backup session +@SYMTestPriority High +@SYMTestActions Test for file open and close,start and end of the backup session +@SYMTestExpectedResults Test must not fail +@SYMREQ REQ0000 +*/ +LOCAL_C void TestLockingL() + { + test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0995 ")); + CLogClient* client = CLogClient::NewL(theFs); + CleanupStack::PushL(client); + + ForceClientImplInstL(*client); + + + DelayL(1000000); + TestLogOpenL(); + StartBackupL(); + DelayL(1000000); + + TestLogClosedL(); + + EndBackupL(); + TestLogOpenL(); + + CleanupStack::PopAndDestroy(); // client + } + +/** +@SYMTestCaseID SYSLIB-LOGENG-CT-0996 +@SYMTestCaseDesc Tests for deleting the file when its locked +@SYMTestPriority High +@SYMTestActions Attempt for deleting the file when its locked +@SYMTestExpectedResults Test must not fail +@SYMREQ REQ0000 +*/ +LOCAL_C void TestDeleteWhileLockedL() + { + test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0996 ")); + CLogClient* client = CLogClient::NewL(theFs); + CleanupStack::PushL(client); + ForceClientImplInstL(*client); + + TestLogOpenL(); + StartBackupL(); + DelayL(1000000); + TestLogClosedL(); + + CleanupStack::PopAndDestroy(); // client + TestLogClosedL(); + + client = CLogClient::NewL(theFs); + CleanupStack::PushL(client); + ForceClientImplInstL(*client); + EndBackupL(); + + TestLogOpenL(); + StartBackupL(); + DelayL(1000000); + TestLogClosedL(); + EndBackupL(); + TestLogOpenL(); + + CleanupStack::PopAndDestroy(); // client + } + +/** +@SYMTestCaseID SYSLIB-LOGENG-CT-0997 +@SYMTestCaseDesc Tests for deleting the view while its locked +@SYMTestPriority High +@SYMTestActions Delete the view when its locked +@SYMTestExpectedResults Test must not fail +@SYMREQ REQ0000 +*/ +LOCAL_C void TestDeleteViewWhileLockedL() + { + test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0997 ")); + CLogClient* client = CLogClient::NewL(theFs); + CleanupStack::PushL(client); + ForceClientImplInstL(*client); + + CLogFilter* filter = CLogFilter::NewL(); + CleanupStack::PushL(filter); + + CLogViewEvent* view = CLogViewEvent::NewL(*client); + CleanupStack::PushL(view); + + TestLogOpenL(); + StartBackupL(); + DelayL(1000000); + TestLogClosedL(); + + CleanupStack::PopAndDestroy(3); // view, filter, client + TestLogClosedL(); + + client = CLogClient::NewL(theFs); + CleanupStack::PushL(client); + ForceClientImplInstL(*client); + + filter = CLogFilter::NewL(); + CleanupStack::PushL(filter); + + view = CLogViewEvent::NewL(*client); + CleanupStack::PushL(view); + EndBackupL(); + + TestLogOpenL(); + StartBackupL(); + DelayL(1000000); + TestLogClosedL(); + EndBackupL(); + TestLogOpenL(); + + CleanupStack::PopAndDestroy(3); // view, filter, client + } + +/** +@SYMTestCaseID SYSLIB-LOGENG-CT-0998 +@SYMTestCaseDesc Multiple client logging test +@SYMTestPriority High +@SYMTestActions Open multiple clients and test for starting and ending the backup +@SYMTestExpectedResults Test must not fail +@SYMREQ REQ0000 +*/ +LOCAL_C void TestMultipleClientLockingL() + { + test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0998 ")); + CLogClient* client1 = CLogClient::NewL(theFs); + CleanupStack::PushL(client1); + ForceClientImplInstL(*client1); + + TestLogOpenL(); + + CLogClient* client2 = CLogClient::NewL(theFs); + CleanupStack::PushL(client2); + ForceClientImplInstL(*client2); + + TestLogOpenL(); + + StartBackupL(); + EndBackupL(); + TestLogOpenL(); + + StartBackupL(); + TestLogClosedL(); + + EndBackupL(); + TestLogOpenL(); + + CleanupStack::PopAndDestroy(2); // client1, client2 + } + +/** +@SYMTestCaseID SYSLIB-LOGENG-CT-0999 +@SYMTestCaseDesc Multiple view locking test +@SYMTestPriority High +@SYMTestActions Open multiple views and test for starting and ending of backup +@SYMTestExpectedResults Test must not fail +@SYMREQ REQ0000 +*/ +LOCAL_C void TestMultipleViewLockingL() + { + test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0999 ")); + CLogClient* client = CLogClient::NewL(theFs); + CleanupStack::PushL(client); + ForceClientImplInstL(*client); + + CLogFilter* filter = CLogFilter::NewL(); + CleanupStack::PushL(filter); + + CLogViewEvent* view1 = CLogViewEvent::NewL(*client); + CleanupStack::PushL(view1); + + CLogViewEvent* view2 = CLogViewEvent::NewL(*client); + CleanupStack::PushL(view2); + + TestLogOpenL(); + StartBackupL(); + TestLogClosedL(); + EndBackupL(); + TestLogOpenL(); + + CleanupStack::PopAndDestroy(4); // view2, view1, filter, client + } + +LOCAL_C void DoTestLogL(CLogBase& aClient, TInt aError) + { + CTestActive* active = new(ELeave)CTestActive(); + CleanupStack::PushL(active); + + CLogEvent* event = CLogEvent::NewL(); + CleanupStack::PushL(event); + + TTime now; + now.UniversalTime(); + + event->SetEventType(KLogCallEventTypeUid); + + active->StartL(); + aClient.AddEvent(*event, active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), aError); + + if (aError == KErrNone) + { + TEST(event->EventType() == KLogCallEventTypeUid); + TEST(event->Description().Length() > 0); + TEST(event->Time() >= now); + now = event->Time(); + } + else + { + // User a dummy id to prevent assertion + event->SetId(123); + } + + TLogId id = event->Id(); + + event->SetRemoteParty(KTestRemoteParty); + event->SetDirection(KTestDirection); + event->SetDurationType(KTestDurationType); + event->SetDuration(KTestDuration); + event->SetStatus(KTestStatus); + event->SetSubject(KTestSubject); + event->SetNumber(KTestNumber); + event->SetContact(KTestContact); + event->SetLink(KTestLink); + event->SetDataL(KTestData); + + active->StartL(); + aClient.ChangeEvent(*event, active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), aError); + + if (aError == KErrNone) + { + TEST(event->Id() == id); + TEST(event->EventType() == KLogCallEventTypeUid); + TEST(event->Description().Length() > 0); + TEST(event->Time() == now); + TEST(event->RemoteParty() == KTestRemoteParty); + TEST(event->Direction() == KTestDirection); + TEST(event->DurationType() == KTestDurationType); + TEST(event->Duration() == KTestDuration); + TEST(event->Status() == KTestStatus); + TEST(event->Subject() == KTestSubject); + TEST(event->Number() == KTestNumber); + TEST(event->Contact() == KTestContact); + TEST(event->Link() == KTestLink); + TEST(event->Data() == KTestData); + } + + CleanupStack::PopAndDestroy(); // event; + + event = CLogEvent::NewL(); + CleanupStack::PushL(event); + + event->SetId(id); + + active->StartL(); + aClient.GetEvent(*event, active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), aError); + + if (aError == KErrNone) + { + TEST(event->Id() == id); + TEST(event->EventType() == KLogCallEventTypeUid); + TEST(event->Description().Length() > 0); + TEST(event->Time() == now); + TEST(event->RemoteParty() == KTestRemoteParty); + TEST(event->Direction() == KTestDirection); + TEST(event->DurationType() == KTestDurationType); + TEST(event->Duration() == KTestDuration); + TEST(event->Status() == KTestStatus); + TEST(event->Subject() == KTestSubject); + TEST(event->Number() == KTestNumber); + TEST(event->Contact() == KTestContact); + TEST(event->Link() == KTestLink); + TEST(event->Data() == KTestData); + } + + active->StartL(); + aClient.DeleteEvent(id, active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), aError); + + active->StartL(); + aClient.GetEvent(*event, active->iStatus); + CActiveScheduler::Start(); + RDebug::Print(_L("*** active->iStatus.Int()=%d\n"), active->iStatus.Int()); + TEST(active->iStatus.Int() == aError || active->iStatus.Int() == KErrNotFound); + + CleanupStack::PopAndDestroy(2); // event, active + } + +/** +@SYMTestCaseID SYSLIB-LOGENG-CT-1000 +@SYMTestCaseDesc Client requests test +@SYMTestPriority High +@SYMTestActions Tests for client requests when the file is opened and check for no errors + Tests for client requests when the file is closed and check for access denied errors + Re-test for client requests when file is opened and check for no errors +@SYMTestExpectedResults Test must not fail +@SYMREQ REQ0000 +*/ +LOCAL_C void TestClientRequestsL() + { + test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-1000 ")); + CLogClient* client1 = CLogClient::NewL(theFs); + CleanupStack::PushL(client1); + ForceClientImplInstL(*client1); + + TestLogOpenL(); + + CLogClient* client2 = CLogClient::NewL(theFs); + CleanupStack::PushL(client2); + ForceClientImplInstL(*client2); + + TestLogOpenL(); + + DoTestLogL(*client1, KErrNone); + DoTestLogL(*client2, KErrNone); + + StartBackupL(); + DelayL(1000000); + TestLogClosedL(); + + DoTestLogL(*client1, KErrAccessDenied); + DoTestLogL(*client2, KErrAccessDenied); + + EndBackupL(); + TestLogOpenL(); + + DoTestLogL(*client1, KErrNone); + DoTestLogL(*client2, KErrNone); + + CleanupStack::PopAndDestroy(2); // client1, client2 + } + +/** +@SYMTestCaseID SYSLIB-LOGENG-CT-1001 +@SYMTestCaseDesc Tests for notification changes +@SYMTestPriority High +@SYMTestActions Set up for client log notification changes. + Change the log and unlock the log.Try and change the log again and check for access denied error. +@SYMTestExpectedResults Test must not fail +@SYMREQ REQ0000 +*/ +LOCAL_C void TestNotificationsL() + { + test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-1001 ")); + CTestActive* notify = new(ELeave)CTestActive; + CleanupStack::PushL(notify); + + CTestTimer* timer = CTestTimer::NewL(); + CleanupStack::PushL(timer); + + CLogClient* client = CLogClient::NewL(theFs); + CleanupStack::PushL(client); + ForceClientImplInstL(*client); + EndBackupL(); + + // Setup change notification + notify->StartL(); + client->NotifyChange(10000000, notify->iStatus); + + // Wait a second + timer->After(1000000); + CActiveScheduler::Start(); + + // Change the log + DoTestLogL(*client, KErrNone); + + // Unlock the log + TestLogOpenL(); + StartBackupL(); + DelayL(1000000); + TestLogClosedL(); + + // Try and change the log again + DoTestLogL(*client, KErrAccessDenied); + + // Make sure the notifier doesn't complete + timer->After(15000000); + CActiveScheduler::Start(); + TEST(notify->IsActive()); + + // Lock the log + EndBackupL(); + TestLogOpenL(); + + // Wait for notification + CActiveScheduler::Start(); + TEST(!notify->IsActive()); + + // Setup change notification + notify->StartL(); + client->NotifyChange(10000000, notify->iStatus); + + // Wait a second + timer->After(1000000); + CActiveScheduler::Start(); + + // Unlock the log + TestLogOpenL(); + StartBackupL(); + DelayL(1000000); + TestLogClosedL(); + + // Check notification is completed when client destroyed + TEST(notify->IsActive()); + CleanupStack::PopAndDestroy(client); + + // Wait for notification + CActiveScheduler::Start(); + TEST(!notify->IsActive()); + TEST2(notify->iStatus.Int(), KErrCancel); + + // Recreate client + client = CLogClient::NewL(theFs); + CleanupStack::PushL(client); + + // Setup change notification + notify->StartL(); + client->NotifyChange(10000000, notify->iStatus); + + // Wait a second + timer->After(1000000); + CActiveScheduler::Start(); + + // Check notification is completed when cancelled + TEST(notify->IsActive()); + client->NotifyChangeCancel(); + + // Wait for notification + CActiveScheduler::Start(); + TEST(!notify->IsActive()); + TEST2(notify->iStatus.Int(), KErrCancel); + + // Setup change notification + notify->StartL(); + client->NotifyChange(10000000, notify->iStatus); + + // Wait a second + timer->After(1000000); + CActiveScheduler::Start(); + + // Lock the log + EndBackupL(); + TestLogOpenL(); + + // Wait for notification + TEST(notify->IsActive()); + CActiveScheduler::Start(); + TEST(!notify->IsActive()); + TEST(notify->iStatus >= 0); + + notify->StartL(); + client->NotifyChange(10000000, notify->iStatus); + + // Wait a second + timer->After(1000000); + CActiveScheduler::Start(); + + // Change the log + DoTestLogL(*client, KErrNone); + + // Wait for notification + TEST(notify->IsActive()); + CActiveScheduler::Start(); + TEST(!notify->IsActive()); + TEST(notify->iStatus >= 0); + + CleanupStack::PopAndDestroy(3); // client, timer, notify + } + +/** +@SYMTestCaseID SYSLIB-LOGENG-CT-1002 +@SYMTestCaseDesc Tests for request in progress +@SYMTestPriority High +@SYMTestActions Add an event when backup is started and check for access denied error +@SYMTestExpectedResults Test must not fail +@SYMREQ REQ0000 +*/ +LOCAL_C void TestRequestInProgressL() + { + test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-1002 ")); + CLogClient* client = CLogClient::NewL(theFs); + CleanupStack::PushL(client); + ForceClientImplInstL(*client); + EndBackupL(); + + CTestActive* active = new(ELeave)CTestActive(); + CleanupStack::PushL(active); + + CLogEvent* event = CLogEvent::NewL(); + CleanupStack::PushL(event); + + event->SetEventType(KLogCallEventTypeUid); + + active->StartL(); + client->AddEvent(*event, active->iStatus); + StartBackupL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrAccessDenied); + DelayL(1000000); + + // User a dummy id to prevent assertion + event->SetId(123); + + EndBackupL(); + active->StartL(); + client->ChangeEvent(*event, active->iStatus); + StartBackupL(); + + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrAccessDenied); + DelayL(1000000); + + EndBackupL(); + active->StartL(); + client->GetEvent(*event, active->iStatus); + StartBackupL(); + + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrAccessDenied); + DelayL(1000000); + + EndBackupL(); + active->StartL(); + client->DeleteEvent(event->Id(), active->iStatus); + StartBackupL(); + + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrAccessDenied); + DelayL(1000000); + + EndBackupL(); + active->StartL(); + client->GetEvent(*event, active->iStatus); + StartBackupL(); + + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrAccessDenied); + DelayL(1000000); + + // Check the log is useable + EndBackupL(); + DoTestLogL(*client, KErrNone); + + CleanupStack::PopAndDestroy(3); // client, event, active + } + +/** +@SYMTestCaseID SYSLIB-LOGENG-CT-1003 +@SYMTestCaseDesc Tests for log view when request is in progress +@SYMTestPriority High +@SYMTestActions Add events to the log,set a filter on log view and start the backup session + and check for the request status for access denied. +@SYMTestExpectedResults Test must not fail +@SYMREQ REQ0000 +*/ +LOCAL_C void TestViewRequestInProgressL() + { + test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-1003 ")); + CLogClient* client = CLogClient::NewL(theFs); + CleanupStack::PushL(client); + ForceClientImplInstL(*client); + EndBackupL(); + + CTestActive* active = new(ELeave)CTestActive(); + CleanupStack::PushL(active); + + CLogFilter* filter = CLogFilter::NewL(); + CleanupStack::PushL(filter); + + CLogViewEvent* view = CLogViewEvent::NewL(*client); + CleanupStack::PushL(view); + + CLogEvent* event = CLogEvent::NewL(); + CleanupStack::PushL(event); + event->SetEventType(KLogCallEventTypeUid); + + active->StartL(); + client->AddEvent(*event, active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + active->StartL(); + client->AddEvent(*event, active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + TestLogOpenL(); + TEST(view->SetFilterL(*filter, active->iStatus)); + active->StartL(); + StartBackupL(); + + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrAccessDenied); + DelayL(1000000); + TestLogClosedL(); + + EndBackupL(); + TestLogOpenL(); + + TEST(view->SetFilterL(*filter, active->iStatus)); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + TEST(view->NextL(active->iStatus)); + active->StartL(); + StartBackupL(); + + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrAccessDenied); + DelayL(1000000); + TestLogClosedL(); + + EndBackupL(); + TestLogOpenL(); + + TEST(view->SetFilterL(*filter, active->iStatus)); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + TEST(view->NextL(active->iStatus)); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + // Now check a view is no longer valid after a backup + TEST(view->SetFilterL(*filter, active->iStatus)); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + TEST(view->CountL() > 1); + + StartBackupL(); + EndBackupL(); + + DelayL(1000000); + + // Check the view can be setup again + TEST(view->SetFilterL(*filter, active->iStatus)); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + TEST(view->CountL() > 1); + + TEST(view->NextL(active->iStatus)); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + CleanupStack::PopAndDestroy(5); // event, view, filter, active, client + } + +/** +@SYMTestCaseID SYSLIB-LOGENG-CT-1004 +@SYMTestCaseDesc Tests for view event log +@SYMTestPriority High +@SYMTestActions Create an event type and add the event to the log. + Close the log and try setting the filter on view.Check for access denied error. + Repeat the operation after opening the log and check for no error +@SYMTestExpectedResults Test must not fail +@SYMREQ REQ0000 +*/ +LOCAL_C void TestViewSetup1L() + { + test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-1004 ")); + CLogClient* client = CLogClient::NewL(theFs); + CleanupStack::PushL(client); + ForceClientImplInstL(*client); + EndBackupL(); + + CTestActive* active = new(ELeave)CTestActive(); + CleanupStack::PushL(active); + + CLogFilter* filter = CLogFilter::NewL(); + CleanupStack::PushL(filter); + + CLogViewEvent* view = CLogViewEvent::NewL(*client); + CleanupStack::PushL(view); + + CLogEvent* event = CLogEvent::NewL(); + CleanupStack::PushL(event); + event->SetEventType(KLogCallEventTypeUid); + + active->StartL(); + client->AddEvent(*event, active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + TestLogOpenL(); + StartBackupL(); + DelayL(1000000); + TestLogClosedL(); + + TRAPD(error, view->SetFilterL(*filter, active->iStatus)); + TEST2(error, KErrAccessDenied); + + EndBackupL(); + TestLogOpenL(); + + DelayL(1000000); + TEST(view->SetFilterL(*filter, active->iStatus)); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + StartBackupL(); + DelayL(1000000); + TestLogClosedL(); + // + CleanupStack::PopAndDestroy(5); // event, view, filter, active, client + } + +/** +@SYMTestCaseID SYSLIB-LOGENG-CT-1005 +@SYMTestCaseDesc Tests for view event log +@SYMTestPriority High +@SYMTestActions Create an event type and add the event to the log. + Close the log and try setting the filter on view twice with an interval of one second.Check for access denied errors. + Repeat the operation after opening the log and check for no error +@SYMTestExpectedResults Test must not fail +@SYMREQ REQ0000 +*/ +LOCAL_C void TestViewSetup2L() + { + test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-1005 ")); + CLogClient* client = CLogClient::NewL(theFs); + CleanupStack::PushL(client); + ForceClientImplInstL(*client); + EndBackupL(); + + CTestActive* active = new(ELeave)CTestActive(); + CleanupStack::PushL(active); + + CLogFilter* filter = CLogFilter::NewL(); + CleanupStack::PushL(filter); + + CLogViewEvent* view = CLogViewEvent::NewL(*client); + CleanupStack::PushL(view); + + CLogEvent* event = CLogEvent::NewL(); + CleanupStack::PushL(event); + event->SetEventType(KLogCallEventTypeUid); + + active->StartL(); + client->AddEvent(*event, active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + DelayL(1000000); + TEST(view->SetFilterL(*filter, active->iStatus)); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + TestLogOpenL(); + StartBackupL(); + TestLogClosedL(); + + TRAPD(error, view->SetFilterL(*filter, active->iStatus)); + TEST2(error, KErrAccessDenied); + + DelayL(1000000); + + TRAP(error, view->SetFilterL(*filter, active->iStatus)); + TEST2(error, KErrAccessDenied); + + EndBackupL(); + TestLogOpenL(); + + // DelayL(1000000); + TEST(view->SetFilterL(*filter, active->iStatus)); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + StartBackupL(); + DelayL(1000000); + TestLogClosedL(); + // + CleanupStack::PopAndDestroy(5); // event, view, filter, active, client + } + +/** +Check that a KLogClientChangeEventRefreshView message is sent if the database is changed +during a backup. This could occur if the database is restored. + +This was added to test the fix for DEF051602 - Problems with MLogViewChangeObserver when a backup occurs + +@SYMTestCaseID SYSLIB-LOGENG-CT-1006 +@SYMTestCaseDesc Check for any problems with MLogViewChangeObserver when a backup occurs +@SYMTestPriority High +@SYMTestActions Check that a KLogClientChangeEventRefreshView message is sent if the database is changed + during a backup. This could occur if the database is restored. +@SYMTestExpectedResults Test must not fail +@SYMREQ REQ0000 +*/ +LOCAL_C void TestRefreshViewL() +{ + test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-1006 ")); + CLogClient* client = CLogClient::NewL(theFs); + CleanupStack::PushL(client); + + // Create a test observer MLogClientChangeObserver + TBool logRefreshViewFlag = EFalse; + TClientObserverTestReceiver testReceiver(logRefreshViewFlag); + client->SetGlobalChangeObserverL(&testReceiver); + + // start a backup + TestLogOpenL(); + StartBackupL(); + DelayL(1000000); + TestLogClosedL(); + + // delete the database so a new empty db will be created + // This will cause a KLogClientChangeEventRefreshViewRefresh + // message to be sent + DeleteLogDatabaseL(); + + // end the backup + EndBackupL(); + DelayL(1000000); + + + // check the obsever hs recieved a message + TEST(logRefreshViewFlag); + // + + CleanupStack::PopAndDestroy(client); +} + + +#endif//__WINS__ +///////////////////////////////////////////////////////////////////////////////////// +///////////////////////////////////////////////////////////////////////////////////// +///////////////////////////////////////////////////////////////////////////////////// + +void doTestsL() +// +// +// + { + test.Start(_L("T_LogBackup")); + TestUtils::Initialize(_L("T_BACKUP")); + TestUtils::DeleteDatabaseL(); +#ifndef __WINS__ + test.Printf(_L("This test harness will only work on WINS\n")); + User::After(5000000); +#else//__WINS__ + CLogChangeNotifier* notifier = CLogChangeNotifier::NewL(); + CleanupStack::PushL(notifier); + + test.Next(_L("Locking")); + TestLockingL(); + theLog.Write(_L8("Test 1 OK\n")); + + test.Next(_L("Delete client while locked")); + TestDeleteWhileLockedL(); + theLog.Write(_L8("Test 2 OK\n")); + + test.Next(_L("Delete view while locked")); + TestDeleteViewWhileLockedL(); + theLog.Write(_L8("Test 3 OK\n")); + + test.Next(_L("Multiple clients")); + TestMultipleClientLockingL(); + theLog.Write(_L8("Test 4 OK\n")); + + test.Next(_L("Multiple views")); + TestMultipleViewLockingL(); + theLog.Write(_L8("Test 5 OK\n")); + + test.Next(_L("Client Requests")); + TestClientRequestsL(); + theLog.Write(_L8("Test 6 OK\n")); + + test.Next(_L("View setup")); + TestViewSetup1L(); + TestViewSetup2L(); + theLog.Write(_L8("Test 7 OK\n")); + + test.Next(_L("Notifications")); + TestNotificationsL(); + theLog.Write(_L8("Test 8 OK\n")); + + test.Next(_L("Request in progress")); + TestRequestInProgressL(); + theLog.Write(_L8("Test 9 OK\n")); + + test.Next(_L("View request in progress")); + TestViewRequestInProgressL(); + theLog.Write(_L8("Test 10 OK\n")); + + test.Next(_L("Refresh view")); + TestRefreshViewL(); + theLog.Write(_L8("Test 11 OK\n")); + + CleanupStack::PopAndDestroy(notifier); +#endif//__WINS__ + }