1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/persistentdata/loggingservices/eventlogger/test/src/t_logapi.cpp Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,1969 @@
1.4 +// Copyright (c) 2002-2010 Nokia Corporation and/or its subsidiary(-ies).
1.5 +// All rights reserved.
1.6 +// This component and the accompanying materials are made available
1.7 +// under the terms of "Eclipse Public License v1.0"
1.8 +// which accompanies this distribution, and is available
1.9 +// at the URL "http://www.eclipse.org/legal/epl-v10.html".
1.10 +//
1.11 +// Initial Contributors:
1.12 +// Nokia Corporation - initial contribution.
1.13 +//
1.14 +// Contributors:
1.15 +//
1.16 +// Description:
1.17 +//
1.18 +
1.19 +#include <s32file.h>
1.20 +#include <e32math.h>
1.21 +#include <logview.h>
1.22 +#include <s32mem.h>
1.23 +#include "t_logutil2.h"
1.24 +#include "t_logutil3.h"
1.25 +
1.26 +#define UNUSED_VAR(a) a = a
1.27 +
1.28 +const TLogContactItemId KTestContact = 0x1234;
1.29 +const TInt KTestEventNum = 10;
1.30 +
1.31 +RTest TheTest(_L("t_logapi"));
1.32 +
1.33 +const TUid KTestEventUid = {0x10005393};
1.34 +_LIT(KTestEventDesc1, "Event Type Description");
1.35 +_LIT(KTestEventDesc2, "Changed Event Description");
1.36 +_LIT(KTestRemoteParty1, "Remote Party");
1.37 +_LIT(KTestRemoteParty2, "Changed Remote Party");
1.38 +_LIT(KTestDirection1, "Direction");
1.39 +_LIT(KTestDirection2, "Changed Direction");
1.40 +const TLogDurationType KTestDurationType1 = 1;
1.41 +const TLogDurationType KTestDurationType2 = 2;
1.42 +const TLogDuration KTestDuration1 = 0x1234;
1.43 +const TLogDuration KTestDuration2 = 0x1234567;
1.44 +_LIT(KTestStatus1, "Status");
1.45 +_LIT(KTestStatus2, "Changed Status");
1.46 +_LIT(KTestSubject1, "Subject");
1.47 +_LIT(KTestSubject2, "Changed Subject");
1.48 +_LIT(KTestNumber1, "TheNumber");
1.49 +_LIT(KTestNumber2, "Changed Number");
1.50 +const TLogContactItemId KTestContact1 = 0x1234;
1.51 +const TLogContactItemId KTestContact2 = 0x1234567;
1.52 +const TLogLink KTestLink1 = 0x1234;
1.53 +const TLogLink KTestLink2 = 0x1234567;
1.54 +_LIT8(KTestData1, "ABCDEFGH");
1.55 +_LIT8(KTestData2, "IJKLMNOPQRSTUVWXYZ");
1.56 +const TLogFlags KTestFlags1 = 0x5;
1.57 +const TLogFlags KTestFlags2 = 0xA;
1.58 +const TLogSize KTestMaxLogSize = 0xFFF;
1.59 +const TLogRecentSize KTestMaxRecentLogSize = 0xF;
1.60 +const TLogAge KTestMaxEventAge = 0xFFFFFFF;
1.61 +
1.62 +TInt gTheId;
1.63 +
1.64 +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.65 +
1.66 +class TClientObserverTestReceiver : public MLogClientChangeObserver
1.67 + {
1.68 +public:
1.69 + TClientObserverTestReceiver(TBool& aFlag) : iCallCount(0), iFlag(aFlag) { }
1.70 +
1.71 +public:
1.72 + void HandleLogClientChangeEventL(TUid aChangeType, TInt /*aChangeParam1*/, TInt /*aChangeParam2*/, TInt /*aChangeParam3*/)
1.73 + {
1.74 + ++iCallCount;
1.75 + iFlag = (aChangeType == KLogClientChangeEventLogCleared);
1.76 + }
1.77 + inline TInt CallCount() const { return iCallCount; }
1.78 + inline void Reset() { iCallCount = 0; iFlag = EFalse; }
1.79 +
1.80 +private:
1.81 + TInt iCallCount;
1.82 + TBool& iFlag;
1.83 + };
1.84 +
1.85 +/**
1.86 +@SYMTestCaseID SYSLIB-LOGENG-CT-0833
1.87 +@SYMTestCaseDesc Client observer mechanism test
1.88 +@SYMTestPriority High
1.89 +@SYMTestActions Set the change observer,add an event type,clear the log and test for the status.
1.90 +@SYMTestExpectedResults Test must not fail
1.91 +@SYMREQ REQ0000
1.92 +*/
1.93 +LOCAL_C void TestClientObserverMechanismL(CLogClient& aClient)
1.94 + {
1.95 + //
1.96 + TBool logClearedFlag = EFalse;
1.97 + TClientObserverTestReceiver testReceiver(logClearedFlag);
1.98 + //
1.99 + aClient.SetGlobalChangeObserverL(&testReceiver);
1.100 +
1.101 + TTime now;
1.102 + now.UniversalTime();
1.103 + TTime clearLogThreshold(now);
1.104 + clearLogThreshold -= TTimeIntervalDays(1);
1.105 + TTime past(now);
1.106 + past -= TTimeIntervalDays(2);
1.107 +
1.108 + // Make some events
1.109 + CLogEvent* event = CLogEvent::NewL();
1.110 + CleanupStack::PushL(event);
1.111 + CTestActive* active = new(ELeave)CTestActive();
1.112 + CleanupStack::PushL(active);
1.113 + for(TInt i=0; i<10; i++)
1.114 + {
1.115 + event->SetEventType(KLogCallEventTypeUid);
1.116 + event->SetRemoteParty(KTestRemoteParty1);
1.117 + event->SetDirection(KTestDirection1);
1.118 + event->SetDurationType(KTestDurationType1);
1.119 + event->SetDuration(KTestDuration1);
1.120 + event->SetStatus(KTestStatus1);
1.121 + event->SetSubject(KTestSubject1);
1.122 + event->SetNumber(KTestNumber1);
1.123 + event->SetContact((TLogContactItemId) i+1);
1.124 + event->SetLink(KTestLink1);
1.125 + event->SetDataL(KTestData1);
1.126 + event->SetFlags(KTestFlags1);
1.127 +
1.128 + // Add event
1.129 + active->StartL();
1.130 + aClient.AddEvent(*event, active->iStatus);
1.131 + CActiveScheduler::Start();
1.132 + TEST2(active->iStatus.Int(), KErrNone);
1.133 +
1.134 + // Make it in the past
1.135 + event->SetTime(past);
1.136 + active->StartL();
1.137 + aClient.ChangeEvent(*event, active->iStatus);
1.138 + CActiveScheduler::Start();
1.139 + TEST2(active->iStatus.Int(), KErrNone);
1.140 + }
1.141 + TEST2(testReceiver.CallCount(), 0);
1.142 +
1.143 + // Clear the log
1.144 + active->StartL();
1.145 + aClient.ClearLog(clearLogThreshold, active->iStatus);
1.146 + CActiveScheduler::Start();
1.147 + TEST2(active->iStatus.Int(), KErrNone);
1.148 +
1.149 + // Have to wait a while, since the change observer active object
1.150 + // won't run until shortly after completing the 'clear log' operation
1.151 + // request status.
1.152 + CTestTimer* timer = CTestTimer::NewL();
1.153 + CleanupStack::PushL(timer);
1.154 + timer->After(5 * 1000000);
1.155 + CActiveScheduler::Start();
1.156 + CleanupStack::PopAndDestroy(timer);
1.157 + //
1.158 + TEST2(testReceiver.CallCount(), 1);
1.159 + TEST(logClearedFlag);
1.160 +
1.161 + // Start again
1.162 + testReceiver.Reset();
1.163 +
1.164 + // Test removing observer
1.165 + aClient.SetGlobalChangeObserverL(NULL);
1.166 +
1.167 + // Add an event again
1.168 + active->StartL();
1.169 + aClient.AddEvent(*event, active->iStatus);
1.170 + CActiveScheduler::Start();
1.171 + TEST2(active->iStatus.Int(), KErrNone);
1.172 + TEST2(testReceiver.CallCount(), 0);
1.173 +
1.174 + // Make it in the past
1.175 + event->SetTime(past);
1.176 + active->StartL();
1.177 + aClient.ChangeEvent(*event, active->iStatus);
1.178 + CActiveScheduler::Start();
1.179 + TEST2(active->iStatus.Int(), KErrNone);
1.180 +
1.181 + // Clear the log again
1.182 + active->StartL();
1.183 + aClient.ClearLog(clearLogThreshold, active->iStatus);
1.184 + CActiveScheduler::Start();
1.185 + TEST2(active->iStatus.Int(), KErrNone);
1.186 + TEST2(testReceiver.CallCount(), 0);
1.187 + TEST(logClearedFlag == EFalse);
1.188 +
1.189 + aClient.SetGlobalChangeObserverL(&testReceiver);
1.190 +
1.191 + // Tidy up
1.192 + CleanupStack::PopAndDestroy(2, event); // active, event
1.193 + }
1.194 +
1.195 +/**
1.196 +@SYMTestCaseID SYSLIB-LOGENG-CT-0834
1.197 +@SYMTestCaseDesc Adding an event to the log engine test.
1.198 +@SYMTestPriority High
1.199 +@SYMTestActions Create a new event type and add that to the log engine.
1.200 + Start an active scheduler and check for the error status.
1.201 + Add the event once again and check for the already exits condition.
1.202 +@SYMTestExpectedResults Test must not fail
1.203 +@SYMREQ REQ0000
1.204 +*/
1.205 +LOCAL_C void TestAddEventTypeL(CLogClient& aClient)
1.206 +//
1.207 +//
1.208 +//
1.209 + {
1.210 + LOGTEXT("TestAddEventTypeL()");
1.211 + CLogEventType* type = CLogEventType::NewL();
1.212 + CleanupStack::PushL(type);
1.213 +
1.214 + type->SetUid(KTestEventUid);
1.215 + type->SetDescription(KTestEventDesc1);
1.216 + type->SetLoggingEnabled(ETrue);
1.217 +
1.218 + CTestActive* active = new(ELeave) CTestActive();
1.219 + CleanupStack::PushL(active);
1.220 +
1.221 + active->StartL();
1.222 + aClient.AddEventType(*type, active->iStatus);
1.223 + aClient.Cancel();
1.224 + CActiveScheduler::Start();
1.225 + TEST2(active->iStatus.Int(), KErrCancel);
1.226 +
1.227 + active->StartL();
1.228 + aClient.AddEventType(*type, active->iStatus);
1.229 + CActiveScheduler::Start();
1.230 + aClient.Cancel();
1.231 + TEST((active->iStatus == KErrNone)||(active->iStatus == KErrAlreadyExists));
1.232 +
1.233 + active->StartL();
1.234 + aClient.AddEventType(*type, active->iStatus);
1.235 + CActiveScheduler::Start();
1.236 + TEST2(active->iStatus.Int(), KErrAlreadyExists);
1.237 +
1.238 + CleanupStack::PopAndDestroy(2); // active, type
1.239 + LOGTEXT("TestAddEventTypeL() - end");
1.240 + }
1.241 +/**
1.242 +@SYMTestCaseID SYSLIB-LOGENG-CT-0835
1.243 +@SYMTestCaseDesc Retrieving the event type information test.
1.244 + Tests for CLogClient::GetEventType() function.
1.245 +@SYMTestPriority High
1.246 +@SYMTestActions Tests for the retrieved information of event type.
1.247 +@SYMTestExpectedResults Test must not fail
1.248 +@SYMREQ REQ0000
1.249 +*/
1.250 +LOCAL_C void TestGetEventTypeL(CLogClient& aClient)
1.251 +//
1.252 +//
1.253 +//
1.254 + {
1.255 + LOGTEXT("TestGetEventTypeL()");
1.256 + CLogEventType* type = CLogEventType::NewL();
1.257 + CleanupStack::PushL(type);
1.258 +
1.259 + type->SetUid(KTestEventUid);
1.260 +
1.261 + CTestActive* active = new(ELeave)CTestActive();
1.262 + CleanupStack::PushL(active);
1.263 +
1.264 + active->StartL();
1.265 + aClient.GetEventType(*type, active->iStatus);
1.266 + aClient.Cancel();
1.267 + CActiveScheduler::Start();
1.268 + TEST2(active->iStatus.Int(), KErrCancel);
1.269 +
1.270 + active->StartL();
1.271 + aClient.GetEventType(*type, active->iStatus);
1.272 + CActiveScheduler::Start();
1.273 + aClient.Cancel();
1.274 + TEST2(active->iStatus.Int(), KErrNone);
1.275 +
1.276 + TEST(type->Uid() == KTestEventUid);
1.277 + TEST(type->Description() == KTestEventDesc1);
1.278 + TEST(type->LoggingEnabled());
1.279 +
1.280 + CleanupStack::PopAndDestroy(2); // active, type
1.281 + LOGTEXT("TestGetEventTypeL() - end");
1.282 + }
1.283 +
1.284 +/**
1.285 +@SYMTestCaseID SYSLIB-LOGENG-CT-0836
1.286 +@SYMTestCaseDesc Changing the event type test.
1.287 + Tests for CLogClient::ChangeEventType test
1.288 +@SYMTestPriority High
1.289 +@SYMTestActions Create a new event type,change the event type and check for any errors
1.290 +@SYMTestExpectedResults Test must not fail
1.291 +@SYMREQ REQ0000
1.292 +*/
1.293 +LOCAL_C void TestChangeEventTypeL(CLogClient& aClient)
1.294 +//
1.295 +//
1.296 +//
1.297 + {
1.298 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0836 "));
1.299 + LOGTEXT("TestChangeEventTypeL()");
1.300 + CTestActive* active = new(ELeave)CTestActive();
1.301 + CleanupStack::PushL(active);
1.302 +
1.303 + CLogEventType* type = CLogEventType::NewL();
1.304 + CleanupStack::PushL(type);
1.305 +
1.306 + type->SetUid(KTestEventUid);
1.307 + type->SetDescription(KTestEventDesc2);
1.308 + type->SetLoggingEnabled(EFalse);
1.309 +
1.310 + active->StartL();
1.311 + aClient.ChangeEventType(*type, active->iStatus);
1.312 + aClient.Cancel();
1.313 + CActiveScheduler::Start();
1.314 + TEST2(active->iStatus.Int(), KErrCancel);
1.315 +
1.316 + active->StartL();
1.317 + aClient.ChangeEventType(*type, active->iStatus);
1.318 + CActiveScheduler::Start();
1.319 + aClient.Cancel();
1.320 + TEST2(active->iStatus.Int(), KErrNone);
1.321 +
1.322 + CleanupStack::PopAndDestroy(); // type
1.323 +
1.324 + type = CLogEventType::NewL();
1.325 + CleanupStack::PushL(type);
1.326 +
1.327 + type->SetUid(KTestEventUid);
1.328 +
1.329 + active->StartL();
1.330 + aClient.GetEventType(*type, active->iStatus);
1.331 + CActiveScheduler::Start();
1.332 + TEST2(active->iStatus.Int(), KErrNone);
1.333 +
1.334 + TEST(type->Uid() == KTestEventUid);
1.335 + TEST(type->Description() == KTestEventDesc2);
1.336 + TEST(type->LoggingEnabled() == EFalse);
1.337 +
1.338 + CleanupStack::PopAndDestroy(2); // type, active
1.339 + LOGTEXT("TestChangeEventTypeL() - end");
1.340 + }
1.341 +
1.342 +/**
1.343 +@SYMTestCaseID SYSLIB-LOGENG-CT-0837
1.344 +@SYMTestCaseDesc Deleting an event type test.
1.345 + Tests for CLogClient::DeleteEventType() test
1.346 +@SYMTestPriority High
1.347 +@SYMTestActions Delete an event type from log database and test for no errors found
1.348 +@SYMTestExpectedResults Test must not fail
1.349 +@SYMREQ REQ0000
1.350 +*/
1.351 +LOCAL_C void TestDeleteEventTypeL(CLogClient& aClient)
1.352 +//
1.353 +//
1.354 +//
1.355 + {
1.356 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0837 "));
1.357 + LOGTEXT("TestChangeEventTypeL()");
1.358 + CTestActive* active = new(ELeave)CTestActive();
1.359 + CleanupStack::PushL(active);
1.360 +
1.361 + active->StartL();
1.362 + aClient.DeleteEventType(KTestEventUid, active->iStatus);
1.363 + aClient.Cancel();
1.364 + CActiveScheduler::Start();
1.365 + TEST2(active->iStatus.Int(), KErrCancel);
1.366 +
1.367 + active->StartL();
1.368 + aClient.DeleteEventType(KTestEventUid, active->iStatus);
1.369 + CActiveScheduler::Start();
1.370 + aClient.Cancel();
1.371 + TEST2(active->iStatus.Int(), KErrNone);
1.372 +
1.373 + CLogEventType* type = CLogEventType::NewL();
1.374 + CleanupStack::PushL(type);
1.375 +
1.376 + type->SetUid(KTestEventUid);
1.377 +
1.378 + active->StartL();
1.379 + aClient.GetEventType(*type, active->iStatus);
1.380 + CActiveScheduler::Start();
1.381 + TEST2(active->iStatus.Int(), KErrNotFound);
1.382 +
1.383 + CleanupStack::PopAndDestroy(2); // type, active
1.384 + LOGTEXT("TestChangeEventTypeL() - end");
1.385 + }
1.386 +
1.387 +/**
1.388 +@SYMTestCaseID SYSLIB-LOGENG-CT-1329
1.389 +@SYMTestCaseDesc Adding an event type test.
1.390 + Tests for CLogClient::AddEventType() function
1.391 +@SYMTestPriority High
1.392 +@SYMTestActions Add an event type to the log database and test for no errors found
1.393 +@SYMTestExpectedResults Test must not fail
1.394 +@SYMREQ REQ0000
1.395 +*/
1.396 +LOCAL_C void TestAddEventL(CLogClient& aClient)
1.397 +//
1.398 +//
1.399 +//
1.400 + {
1.401 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-1329 "));
1.402 + CLogEventType* type = CLogEventType::NewL();
1.403 + CleanupStack::PushL(type);
1.404 +
1.405 + type->SetUid(KTestEventUid);
1.406 + type->SetDescription(KTestEventDesc1);
1.407 + type->SetLoggingEnabled(ETrue);
1.408 +
1.409 + CTestActive* active = new(ELeave)CTestActive();
1.410 + CleanupStack::PushL(active);
1.411 +
1.412 + active->StartL();
1.413 + aClient.AddEventType(*type, active->iStatus);
1.414 + CActiveScheduler::Start();
1.415 + TEST2(active->iStatus.Int(), KErrNone);
1.416 +
1.417 + CLogEvent* event = CLogEvent::NewL();
1.418 + CleanupStack::PushL(event);
1.419 +
1.420 + // Reset
1.421 + gTheId = KLogNullId;
1.422 + //
1.423 + TTime now;
1.424 + now.UniversalTime();
1.425 +
1.426 + event->SetEventType(KTestEventUid);
1.427 + event->SetRemoteParty(KTestRemoteParty1);
1.428 + event->SetDirection(KTestDirection1);
1.429 + event->SetDurationType(KTestDurationType1);
1.430 + event->SetDuration(KTestDuration1);
1.431 + event->SetStatus(KTestStatus1);
1.432 + event->SetSubject(KTestSubject1);
1.433 + event->SetNumber(KTestNumber1);
1.434 + event->SetContact(KTestContact1);
1.435 + event->SetLink(KTestLink1);
1.436 + event->SetDataL(KTestData1);
1.437 + event->SetFlags(KTestFlags1);
1.438 + //
1.439 + active->StartL();
1.440 + aClient.AddEvent(*event, active->iStatus);
1.441 + aClient.Cancel();
1.442 + CActiveScheduler::Start();
1.443 + TEST2(active->iStatus.Int(), KErrCancel);
1.444 + //
1.445 + active->StartL();
1.446 + aClient.AddEvent(*event, active->iStatus);
1.447 + CActiveScheduler::Start();
1.448 + TEST(!active->IsActive());
1.449 + aClient.Cancel();
1.450 + TEST2(active->iStatus.Int(), KErrNone);
1.451 + //
1.452 + gTheId=event->Id();
1.453 + //
1.454 + TEST(gTheId != KLogNullId);
1.455 + TEST(event->Time() >= now);
1.456 + TEST(event->Description() == KTestEventDesc1);
1.457 + //
1.458 + CleanupStack::PopAndDestroy(3); // event, active, type
1.459 + }
1.460 +
1.461 +/**
1.462 +@SYMTestCaseID SYSLIB-LOGENG-CT-0838
1.463 +@SYMTestCaseDesc Client failure test
1.464 +@SYMTestPriority High
1.465 +@SYMTestActions Checks for status after client is deleted,checks for Cancel error flag
1.466 +@SYMTestExpectedResults Test must not fail
1.467 +@SYMREQ REQ0000
1.468 +*/
1.469 +LOCAL_C void TestClientFailL()
1.470 + {
1.471 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0838 "));
1.472 + CLogEvent* event = CLogEvent::NewL();
1.473 + CleanupStack::PushL(event);
1.474 +
1.475 + CTestActive* active = new(ELeave)CTestActive();
1.476 + CleanupStack::PushL(active);
1.477 +
1.478 + CLogClient* client = CLogClient::NewL(theFs);
1.479 + CleanupStack::PushL(client);
1.480 +
1.481 + event->SetId(gTheId);
1.482 +
1.483 + active->StartL();
1.484 + client->GetEvent(*event, active->iStatus);
1.485 + CleanupStack::Pop(); // client
1.486 + delete client;
1.487 +
1.488 + CActiveScheduler::Start();
1.489 + TEST2(active->iStatus.Int(), KErrCancel);
1.490 +
1.491 + CleanupStack::PopAndDestroy(2); // event, active
1.492 + }
1.493 +
1.494 +/**
1.495 +@SYMTestCaseID SYSLIB-LOGENG-CT-0839
1.496 +@SYMTestCaseDesc Tests for CLogClient::GetEvent() function
1.497 +@SYMTestPriority High
1.498 +@SYMTestActions Retrieve the event type and test for the integrity of the event type information
1.499 + Check for no errors
1.500 +@SYMTestExpectedResults Test must not fail
1.501 +@SYMREQ REQ0000
1.502 +*/
1.503 +
1.504 +LOCAL_C void TestGetEventL(CLogClient& aClient)
1.505 +//
1.506 +//
1.507 +//
1.508 + {
1.509 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0839 "));
1.510 + CTestActive* active = new(ELeave)CTestActive();
1.511 + CleanupStack::PushL(active);
1.512 +
1.513 + CLogEvent* event = CLogEvent::NewL();
1.514 + CleanupStack::PushL(event);
1.515 +
1.516 + event->SetId(gTheId);
1.517 +
1.518 + active->StartL();
1.519 + aClient.GetEvent(*event, active->iStatus);
1.520 + aClient.Cancel();
1.521 + CActiveScheduler::Start();
1.522 + TEST2(active->iStatus.Int(), KErrCancel);
1.523 +
1.524 + active->StartL();
1.525 + aClient.GetEvent(*event, active->iStatus);
1.526 + CActiveScheduler::Start();
1.527 + aClient.Cancel();
1.528 + TEST2(active->iStatus.Int(), KErrNone);
1.529 +
1.530 + TEST(event->Id() == gTheId);
1.531 + TEST(event->Time() > TTime(0));
1.532 + TEST(event->Description() == KTestEventDesc1);
1.533 + TEST(event->EventType() == KTestEventUid);
1.534 + TEST(event->RemoteParty() == KTestRemoteParty1);
1.535 + TEST(event->Direction() == KTestDirection1);
1.536 + TEST(event->DurationType() == KTestDurationType1);
1.537 + TEST(event->Duration() == KTestDuration1);
1.538 + TEST(event->Status() == KTestStatus1);
1.539 + TEST(event->Subject() == KTestSubject1);
1.540 + TEST(event->Number() == KTestNumber1);
1.541 + TEST(event->Contact() == KTestContact1);
1.542 + TEST(event->Link() == KTestLink1);
1.543 + TEST(event->Data() == KTestData1);
1.544 + TEST(event->Flags() == KTestFlags1);
1.545 +
1.546 + TBuf<500> subject;
1.547 + TInt i=450;
1.548 + while(i--)
1.549 + subject.Append(_L("a"));
1.550 + event->SetSubject(subject);
1.551 +
1.552 + active->StartL();
1.553 + aClient.AddEvent(*event, active->iStatus);
1.554 + CActiveScheduler::Start();
1.555 + if (aClient.IsActive() && active->iStatus == KRequestPending)
1.556 + {
1.557 + aClient.Cancel();
1.558 + CActiveScheduler::Start();
1.559 + TEST2(active->iStatus.Int(), KErrCancel);
1.560 + }
1.561 + else
1.562 + {
1.563 + TEST2(active->iStatus.Int(), KErrNone);
1.564 + }
1.565 +
1.566 + // See TestAddEventL on why this might still allow the active object
1.567 + // to be cancelled.
1.568 +// TEST(active->iStatus == KErrNone || active->iStatus == KErrCancel);
1.569 +
1.570 + i=450;
1.571 + while(i--)
1.572 + subject[i]='b';
1.573 + event->SetSubject(subject);
1.574 +
1.575 + active->StartL();
1.576 + aClient.GetEvent(*event, active->iStatus);
1.577 + CActiveScheduler::Start();
1.578 + aClient.Cancel();
1.579 + TEST2(active->iStatus.Int(), KErrNone);
1.580 +
1.581 +
1.582 + CleanupStack::PopAndDestroy(2); // event, active
1.583 + }
1.584 +
1.585 +/**
1.586 +@SYMTestCaseID SYSLIB-LOGENG-CT-0840
1.587 +@SYMTestCaseDesc Tests for CLogClient::ChangeEvent() function
1.588 +@SYMTestPriority High
1.589 +@SYMTestActions Change the event,get the event information and test for the integrity.
1.590 + Check for any errors.
1.591 +@SYMTestExpectedResults Test must not fail
1.592 +@SYMREQ REQ0000
1.593 +*/
1.594 +LOCAL_C void TestChangeEventL(CLogClient& aClient)
1.595 +//
1.596 +//
1.597 +//
1.598 + {
1.599 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0840 "));
1.600 + CTestActive* active = new(ELeave)CTestActive();
1.601 + CleanupStack::PushL(active);
1.602 +
1.603 + CLogEvent* event = CLogEvent::NewL();
1.604 + CleanupStack::PushL(event);
1.605 +
1.606 + TTime now;
1.607 + now.UniversalTime();
1.608 +
1.609 + event->SetId(gTheId);
1.610 + event->SetTime(now);
1.611 + event->SetRemoteParty(KTestRemoteParty2);
1.612 + event->SetDirection(KTestDirection2);
1.613 + event->SetDurationType(KTestDurationType2);
1.614 + event->SetDuration(KTestDuration2);
1.615 + event->SetStatus(KTestStatus2);
1.616 + event->SetSubject(KTestSubject2);
1.617 + event->SetNumber(KTestNumber2);
1.618 + event->SetContact(KTestContact2);
1.619 + event->SetLink(KTestLink2);
1.620 + event->SetDataL(KTestData2);
1.621 + event->SetFlags(KTestFlags2);
1.622 +
1.623 + active->StartL();
1.624 + aClient.ChangeEvent(*event, active->iStatus);
1.625 + aClient.Cancel();
1.626 + CActiveScheduler::Start();
1.627 + TEST2(active->iStatus.Int(), KErrCancel);
1.628 +
1.629 + active->StartL();
1.630 + aClient.ChangeEvent(*event, active->iStatus);
1.631 + CActiveScheduler::Start();
1.632 + aClient.Cancel();
1.633 + TEST2(active->iStatus.Int(), KErrNone);
1.634 +
1.635 + CleanupStack::PopAndDestroy(); // event
1.636 +
1.637 + event = CLogEvent::NewL();
1.638 + CleanupStack::PushL(event);
1.639 +
1.640 + event->SetId(gTheId);
1.641 +
1.642 + active->StartL();
1.643 + aClient.GetEvent(*event, active->iStatus);
1.644 + CActiveScheduler::Start();
1.645 + TEST2(active->iStatus.Int(), KErrNone);
1.646 +
1.647 + TEST(event->Id() == gTheId);
1.648 + TEST(event->Time() == now);
1.649 + TEST(event->Description() == KTestEventDesc1);
1.650 + TEST(event->EventType() == KTestEventUid);
1.651 + TEST(event->RemoteParty() == KTestRemoteParty2);
1.652 + TEST(event->Direction() == KTestDirection2);
1.653 + TEST(event->DurationType() == KTestDurationType2);
1.654 + TEST(event->Duration() == KTestDuration2);
1.655 + TEST(event->Status() == KTestStatus2);
1.656 + TEST(event->Subject() == KTestSubject2);
1.657 + TEST(event->Number() == KTestNumber2);
1.658 + TEST(event->Contact() == KTestContact2);
1.659 + TEST(event->Link() == KTestLink2);
1.660 + TEST(event->Data() == KTestData2);
1.661 + TEST(event->Flags() == KTestFlags2);
1.662 +
1.663 + CleanupStack::PopAndDestroy(2); // event, active
1.664 + }
1.665 +
1.666 +/**
1.667 +@SYMTestCaseID SYSLIB-LOGENG-CT-0841
1.668 +@SYMTestCaseDesc Tests for CLogClient::DeleteEvent() function
1.669 +@SYMTestPriority High
1.670 +@SYMTestActions Delete the event and test for no errors found.
1.671 +@SYMTestExpectedResults Test must not fail
1.672 +@SYMREQ REQ0000
1.673 +*/
1.674 +LOCAL_C void TestDeleteEventL(CLogClient& aClient)
1.675 +//
1.676 +//
1.677 +//
1.678 + {
1.679 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0841 "));
1.680 + CTestActive* active = new(ELeave)CTestActive();
1.681 + CleanupStack::PushL(active);
1.682 +
1.683 + active->StartL();
1.684 + aClient.DeleteEvent(0, active->iStatus);
1.685 + aClient.Cancel();
1.686 + CActiveScheduler::Start();
1.687 + TEST2(active->iStatus.Int(), KErrCancel);
1.688 +
1.689 + active->StartL();
1.690 + aClient.DeleteEvent(0, active->iStatus);
1.691 + CActiveScheduler::Start();
1.692 + aClient.Cancel();
1.693 + TEST2(active->iStatus.Int(), KErrNone);
1.694 +
1.695 + CLogEvent* event = CLogEvent::NewL();
1.696 + CleanupStack::PushL(event);
1.697 +
1.698 + event->SetId(0);
1.699 +
1.700 + active->StartL();
1.701 + aClient.GetEvent(*event, active->iStatus);
1.702 + CActiveScheduler::Start();
1.703 + TEST2(active->iStatus.Int(), KErrNotFound);
1.704 +
1.705 + CleanupStack::PopAndDestroy(2); // event, active
1.706 + }
1.707 +
1.708 +
1.709 +#ifdef SYSLIBS_TEST
1.710 +
1.711 +/**
1.712 +@SYMTestCaseID SYSLIB-LOGENG-UT-4015
1.713 +@SYMTestCaseDesc Test the behaviour implemented by PREQ2103
1.714 +@SYMTestPriority Medium
1.715 +@SYMTestActions Get the settings from logeng repository file / resource file.
1.716 +@SYMTestExpectedResults Test must not fail
1.717 +@SYMREQ REQ11125
1.718 + REQ11126
1.719 + REQ11127
1.720 + REQ11128
1.721 +*/
1.722 +LOCAL_C void TestGetConfigSettingsFromRepositoryFileL(CLogClient& aClient)
1.723 + {
1.724 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-UT-4015 "));
1.725 +
1.726 + TInt contactMatchCount1;
1.727 + TLogContactNameFormat contactNameFormat1;
1.728 + LogGetContactmatchCountAndNameFormatL(contactMatchCount1, contactNameFormat1);
1.729 + TheTest.Printf(_L("Contact match count = %d, contact name format = %d\r\n"), contactMatchCount1, (TInt)contactNameFormat1);
1.730 + //contactMatchCount1 and contactNameFormat1 are loaded directly from the repository, if exists.
1.731 + //Otherwise they are initialzied with their default values.
1.732 + //The LogEng server should load these resource values in a similar way.
1.733 + //They will be stored in contactMatchCount2 and contactNameFormat2.
1.734 + TInt16 contactMatchCount2;
1.735 + TInt16 contactNameFormat2;
1.736 + RFs fs;
1.737 +
1.738 + LEAVE_IF_ERROR(fs.Connect());
1.739 + CleanupClosePushL(fs);
1.740 +
1.741 + //Creating a new CLogClient Object make the server getting the contact match settings.
1.742 + //As the database is deleted it gets them from the LogEng repository.
1.743 + CLogClient* client2 = CLogClient::NewL(fs);
1.744 + CleanupStack::PushL(client2);
1.745 + CleanupStack::PopAndDestroy(client2);
1.746 +
1.747 + //Read these settings via "reader" object.
1.748 + RFileReadStream resFileCount_reader;
1.749 + CleanupClosePushL(resFileCount_reader);
1.750 + RFileReadStream resFileFormat_reader;
1.751 + CleanupClosePushL(resFileFormat_reader);
1.752 + _LIT(KLogengTestFileNameCount, "c:\\test\\test_logengconfig_count.ini");
1.753 + _LIT(KLogengTestFileNameFormat, "c:\\test\\test_logengconfig_format.ini");
1.754 + LEAVE_IF_ERROR(resFileCount_reader.Open(fs, KLogengTestFileNameCount, EFileRead));
1.755 + LEAVE_IF_ERROR(resFileFormat_reader.Open(fs, KLogengTestFileNameFormat, EFileRead));
1.756 + contactMatchCount2 = resFileCount_reader.ReadInt32L();
1.757 + contactNameFormat2 = resFileFormat_reader.ReadInt32L();
1.758 +
1.759 + //The settings should match the ones from resource file.
1.760 + TEST2(contactMatchCount1, contactMatchCount2);
1.761 + TEST2(contactNameFormat1, contactNameFormat2);
1.762 +
1.763 + CleanupStack::PopAndDestroy(&resFileFormat_reader);
1.764 + CleanupStack::PopAndDestroy(&resFileCount_reader);
1.765 +
1.766 + //Get the config settings (Three config settings).
1.767 +
1.768 + CTestActive* active = new(ELeave)CTestActive();
1.769 + CleanupStack::PushL(active);
1.770 +
1.771 + TLogConfig config;
1.772 + TEST(config.iMaxEventAge == 0);
1.773 + TEST(config.iMaxLogSize == 0);
1.774 + TEST(config.iMaxRecentLogSize == 0);
1.775 + active->StartL();
1.776 + aClient.GetConfig(config, active->iStatus);
1.777 + CActiveScheduler::Start();
1.778 + TEST2(active->iStatus.Int(), KErrNone);
1.779 +
1.780 + //The config settings should match the ones from the repository.
1.781 + TEST(config.iMaxEventAge == 2592000);
1.782 + TEST(config.iMaxLogSize == 1000);
1.783 + TEST(config.iMaxRecentLogSize == 20);
1.784 +
1.785 +
1.786 + //Now let's provide the repository file, so the server will find it and will get the settings
1.787 + //from it.
1.788 +
1.789 + //Create the directory c:\private\10202be9\ if it does not exist.
1.790 + _LIT(KExecutableFileName, "t_logapi_helper.exe");
1.791 + _LIT(KCommandParameters, "c:\\private\\10202be9\\;c:\\private\\10202be9\\101f401d.txt;3");
1.792 + RProcess process;
1.793 + TRequestStatus processWaitStatus;
1.794 + TInt r = process.Create(KExecutableFileName, KCommandParameters);
1.795 + TEST(r == KErrNone);
1.796 + process.Logon(processWaitStatus);
1.797 + process.Resume();
1.798 + User::WaitForRequest(processWaitStatus);
1.799 + TEST(processWaitStatus.Int() == KErrNone);
1.800 + process.Close();
1.801 +
1.802 + //copy the repository file to the folder 10202be9
1.803 + _LIT(KCommandParameters1, "z:\\test\\101f401d_TEST.txt;c:\\private\\10202be9\\101f401d.txt;0");
1.804 + r = process.Create(KExecutableFileName, KCommandParameters1);
1.805 + TEST(r == KErrNone);
1.806 + process.Logon(processWaitStatus);
1.807 + process.Resume();
1.808 + User::WaitForRequest(processWaitStatus);
1.809 + TEST(processWaitStatus.Int() == KErrNone);
1.810 + process.Close();
1.811 +
1.812 + TestUtils::DeleteDatabaseL();
1.813 +
1.814 + //Get the config settings.
1.815 + config.iMaxEventAge = 0;
1.816 + config.iMaxLogSize = 0;
1.817 + config.iMaxRecentLogSize = 0;
1.818 + active->StartL();
1.819 + aClient.GetConfig(config, active->iStatus);
1.820 + CActiveScheduler::Start();
1.821 + TEST2(active->iStatus.Int(), KErrNone);
1.822 +
1.823 + //They should match the ones from the repository file.
1.824 + TEST(config.iMaxEventAge == 2592001);
1.825 + TEST(config.iMaxLogSize == 1001);
1.826 + TEST(config.iMaxRecentLogSize == 21);
1.827 +
1.828 + CleanupStack::PopAndDestroy(active);
1.829 +
1.830 + //Get the contact match count and the contact name format.
1.831 + RFileReadStream repFileCount_reader;
1.832 + CleanupClosePushL(repFileCount_reader);
1.833 + RFileReadStream repFileFormat_reader;
1.834 + CleanupClosePushL(repFileFormat_reader);
1.835 + LEAVE_IF_ERROR(repFileCount_reader.Open(fs, KLogengTestFileNameCount, EFileRead));
1.836 + LEAVE_IF_ERROR(repFileFormat_reader.Open(fs, KLogengTestFileNameFormat, EFileRead));
1.837 + contactMatchCount2 = repFileCount_reader.ReadInt32L();
1.838 + contactNameFormat2 = repFileFormat_reader.ReadInt32L();
1.839 + CleanupStack::PopAndDestroy(&repFileFormat_reader);
1.840 + CleanupStack::PopAndDestroy(&repFileCount_reader);
1.841 + CleanupStack::PopAndDestroy(&fs);
1.842 +
1.843 + //The values should match the ones from the repository file.
1.844 + TEST(contactMatchCount2 == 6);
1.845 + TEST(contactNameFormat2 == 1);
1.846 +
1.847 + //delete the repository file c:\\private\\10202be9\\101f401d.txt.
1.848 + _LIT(KCommandParameters2, "c:\\private\\10202be9\\101f401d.txt;private\\10202be9\101f401d.txt;2");
1.849 + r = process.Create(KExecutableFileName, KCommandParameters2);
1.850 + TEST(r == KErrNone);
1.851 + process.Logon(processWaitStatus);
1.852 + process.Resume();
1.853 + User::WaitForRequest(processWaitStatus);
1.854 + TEST(processWaitStatus.Int() == KErrNone);
1.855 + process.Close();
1.856 +
1.857 + theLog.Write(_L8("Deleting the Log engine database... \n"));
1.858 + TestUtils::DeleteDatabaseL();
1.859 + TheTest.Next(_L("Delay of 2 min, the necessary time to central repository to unload its cache... "));
1.860 + User::After(125000000); // Delay to time to cenrep to unload its cache.
1.861 + }
1.862 +#endif
1.863 +
1.864 +
1.865 +/**
1.866 +@SYMTestCaseID SYSLIB-LOGENG-CT-0842
1.867 +@SYMTestCaseDesc Tests for retrieving the log engine configuration data
1.868 +@SYMTestPriority High
1.869 +@SYMTestActions Tests for CLogClient::GetConfig() function,check for the integrity of the data
1.870 +@SYMTestExpectedResults Test must not fail
1.871 +@SYMREQ REQ0000
1.872 +*/
1.873 +LOCAL_C void TestGetConfigL(CLogClient& aClient)
1.874 +//
1.875 +//
1.876 +//
1.877 + {
1.878 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0842 "));
1.879 + CTestActive* active = new(ELeave)CTestActive();
1.880 + CleanupStack::PushL(active);
1.881 +
1.882 + TLogConfig config;
1.883 +
1.884 + TEST(config.iMaxEventAge == 0);
1.885 + TEST(config.iMaxLogSize == 0);
1.886 + TEST(config.iMaxRecentLogSize == 0);
1.887 +
1.888 + active->StartL();
1.889 + aClient.GetConfig(config, active->iStatus);
1.890 + aClient.Cancel();
1.891 + CActiveScheduler::Start();
1.892 + TEST2(active->iStatus.Int(), KErrCancel);
1.893 +
1.894 + active->StartL();
1.895 + aClient.GetConfig(config, active->iStatus);
1.896 + CActiveScheduler::Start();
1.897 + aClient.Cancel();
1.898 + TEST2(active->iStatus.Int(), KErrNone);
1.899 +
1.900 + TEST(config.iMaxEventAge > 0);
1.901 + TEST(config.iMaxLogSize > 0);
1.902 + TEST(config.iMaxRecentLogSize > 0);
1.903 +
1.904 + CleanupStack::PopAndDestroy(); // active
1.905 + }
1.906 +
1.907 +/**
1.908 +@SYMTestCaseID SYSLIB-LOGENG-CT-0843
1.909 +@SYMTestCaseDesc Tests for CLogClient::ChangeConfig() function
1.910 +@SYMTestPriority High
1.911 +@SYMTestActions Change the configuration data and test for the integrity.
1.912 +@SYMTestExpectedResults Test must not fail
1.913 +@SYMREQ REQ0000
1.914 +*/
1.915 +LOCAL_C void TestChangeConfigL(CLogClient& aClient)
1.916 +//
1.917 +//
1.918 +//
1.919 + {
1.920 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0843 "));
1.921 + CTestActive* active = new(ELeave)CTestActive();
1.922 + CleanupStack::PushL(active);
1.923 +
1.924 + TLogConfig config;
1.925 +
1.926 + config.iMaxLogSize = KTestMaxLogSize;
1.927 + config.iMaxRecentLogSize = KTestMaxRecentLogSize;
1.928 + config.iMaxEventAge = KTestMaxEventAge;
1.929 +
1.930 + active->StartL();
1.931 + aClient.ChangeConfig(config, active->iStatus);
1.932 + aClient.Cancel();
1.933 + CActiveScheduler::Start();
1.934 + TEST2(active->iStatus.Int(), KErrCancel);
1.935 +
1.936 + active->StartL();
1.937 + aClient.ChangeConfig(config, active->iStatus);
1.938 + CActiveScheduler::Start();
1.939 + aClient.Cancel();
1.940 + TEST2(active->iStatus.Int(), KErrNone);
1.941 +
1.942 + TEST(config.iMaxLogSize == KTestMaxLogSize);
1.943 + TEST(config.iMaxRecentLogSize == KTestMaxRecentLogSize);
1.944 + TEST(config.iMaxEventAge == KTestMaxEventAge);
1.945 +
1.946 + CleanupStack::PopAndDestroy(); // active
1.947 + }
1.948 +
1.949 +/**
1.950 +@SYMTestCaseID SYSLIB-LOGENG-CT-0844
1.951 +@SYMTestCaseDesc Tests for CLogClient::GetString() function
1.952 +@SYMTestPriority High
1.953 +@SYMTestActions Get the string from the resource file and check for no errors and the zero string length
1.954 +@SYMTestExpectedResults Test must not fail
1.955 +@SYMREQ REQ0000
1.956 +*/
1.957 +LOCAL_C void TestGetStringL(CLogClient& aClient)
1.958 +//
1.959 +//
1.960 +//
1.961 + {
1.962 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0844 "));
1.963 + TBuf<KLogMaxSharedStringLength> str;
1.964 +
1.965 + TInt err = aClient.GetString(str, R_LOG_DIR_IN);
1.966 + TEST2(err, KErrNone);
1.967 + TEST(str.Length() > 0);
1.968 + str.Zero();
1.969 +
1.970 + err = aClient.GetString(str, R_LOG_DIR_OUT);
1.971 + TEST2(err, KErrNone);
1.972 + TEST(str.Length() > 0);
1.973 + str.Zero();
1.974 +
1.975 + err = aClient.GetString(str, R_LOG_DIR_IN_ALT);
1.976 + TEST2(err, KErrNone);
1.977 + TEST(str.Length() > 0);
1.978 + str.Zero();
1.979 +
1.980 + err = aClient.GetString(str, R_LOG_DIR_OUT_ALT);
1.981 + TEST2(err, KErrNone);
1.982 + TEST(str.Length() > 0);
1.983 + str.Zero();
1.984 +
1.985 + err = aClient.GetString(str, R_LOG_DIR_FETCHED);
1.986 + TEST2(err, KErrNone);
1.987 + TEST(str.Length() > 0);
1.988 + str.Zero();
1.989 +
1.990 + err = aClient.GetString(str, R_LOG_DIR_MISSED);
1.991 + TEST2(err, KErrNone);
1.992 + TEST(str.Length() > 0);
1.993 + str.Zero();
1.994 +
1.995 + err = aClient.GetString(str, R_LOG_DEL_PENDING);
1.996 + TEST2(err, KErrNone);
1.997 + TEST(str.Length() > 0);
1.998 + str.Zero();
1.999 +
1.1000 + err = aClient.GetString(str, R_LOG_DEL_SENT);
1.1001 + TEST2(err, KErrNone);
1.1002 + TEST(str.Length() > 0);
1.1003 + str.Zero();
1.1004 +
1.1005 + err = aClient.GetString(str, R_LOG_DEL_FAILED);
1.1006 + TEST2(err, KErrNone);
1.1007 + TEST(str.Length() > 0);
1.1008 + str.Zero();
1.1009 +
1.1010 + err = aClient.GetString(str, R_LOG_DEL_NONE);
1.1011 + TEST2(err, KErrNone);
1.1012 + TEST(str.Length() > 0);
1.1013 + str.Zero();
1.1014 +
1.1015 + err = aClient.GetString(str, R_LOG_DEL_DONE);
1.1016 + TEST2(err, KErrNone);
1.1017 + TEST(str.Length() > 0);
1.1018 + str.Zero();
1.1019 +
1.1020 + err = aClient.GetString(str, R_LOG_DEL_NOT_SENT);
1.1021 + TEST2(err, KErrNone);
1.1022 + TEST(str.Length() > 0);
1.1023 + str.Zero();
1.1024 +
1.1025 + err = aClient.GetString(str, R_LOG_DEL_NOTIFIED);
1.1026 + TEST2(err, KErrNone);
1.1027 + TEST(str.Length() > 0);
1.1028 + str.Zero();
1.1029 +
1.1030 + err = aClient.GetString(str, R_LOG_DEL_EXPIRED);
1.1031 + TEST2(err, KErrNone);
1.1032 + TEST(str.Length() > 0);
1.1033 + str.Zero();
1.1034 +
1.1035 + err = aClient.GetString(str, R_LOG_REMOTE_UNKNOWN);
1.1036 + TEST2(err, KErrNone);
1.1037 + TEST(str.Length() > 0);
1.1038 + str.Zero();
1.1039 +
1.1040 + err = aClient.GetString(str, R_LOG_REMOTE_MULTIPLE);
1.1041 + TEST2(err, KErrNone);
1.1042 + TEST(str.Length() > 0);
1.1043 + str.Zero();
1.1044 +
1.1045 + err = aClient.GetString(str, R_LOG_SUBJECT_NONE);
1.1046 + TEST2(err, KErrNone);
1.1047 + TEST(str.Length() > 0);
1.1048 + str.Zero();
1.1049 + }
1.1050 +
1.1051 +/**
1.1052 +@SYMTestCaseID SYSLIB-LOGENG-CT-0845
1.1053 +@SYMTestCaseDesc Tests for clearing the event types from the log
1.1054 +@SYMTestPriority High
1.1055 +@SYMTestActions Clear the event types from the log and check for event not found error.
1.1056 +@SYMTestExpectedResults Test must not fail
1.1057 +@SYMREQ REQ0000
1.1058 +*/
1.1059 +LOCAL_C void TestClearEventLogL(CLogClient& aClient)
1.1060 + {
1.1061 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0845 "));
1.1062 + TTime now;
1.1063 + now.UniversalTime();
1.1064 + TDateTime d = now.DateTime();
1.1065 + TheTest.Printf(_L("TimeNow: Y=%d, M=%d, D=%d, H=%d, M=%d, S=%d\n"), d.Year(), d.Month() + 1, d.Day() + 1, d.Hour(), d.Minute(), d.Second());
1.1066 +
1.1067 + TTime date1(now);
1.1068 + date1 -= TTimeIntervalDays(1);
1.1069 +
1.1070 + TTime date2(date1);
1.1071 + date2 -= TTimeIntervalDays(1);
1.1072 +
1.1073 + CTestActive* active = new(ELeave)CTestActive();
1.1074 + CleanupStack::PushL(active);
1.1075 +
1.1076 + //////////////////////////////////////////////////////////////////////////////
1.1077 + //Clear all events before (current date). Actually - all events!
1.1078 + active->StartL();
1.1079 + aClient.ClearLog(now, active->iStatus);
1.1080 + CActiveScheduler::Start();
1.1081 + TEST2(active->iStatus.Int(), KErrNone);
1.1082 +
1.1083 + //////////////////////////////////////////////////////////////////////////////
1.1084 + //The next part of the test will create 4 events:
1.1085 + //-event1 and event2 will have time = current date - 1 day + 10 seconds;
1.1086 + //-event3 and event4 will have time = current date - 2 days;
1.1087 + //The test is:
1.1088 + //ClearLog - Delete all events, which time is less or equal to current date - 1 day.
1.1089 + //Check - event3 and event4 should disappear, event1 and event2 should stay.
1.1090 + //ClearLog - Delete all events, which time is less or equal to current date.
1.1091 + //Check - event1 and event2 should disappear too.
1.1092 + //
1.1093 + //The "10 seconds" addition is very important. The creation of the 4 events is
1.1094 + //an operation, which is performed very quickly. It is possible that the
1.1095 + //first ClearLog operation will be executed at the same second at which the events
1.1096 + //were created. Which means, that all events will be deleted and the next check
1.1097 + //for the presence of event1 and event2 will fail.
1.1098 +
1.1099 + //////////////////////////////////////////////////////////////////////////////
1.1100 + //Create and add new event - event1.
1.1101 + //Set event1 date to be (current date - 1 day + 10 seconds).
1.1102 + CLogEvent* event1 = CLogEvent::NewL();
1.1103 + CleanupStack::PushL(event1);
1.1104 +
1.1105 + event1->SetEventType(KTestEventUid);
1.1106 + active->StartL();
1.1107 + aClient.AddEvent(*event1, active->iStatus);
1.1108 + CActiveScheduler::Start();
1.1109 + TEST2(active->iStatus.Int(), KErrNone);
1.1110 +
1.1111 + TTimeIntervalSeconds tenSeconds(10);
1.1112 + event1->SetTime(date1 + tenSeconds);
1.1113 + active->StartL();
1.1114 + aClient.ChangeEvent(*event1, active->iStatus);
1.1115 + CActiveScheduler::Start();
1.1116 + TEST2(active->iStatus.Int(), KErrNone);
1.1117 +
1.1118 + //////////////////////////////////////////////////////////////////////////////
1.1119 + //Create and add new event - event2.
1.1120 + //Set event2 date to be (current date - 1 day + 10 seconds).
1.1121 + CLogEvent* event2 = CLogEvent::NewL();
1.1122 + CleanupStack::PushL(event2);
1.1123 +
1.1124 + event2->SetEventType(KTestEventUid);
1.1125 + active->StartL();
1.1126 + aClient.AddEvent(*event2, active->iStatus);
1.1127 + CActiveScheduler::Start();
1.1128 + TEST2(active->iStatus.Int(), KErrNone);
1.1129 +
1.1130 + event2->SetTime(date1 + tenSeconds);
1.1131 + active->StartL();
1.1132 + aClient.ChangeEvent(*event2, active->iStatus);
1.1133 + CActiveScheduler::Start();
1.1134 + TEST2(active->iStatus.Int(), KErrNone);
1.1135 +
1.1136 + //////////////////////////////////////////////////////////////////////////////
1.1137 + //Create and add new event - event3.
1.1138 + //Set event3 date to be (current date - 2 days).
1.1139 + CLogEvent* event3 = CLogEvent::NewL();
1.1140 + CleanupStack::PushL(event3);
1.1141 + event3->SetEventType(KTestEventUid);
1.1142 +
1.1143 + active->StartL();
1.1144 + aClient.AddEvent(*event3, active->iStatus);
1.1145 + CActiveScheduler::Start();
1.1146 + TEST2(active->iStatus.Int(), KErrNone);
1.1147 +
1.1148 + event3->SetTime(date2);
1.1149 + active->StartL();
1.1150 + aClient.ChangeEvent(*event3, active->iStatus);
1.1151 + CActiveScheduler::Start();
1.1152 + TEST2(active->iStatus.Int(), KErrNone);
1.1153 +
1.1154 + //////////////////////////////////////////////////////////////////////////////
1.1155 + //Create and add new event - event4.
1.1156 + //Set event4 date to be (current date - 2 days).
1.1157 + CLogEvent* event4 = CLogEvent::NewL();
1.1158 + CleanupStack::PushL(event4);
1.1159 + event4->SetEventType(KTestEventUid);
1.1160 +
1.1161 + active->StartL();
1.1162 + aClient.AddEvent(*event4, active->iStatus);
1.1163 + CActiveScheduler::Start();
1.1164 + TEST2(active->iStatus.Int(), KErrNone);
1.1165 +
1.1166 + event4->SetTime(date2);
1.1167 + active->StartL();
1.1168 + aClient.ChangeEvent(*event4, active->iStatus);
1.1169 + CActiveScheduler::Start();
1.1170 + TEST2(active->iStatus.Int(), KErrNone);
1.1171 +
1.1172 + //////////////////////////////////////////////////////////////////////////////
1.1173 + //Clear all events before (current date - 1 day).
1.1174 + //Then cancel the operation.
1.1175 + TheTest.Printf(_L("=.= ClearLog 1\n"));
1.1176 + active->StartL();
1.1177 + aClient.ClearLog(date1, active->iStatus);
1.1178 + aClient.Cancel();
1.1179 + CActiveScheduler::Start();
1.1180 + TEST2(active->iStatus.Int(), KErrCancel);
1.1181 +
1.1182 + //////////////////////////////////////////////////////////////////////////////
1.1183 + //Clear all events before (current date - 1 day).
1.1184 + //event3 and event4 should be removed.
1.1185 + TheTest.Printf(_L("=.= ClearLog 2\n"));
1.1186 + active->StartL();
1.1187 + aClient.ClearLog(date1, active->iStatus);
1.1188 + CActiveScheduler::Start();
1.1189 + TEST2(active->iStatus.Int(), KErrNone);
1.1190 +
1.1191 + //////////////////////////////////////////////////////////////////////////////
1.1192 + //Get event1. It should be there - its time is (current date - 1 day + 10 seconds).
1.1193 + TheTest.Printf(_L("=.= GetEvent 1\n"));
1.1194 + active->StartL();
1.1195 + aClient.GetEvent(*event1, active->iStatus);
1.1196 + CActiveScheduler::Start();
1.1197 + if(active->iStatus != KErrNone)
1.1198 + {
1.1199 + TheTest.Printf(_L("=1= error code:%d\n"),active->iStatus.Int());
1.1200 + }
1.1201 + TEST2(active->iStatus.Int(), KErrNone);
1.1202 +
1.1203 + //////////////////////////////////////////////////////////////////////////////
1.1204 + //Get event2. It should be there - its time is (current date - 1 day + 10 seconds).
1.1205 + TheTest.Printf(_L("=.= GetEvent 2\n"));
1.1206 + active->StartL();
1.1207 + aClient.GetEvent(*event2, active->iStatus);
1.1208 + CActiveScheduler::Start();
1.1209 + if(active->iStatus != KErrNone)
1.1210 + {
1.1211 + TheTest.Printf(_L("=2= error code:%d\n"),active->iStatus.Int());
1.1212 + }
1.1213 + TEST2(active->iStatus.Int(), KErrNone);
1.1214 +
1.1215 + //////////////////////////////////////////////////////////////////////////////
1.1216 + //Get event3. It should not be there - its time is (current date - 2 days).
1.1217 + TheTest.Printf(_L("=.= GetEvent 3\n"));
1.1218 + active->StartL();
1.1219 + aClient.GetEvent(*event3, active->iStatus);
1.1220 + CActiveScheduler::Start();
1.1221 + TEST2(active->iStatus.Int(), KErrNotFound);
1.1222 +
1.1223 + //////////////////////////////////////////////////////////////////////////////
1.1224 + //Get event4. It should not be there - its time is (current date - 2 days).
1.1225 + TheTest.Printf(_L("=.= GetEvent 4\n"));
1.1226 + active->StartL();
1.1227 + aClient.GetEvent(*event4, active->iStatus);
1.1228 + CActiveScheduler::Start();
1.1229 + TEST2(active->iStatus.Int(), KErrNotFound);
1.1230 +
1.1231 + //////////////////////////////////////////////////////////////////////////////
1.1232 + //Clear all events happened before (current date).
1.1233 + //event1 and event2 should be removed.
1.1234 + TheTest.Printf(_L("=#= ClearLog 1\n"));
1.1235 + active->StartL();
1.1236 + aClient.ClearLog(now, active->iStatus);
1.1237 + CActiveScheduler::Start();
1.1238 + TEST2(active->iStatus.Int(), KErrNone);
1.1239 +
1.1240 + //////////////////////////////////////////////////////////////////////////////
1.1241 + //Get event1. It should not be there - its time is (current date - 1 day + 10 seconds).
1.1242 + TheTest.Printf(_L("=#= GetEvent 1\n"));
1.1243 + active->StartL();
1.1244 + aClient.GetEvent(*event1, active->iStatus);
1.1245 + CActiveScheduler::Start();
1.1246 + TEST2(active->iStatus.Int(), KErrNotFound);
1.1247 +
1.1248 + //////////////////////////////////////////////////////////////////////////////
1.1249 + //Get event2. It should not be there - its time is (current date - 1 day + 10 seconds).
1.1250 + TheTest.Printf(_L("=#= GetEvent 2\n"));
1.1251 + active->StartL();
1.1252 + aClient.GetEvent(*event2, active->iStatus);
1.1253 + CActiveScheduler::Start();
1.1254 + TEST2(active->iStatus.Int(), KErrNotFound);
1.1255 +
1.1256 + CleanupStack::PopAndDestroy(5); // event4, event3, event2, event1, active
1.1257 + }
1.1258 +
1.1259 +LOCAL_C void DoTestLogL(CLogBase& aClient)
1.1260 + {
1.1261 + CTestActive* active = new(ELeave)CTestActive();
1.1262 + CleanupStack::PushL(active);
1.1263 +
1.1264 + CLogEvent* event = CLogEvent::NewL();
1.1265 + CleanupStack::PushL(event);
1.1266 +
1.1267 + TTime now;
1.1268 + now.UniversalTime();
1.1269 +
1.1270 + event->SetEventType(KLogCallEventTypeUid);
1.1271 +
1.1272 + User::After((Math::Random() % 4) * 100000);
1.1273 + active->StartL();
1.1274 + aClient.AddEvent(*event, active->iStatus);
1.1275 + CActiveScheduler::Start();
1.1276 + TTEST2(active->iStatus.Int(), KErrNone);
1.1277 +
1.1278 + TTEST(event->EventType() == KLogCallEventTypeUid);
1.1279 + TTEST(event->Description().Length() > 0);
1.1280 + TTEST(event->Time() >= now);
1.1281 + now = event->Time();
1.1282 +
1.1283 + TLogId id = event->Id();
1.1284 +
1.1285 + event->SetRemoteParty(KTestRemoteParty1);
1.1286 + event->SetDirection(KTestDirection1);
1.1287 + event->SetDurationType(KTestDurationType1);
1.1288 + event->SetDuration(KTestDuration1);
1.1289 + event->SetStatus(KTestStatus1);
1.1290 + event->SetSubject(KTestSubject1);
1.1291 + event->SetNumber(KTestNumber1);
1.1292 + event->SetContact(KTestContact1);
1.1293 + event->SetLink(KTestLink1);
1.1294 + event->SetDataL(KTestData1);
1.1295 +
1.1296 + User::After((Math::Random() % 4) * 100000);
1.1297 + active->StartL();
1.1298 + aClient.ChangeEvent(*event, active->iStatus);
1.1299 + CActiveScheduler::Start();
1.1300 + TTEST2(active->iStatus.Int(), KErrNone);
1.1301 +
1.1302 + TTEST(event->Id() == id);
1.1303 + TTEST(event->EventType() == KLogCallEventTypeUid);
1.1304 + TTEST(event->Description().Length() > 0);
1.1305 + TTEST(event->Time() == now);
1.1306 + TTEST(event->RemoteParty() == KTestRemoteParty1);
1.1307 + TTEST(event->Direction() == KTestDirection1);
1.1308 + TTEST(event->DurationType() == KTestDurationType1);
1.1309 + TTEST(event->Duration() == KTestDuration1);
1.1310 + TTEST(event->Status() == KTestStatus1);
1.1311 + TTEST(event->Subject() == KTestSubject1);
1.1312 + TTEST(event->Number() == KTestNumber1);
1.1313 + TTEST(event->Contact() == KTestContact1);
1.1314 + TTEST(event->Link() == KTestLink1);
1.1315 + TTEST(event->Data() == KTestData1);
1.1316 +
1.1317 + CleanupStack::PopAndDestroy(); // event;
1.1318 +
1.1319 + event = CLogEvent::NewL();
1.1320 + CleanupStack::PushL(event);
1.1321 +
1.1322 + event->SetId(id);
1.1323 +
1.1324 + active->StartL();
1.1325 + aClient.GetEvent(*event, active->iStatus);
1.1326 + CActiveScheduler::Start();
1.1327 + TTEST2(active->iStatus.Int(), KErrNone);
1.1328 +
1.1329 + TTEST(event->Id() == id);
1.1330 + TTEST(event->EventType() == KLogCallEventTypeUid);
1.1331 + TTEST(event->Description().Length() > 0);
1.1332 + TTEST(event->Time() == now);
1.1333 + TTEST(event->RemoteParty() == KTestRemoteParty1);
1.1334 + TTEST(event->Direction() == KTestDirection1);
1.1335 + TTEST(event->DurationType() == KTestDurationType1);
1.1336 + TTEST(event->Duration() == KTestDuration1);
1.1337 + TTEST(event->Status() == KTestStatus1);
1.1338 + TTEST(event->Subject() == KTestSubject1);
1.1339 + TTEST(event->Number() == KTestNumber1);
1.1340 + TTEST(event->Contact() == KTestContact1);
1.1341 + TTEST(event->Link() == KTestLink1);
1.1342 + TTEST(event->Data() == KTestData1);
1.1343 +
1.1344 + User::After((Math::Random() % 4) * 100000);
1.1345 + active->StartL();
1.1346 + aClient.DeleteEvent(id, active->iStatus);
1.1347 + CActiveScheduler::Start();
1.1348 + TTEST2(active->iStatus.Int(), KErrNone);
1.1349 +
1.1350 + active->StartL();
1.1351 + aClient.GetEvent(*event, active->iStatus);
1.1352 + CActiveScheduler::Start();
1.1353 + TTEST2(active->iStatus.Int(), KErrNotFound);
1.1354 +
1.1355 + CleanupStack::PopAndDestroy(2); // event, active
1.1356 + }
1.1357 +
1.1358 +void DoTestMultipleClientAccessL()
1.1359 + {
1.1360 + CActiveScheduler::Install(new(ELeave)CActiveScheduler);
1.1361 + CleanupStack::PushL(CActiveScheduler::Current());
1.1362 +
1.1363 + RFs fs;
1.1364 + TTEST2(fs.Connect(), KErrNone);
1.1365 + CleanupClosePushL(fs);
1.1366 +
1.1367 + CLogClient* client = CLogClient::NewL(fs);
1.1368 + CleanupStack::PushL(client);
1.1369 +
1.1370 + TBuf8<500> buf;
1.1371 +
1.1372 + TInt count = 10;
1.1373 + while(count--)
1.1374 + {
1.1375 + DoTestLogL(*client);
1.1376 + }
1.1377 +
1.1378 + CleanupStack::PopAndDestroy(3); // fs, client, CActiveScheduler
1.1379 + }
1.1380 +
1.1381 +void DoThreadDieL()
1.1382 + {
1.1383 + CActiveScheduler::Install(new(ELeave)CActiveScheduler);
1.1384 + CleanupStack::PushL(CActiveScheduler::Current());
1.1385 +
1.1386 + RFs fs;
1.1387 + TTEST2(fs.Connect(), KErrNone);
1.1388 + CleanupClosePushL(fs);
1.1389 +
1.1390 + CLogEvent* event = CLogEvent::NewL();
1.1391 + CleanupStack::PushL(event);
1.1392 +
1.1393 + const TInt KLogClientCnt = 10;
1.1394 + for(TInt i=0;i<KLogClientCnt;i++)
1.1395 + {
1.1396 + CLogClient* client = CLogClient::NewL(fs);
1.1397 + event->SetId(i);
1.1398 + TRequestStatus status;
1.1399 + client->GetEvent(*event, status);
1.1400 + }
1.1401 +
1.1402 + User::After(100000);
1.1403 +
1.1404 + RThread thread;
1.1405 + thread.Kill(KErrGeneral);
1.1406 + }
1.1407 +
1.1408 +static TInt DoDyingThreadStart(TAny*)
1.1409 + {
1.1410 + CTrapCleanup* cleanup = CTrapCleanup::New();
1.1411 + TTEST(cleanup != NULL);
1.1412 + TRAPD(err, DoThreadDieL());
1.1413 + delete cleanup;
1.1414 + if(err != KErrNone)
1.1415 + {
1.1416 + RDebug::Print(_L("*** DoThreadDieL() failed with err %d\r\n"), err);
1.1417 + User::Panic(_L("ThrChk4"), 4);
1.1418 + }
1.1419 + return err;
1.1420 + }
1.1421 +
1.1422 +static TInt DoThreadStart(TAny* aThreadNumber)
1.1423 + {
1.1424 + TInt thrNum = (TInt)aThreadNumber;
1.1425 + CTrapCleanup* cleanup = CTrapCleanup::New();
1.1426 + TTEST(cleanup != NULL);
1.1427 + TRAPD(err, DoTestMultipleClientAccessL());
1.1428 + delete cleanup;
1.1429 + if(err != KErrNone)
1.1430 + {
1.1431 + RDebug::Print(_L("*** Thread %d failed with err %d\r\n"), thrNum, err);
1.1432 + User::Panic(_L("ThrChk3"), 3);
1.1433 + }
1.1434 + return err;
1.1435 + }
1.1436 +
1.1437 +const TInt KTestThreadCount = 20;
1.1438 +const TInt KMinTestHeapSize = 0x10000;
1.1439 +const TInt KMaxTestHeapSize = 0x100000;
1.1440 +
1.1441 +/**
1.1442 +@SYMTestCaseID SYSLIB-LOGENG-CT-0846
1.1443 +@SYMTestCaseDesc Thread invoking test
1.1444 +@SYMTestPriority High
1.1445 +@SYMTestActions Create a new thread,check for no errors,register for notification of status when the thread dies
1.1446 +@SYMTestExpectedResults Test must not fail
1.1447 +@SYMREQ REQ0000
1.1448 +*/
1.1449 +LOCAL_C void TestThreadDieL()
1.1450 + {
1.1451 + RThread thread;
1.1452 + TRequestStatus status;
1.1453 +
1.1454 + TName name;
1.1455 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0846 "));
1.1456 + _LIT(KThreadName, "Test thread");
1.1457 + name.Format(KThreadName);
1.1458 +
1.1459 + TInt err = thread.Create(name, DoDyingThreadStart, KDefaultStackSize, KMinTestHeapSize, KMaxTestHeapSize, NULL, EOwnerThread);
1.1460 + // Create the thread
1.1461 + TEST2(err, KErrNone);
1.1462 + thread.Logon(status);
1.1463 +
1.1464 + // Let the thread run
1.1465 + thread.Resume();
1.1466 +
1.1467 + User::WaitForRequest(status);
1.1468 + TEST2(thread.ExitType(), EExitKill);
1.1469 + thread.Close();
1.1470 + TEST2(status.Int(), KErrGeneral);
1.1471 + }
1.1472 +
1.1473 +/**
1.1474 +@SYMTestCaseID SYSLIB-LOGENG-CT-0847
1.1475 +@SYMTestCaseDesc Multiple client access test
1.1476 +@SYMTestPriority High
1.1477 +@SYMTestActions Create threads,request for notification of thread death.
1.1478 + Resume and stop all the threads executions.Check for no errors.
1.1479 +@SYMTestExpectedResults Test must not fail
1.1480 +@SYMREQ REQ0000
1.1481 +*/
1.1482 +LOCAL_C void TestMultipleClientAccessL()
1.1483 + {
1.1484 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0847 "));
1.1485 + RThread threadArray[KTestThreadCount];
1.1486 + TRequestStatus statusArray[KTestThreadCount];
1.1487 +
1.1488 + // Create the threads
1.1489 + TInt count = KTestThreadCount;
1.1490 + while(count--)
1.1491 + {
1.1492 + TName name;
1.1493 + _LIT(KThreadName, "TmcaTh%d");
1.1494 + name.Format(KThreadName, count);
1.1495 +
1.1496 + // Create the thread
1.1497 + TInt err = threadArray[count].Create(name, DoThreadStart, KDefaultStackSize, KMinTestHeapSize, KMaxTestHeapSize, (TAny*) count, EOwnerThread);
1.1498 + TEST2(err, KErrNone);
1.1499 + threadArray[count].Logon(statusArray[count]);
1.1500 + }
1.1501 +
1.1502 + // Let the thread run
1.1503 + count = KTestThreadCount;
1.1504 + while(count--)
1.1505 + {
1.1506 + TheTest.Printf(_L(" ** Resume thread %d\r\n"), count);
1.1507 + threadArray[count].Resume();
1.1508 + }
1.1509 +
1.1510 + TheTest.Printf(_L(" ** Waiting threads to complete....\r\n"));
1.1511 +
1.1512 + // Wait for all the threads to complete
1.1513 + count = KTestThreadCount;
1.1514 + while(count--)
1.1515 + {
1.1516 + User::WaitForRequest(statusArray[count]);
1.1517 + TheTest.Printf(_L(" ** Thread %d completed\r\n"), count);
1.1518 + TEST(threadArray[count].ExitType() != EExitPanic);
1.1519 + threadArray[count].Close();
1.1520 + }
1.1521 + }
1.1522 +
1.1523 +/**
1.1524 +@SYMTestCaseID SYSLIB-LOGENG-CT-0848
1.1525 +@SYMTestCaseDesc Test for checking notification of status
1.1526 +@SYMTestPriority High
1.1527 +@SYMTestActions Call up add - get - change - delete event type.
1.1528 +@SYMTestExpectedResults Test must not fail
1.1529 +@SYMREQ REQ0000
1.1530 +*/
1.1531 +LOCAL_C void TestNoNotifierL()
1.1532 + {
1.1533 + TestUtils::DeleteDatabaseL();
1.1534 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0848 "));
1.1535 + TheTest.Printf(_L("TestNoNotifierL - begin\n"));
1.1536 +
1.1537 + CLogClient* client = CLogClient::NewL(theFs);
1.1538 + CleanupStack::PushL(client);
1.1539 +
1.1540 + CTestActive* active = new(ELeave)CTestActive;
1.1541 + CleanupStack::PushL(active);
1.1542 +
1.1543 + TheTest.Printf(_L("TestAddEventTypeL\n"));
1.1544 + TestAddEventTypeL(*client);
1.1545 +
1.1546 + TheTest.Printf(_L("TestGetEventTypeL\n"));
1.1547 + TestGetEventTypeL(*client);
1.1548 +
1.1549 + TheTest.Printf(_L("TestChangeEventTypeL\n"));
1.1550 + TestChangeEventTypeL(*client);
1.1551 +
1.1552 + TheTest.Printf(_L("TestDeleteEventTypeL\n"));
1.1553 + TestDeleteEventTypeL(*client);
1.1554 +
1.1555 + TheTest.Printf(_L("TestAddEventL\n"));
1.1556 + TestAddEventL(*client);
1.1557 +
1.1558 + TheTest.Printf(_L("TestGetEventL\n"));
1.1559 + TestGetEventL(*client);
1.1560 +
1.1561 + TheTest.Printf(_L("TestChangeEventL\n"));
1.1562 + TestChangeEventL(*client);
1.1563 +
1.1564 + TheTest.Printf(_L("TestDeleteEventL\n"));
1.1565 + TestDeleteEventL(*client);
1.1566 +
1.1567 + TheTest.Printf(_L("TestGetConfigL\n"));
1.1568 + TestGetConfigL(*client);
1.1569 +
1.1570 + TheTest.Printf(_L("TestChangeConfigL\n"));
1.1571 + TestChangeConfigL(*client);
1.1572 +
1.1573 + TheTest.Printf(_L("TestGetStringL\n"));
1.1574 + TestGetStringL(*client);
1.1575 +
1.1576 + TheTest.Printf(_L("TestClearEventLogL\n"));
1.1577 + TestClearEventLogL(*client);
1.1578 +
1.1579 + CleanupStack::PopAndDestroy(2); // active, client
1.1580 + TheTest.Printf(_L("TestNoNotifierL - end\n"));
1.1581 + }
1.1582 +
1.1583 +/**
1.1584 +@SYMTestCaseID PDS-LOGENG-CT-4016
1.1585 +@SYMTestCaseDesc Tests for CLogChangeDefinition public APIs
1.1586 +@SYMTestPriority High
1.1587 +@SYMTestActions Tests for CLogChangeDefinition::Find() functions, and different NewL() functions.
1.1588 +@SYMTestExpectedResults CLogChangeDefinition object need to be created propertly. Find() functions
1.1589 + need to return proper items from list.
1.1590 +@SYMDEF DEF135499
1.1591 +*/
1.1592 +LOCAL_C void TestLogChangeDefinitionL(CLogClient& aClient)
1.1593 + {
1.1594 + TheTest.Next(_L(" @SYMTestCaseID:PDS-LOGENG-CT-4016"));
1.1595 + TestUtils::DeleteDatabaseL();
1.1596 +
1.1597 + CLogEvent* event = CLogEvent::NewL();
1.1598 + CleanupStack::PushL(event);
1.1599 +
1.1600 + CLogFilter* filter = CLogFilter::NewL();
1.1601 + CleanupStack::PushL(filter);
1.1602 + filter->SetContact(KTestContact);
1.1603 + filter->SetEventType(KLogPacketDataEventTypeUid);
1.1604 +
1.1605 + CTestActive* active = new(ELeave)CTestActive();
1.1606 + CleanupStack::PushL(active);
1.1607 +
1.1608 + CLogViewChangeObserver* changeObs = CLogViewChangeObserver::NewLC();
1.1609 + changeObs->SetActive();
1.1610 +
1.1611 + CLogViewEvent* view = CLogViewEvent::NewL(aClient, *changeObs);
1.1612 + CleanupStack::PushL(view);
1.1613 +
1.1614 + // Incoming
1.1615 + TBuf<KLogMaxDirectionLength> buf;
1.1616 + aClient.GetString(buf, R_LOG_DIR_IN);
1.1617 +
1.1618 + event->SetEventType(KLogPacketDataEventTypeUid);
1.1619 + event->SetDirection(buf);
1.1620 + event->SetContact(KTestContact);
1.1621 +
1.1622 + active->StartL();
1.1623 + aClient.AddEvent(*event, active->iStatus);
1.1624 + CActiveScheduler::Start();
1.1625 + TEST2(active->iStatus.Int(), KErrNone);
1.1626 + User::After(1 * 1000000);
1.1627 +
1.1628 + TEST2(view->CountL(), 0);
1.1629 + active->StartL();
1.1630 + TBool res = view->SetFilterL(*filter, active->iStatus);
1.1631 + TEST(res);
1.1632 + CActiveScheduler::Start();
1.1633 + TEST2(active->iStatus.Int(), KErrNone);
1.1634 + TEST2(view->CountL(), 1);
1.1635 +
1.1636 + // Transients
1.1637 + TInt changeCount;
1.1638 + TLogId logId;
1.1639 + TInt viewIndex;
1.1640 + TLogDatabaseChangeType type;
1.1641 +
1.1642 + for(TInt count = 0; count < KTestEventNum; count++)
1.1643 + {
1.1644 + active->StartL();
1.1645 + aClient.AddEvent(*event, active->iStatus);
1.1646 + CActiveScheduler::Start();
1.1647 + TEST2(active->iStatus.Int(), KErrNone);
1.1648 + User::After(1 * 1000000);
1.1649 + }
1.1650 +
1.1651 + const CLogChangeDefinition& changes = changeObs->Changes();
1.1652 +
1.1653 + changeCount = changes.Count();
1.1654 + TheTest.Printf(_L("Change Count: %d\n"), changeCount);
1.1655 + TEST2(changeCount, KTestEventNum);
1.1656 + for(TInt i=0; i<changeCount; i++)
1.1657 + {
1.1658 + type = changes.At(i, logId, viewIndex);
1.1659 + TheTest.Printf(_L("Change Type: %d, logId: %d, viewIndex: %d\n"), type, logId, viewIndex);
1.1660 + TEST(changes.Find(logId)==i);
1.1661 + TEST(changes.Find(logId, ELogChangeTypeEventAdded)>=0);
1.1662 + TEST(changes.Find(TLogId(100000000), ELogChangeTypeEventAdded)==KErrNotFound);
1.1663 + TEST(changes.Find(logId, ELogChangeTypeLogCleared)==KErrNotFound);
1.1664 + TEST(changes.FindByViewIndex(viewIndex)>=0);
1.1665 + TEST(changes.Find(TLogId(100000000))==KErrNotFound);
1.1666 + }
1.1667 +
1.1668 + CBufFlat* buffer = CBufFlat::NewL(10*1024);
1.1669 + CleanupStack::PushL(buffer);
1.1670 + RBufWriteStream wstr(*buffer,0);
1.1671 + wstr << changes;
1.1672 + wstr.CommitL();
1.1673 + wstr.Close();
1.1674 + RBufReadStream rstr(*buffer,0);
1.1675 + CLogChangeDefinition* changes2 = CLogChangeDefinition::NewL(rstr);
1.1676 + CleanupStack::PushL(changes2);
1.1677 + rstr.Close();
1.1678 +
1.1679 + TEST(changes.Count()==changes2->Count());
1.1680 +
1.1681 + CleanupStack::PopAndDestroy(3); // changes2, buffer, view
1.1682 +
1.1683 + // Check the change was as expected
1.1684 + TEST2(changes.Count(), 10);
1.1685 + type = changes.At(0, logId, viewIndex);
1.1686 +
1.1687 + CleanupStack::PopAndDestroy(4, event); // changeObs, active, filter, event
1.1688 +
1.1689 + TEST2(type, ELogChangeTypeEventAdded);
1.1690 + TEST2(viewIndex, 0); // first (newest) events in the view
1.1691 +
1.1692 + const TLogId expectedLogId = ((TLogId) 1);
1.1693 + TEST2(logId, expectedLogId);
1.1694 + }
1.1695 +
1.1696 +void DoStartL()
1.1697 + {
1.1698 + CActiveScheduler::Install(new(ELeave)CActiveScheduler);
1.1699 + RFs fs;
1.1700 + LEAVE_IF_ERROR(fs.Connect());
1.1701 + CleanupClosePushL(fs);
1.1702 + CLogClient* client = CLogClient::NewL(fs);
1.1703 + delete client;
1.1704 + CleanupStack::PopAndDestroy(&fs);
1.1705 + delete CActiveScheduler::Current();
1.1706 + }
1.1707 +
1.1708 +static TInt LaunchThread(TAny* /*aAny*/)
1.1709 + {
1.1710 + __UHEAP_MARK;
1.1711 + CTrapCleanup* cleanup = CTrapCleanup::New();
1.1712 + TRAPD(err, DoStartL());
1.1713 + delete cleanup;
1.1714 + __UHEAP_MARKEND;
1.1715 + if(err != KErrNone)
1.1716 + {
1.1717 + RDebug::Print(_L("*** DoStartL() failed with err %d\r\n"), err);
1.1718 + User::Panic(_L("ThrChk5"), 5);
1.1719 + }
1.1720 + return KErrNone;
1.1721 + }
1.1722 +
1.1723 +/**
1.1724 +@SYMTestCaseID SYSLIB-LOGENG-CT-0849
1.1725 +@SYMTestCaseDesc Tests for creation of two simultaneous threads
1.1726 +@SYMTestPriority High
1.1727 +@SYMTestActions Create two threads,start and close the threads
1.1728 +@SYMTestExpectedResults Test must not fail
1.1729 +@SYMREQ REQ0000
1.1730 +*/
1.1731 +LOCAL_C void TestStartupL()
1.1732 + {
1.1733 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0849 "));
1.1734 + RThread thread1;
1.1735 + RThread thread2;
1.1736 +
1.1737 + // Create the threads
1.1738 + LEAVE_IF_ERROR(thread1.Create(_L("Thread1"), LaunchThread, KDefaultStackSize, KMinHeapSize , KMinHeapSize , NULL));
1.1739 + LEAVE_IF_ERROR(thread2.Create(_L("Thread2"), LaunchThread, KDefaultStackSize, KMinHeapSize , KMinHeapSize, NULL));
1.1740 +
1.1741 + // Let them run
1.1742 + TRequestStatus s1;
1.1743 + thread1.Logon(s1);
1.1744 + thread1.Resume();
1.1745 +
1.1746 + TRequestStatus s2;
1.1747 + thread2.Logon(s2);
1.1748 + thread2.Resume();
1.1749 +
1.1750 + User::WaitForRequest(s1);
1.1751 + TEST(thread1.ExitType() != EExitPanic);
1.1752 + thread1.Close();
1.1753 +
1.1754 + User::WaitForRequest(s2);
1.1755 + TEST(thread2.ExitType() != EExitPanic);
1.1756 + thread2.Close();
1.1757 +
1.1758 + TEST2(s1.Int(), KErrNone);
1.1759 + TEST2(s2.Int(), KErrNone);
1.1760 + }
1.1761 +
1.1762 +/**
1.1763 +@SYMTestCaseID SYSLIB-LOGENG-CT-0850
1.1764 +@SYMTestCaseDesc Tests for invalid database scheme
1.1765 +@SYMTestPriority High
1.1766 +@SYMTestActions Create a log event implementation,should leave if there is a problem
1.1767 +@SYMTestExpectedResults Test must not fail
1.1768 +@SYMREQ REQ0000
1.1769 +*/
1.1770 +LOCAL_C void TestInvalidSchemaL()
1.1771 + {
1.1772 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0850 "));
1.1773 + TestUtils::TestInvalidSchemaL();
1.1774 + }
1.1775 +
1.1776 +void doTestsL()
1.1777 + {
1.1778 + TestUtils::Initialize(_L("t_logapi"));
1.1779 +
1.1780 + // This test should be first to ensure no clients kicking around
1.1781 + TheTest.Next(_L("Invalid database scheme"));
1.1782 + TestInvalidSchemaL();
1.1783 + theLog.Write(_L8("Test 0 OK\n"));
1.1784 +
1.1785 + TheTest.Start(_L("Simultaneous Startup"));
1.1786 + TestStartupL();
1.1787 + theLog.Write(_L8("Test 1 OK\n"));
1.1788 +
1.1789 + CLogChangeNotifier* notifier = CLogChangeNotifier::NewL();
1.1790 + CleanupStack::PushL(notifier);
1.1791 +
1.1792 + TheTest.Next(_L("Dying thread test"));
1.1793 + TestThreadDieL();
1.1794 + theLog.Write(_L8("Test 2 OK\n"));
1.1795 +
1.1796 + TestUtils::DeleteDatabaseL();
1.1797 +
1.1798 + CLogClient* client = CLogClient::NewL(theFs);
1.1799 + CleanupStack::PushL(client);
1.1800 +
1.1801 + CTestActive* active = new(ELeave) CTestActive(CActive::EPriorityIdle - 500);
1.1802 + CleanupStack::PushL(active);
1.1803 +
1.1804 + TheTest.Next(_L("Additional tests on CLogChangeDefinition."));
1.1805 + TestLogChangeDefinitionL(*client);
1.1806 + theLog.Write(_L8("Test 2.1 OK\n"));
1.1807 + TestUtils::DeleteDatabaseL();
1.1808 +
1.1809 + TheTest.Next(_L("Client death"));
1.1810 + TestClientFailL();
1.1811 + theLog.Write(_L8("Test 3 OK\n"));
1.1812 +
1.1813 + TheTest.Next(_L("Testing client API"));
1.1814 + TestNoNotifierL();
1.1815 + theLog.Write(_L8("Test 4 OK\n"));
1.1816 +
1.1817 + // Delay for testing change notification
1.1818 + TInt delay = 5000000;
1.1819 + User::After(delay);
1.1820 +
1.1821 +
1.1822 + active->StartL();
1.1823 + client->NotifyChange(delay, active->iStatus);
1.1824 +
1.1825 + TheTest.Next(_L("Delete Event Type"));
1.1826 + TestDeleteEventTypeL(*client);
1.1827 + theLog.Write(_L8("Test 5 OK\n"));
1.1828 +
1.1829 + CActiveScheduler::Start();
1.1830 + TEST(active->iStatus.Int() >= 0);
1.1831 +
1.1832 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0834 Add Event Type "));
1.1833 + TestAddEventTypeL(*client);
1.1834 + theLog.Write(_L8("Test 6 OK\n"));
1.1835 +
1.1836 + // Must delete the database before testing
1.1837 + // the notification API, since we just created the
1.1838 + // entry in the previous test (6) and therefore
1.1839 + // attempting to add the entry again just results in
1.1840 + // KErrAlreadyExists and does not cause a change to the
1.1841 + // database.
1.1842 + TestUtils::DeleteDatabaseL();
1.1843 +
1.1844 + active->StartL();
1.1845 + client->NotifyChange(delay, active->iStatus);
1.1846 +
1.1847 + TestAddEventTypeL(*client);
1.1848 +
1.1849 + CActiveScheduler::Start();
1.1850 + TEST(active->iStatus.Int() >= 0);
1.1851 + active->StartL();
1.1852 + client->NotifyChange(delay, active->iStatus);
1.1853 +
1.1854 + // The following doesn't make any changes
1.1855 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0835 Get Event Type "));
1.1856 + TestGetEventTypeL(*client);
1.1857 + theLog.Write(_L8("Test 7 OK\n"));
1.1858 +
1.1859 + TheTest.Next(_L("Change Event Type"));
1.1860 + TestChangeEventTypeL(*client);
1.1861 + theLog.Write(_L8("Test 8 OK\n"));
1.1862 +
1.1863 + CActiveScheduler::Start();
1.1864 + TEST(active->iStatus.Int() >= 0);
1.1865 + active->StartL();
1.1866 + client->NotifyChange(delay, active->iStatus);
1.1867 +
1.1868 + TheTest.Next(_L("Delete Event Type"));
1.1869 + TestDeleteEventTypeL(*client);
1.1870 + theLog.Write(_L8("Test 9 OK\n"));
1.1871 +
1.1872 + CActiveScheduler::Start();
1.1873 + TEST(active->iStatus.Int() >= 0);
1.1874 + active->StartL();
1.1875 + client->NotifyChange(delay, active->iStatus);
1.1876 +
1.1877 + TheTest.Next(_L("Add Event"));
1.1878 + TestAddEventL(*client);
1.1879 + theLog.Write(_L8("Test 10 OK\n"));
1.1880 +
1.1881 + CActiveScheduler::Start();
1.1882 + TEST(active->iStatus.Int() >= 0);
1.1883 + active->StartL();
1.1884 + client->NotifyChange(delay, active->iStatus);
1.1885 +
1.1886 + // The following doesn't make any changes
1.1887 + TheTest.Next(_L("Get Event"));
1.1888 + TestGetEventL(*client);
1.1889 + theLog.Write(_L8("Test 11 OK\n"));
1.1890 +
1.1891 + TheTest.Next(_L("Change Event"));
1.1892 + TestChangeEventL(*client);
1.1893 + theLog.Write(_L8("Test 12 OK\n"));
1.1894 +
1.1895 + CActiveScheduler::Start();
1.1896 + TEST(active->iStatus.Int() >= 0);
1.1897 + active->StartL();
1.1898 + client->NotifyChange(delay, active->iStatus);
1.1899 +
1.1900 + TheTest.Next(_L("Delete Event"));
1.1901 + TestDeleteEventL(*client);
1.1902 + theLog.Write(_L8("Test 13 OK\n"));
1.1903 +
1.1904 + CActiveScheduler::Start();
1.1905 + TEST(active->iStatus.Int() >= 0);
1.1906 + active->StartL();
1.1907 + client->NotifyChange(delay, active->iStatus);
1.1908 +
1.1909 + // The following doesn't make any changes
1.1910 + TheTest.Next(_L("Get Config"));
1.1911 + TestGetConfigL(*client);
1.1912 + theLog.Write(_L8("Test 14 OK\n"));
1.1913 +
1.1914 + TheTest.Next(_L("Change Config"));
1.1915 + TestChangeConfigL(*client);
1.1916 + theLog.Write(_L8("Test 15 OK\n"));
1.1917 +
1.1918 + CActiveScheduler::Start();
1.1919 + TEST(active->iStatus.Int() >= 0);
1.1920 + active->StartL();
1.1921 + client->NotifyChange(delay*3, active->iStatus);
1.1922 +
1.1923 + // The following doesn't make any changes
1.1924 + TheTest.Next(_L("Get String"));
1.1925 + TestGetStringL(*client);
1.1926 + theLog.Write(_L8("Test 16 OK\n"));
1.1927 +
1.1928 + TheTest.Next(_L("Clear Event Log"));
1.1929 + TestClearEventLogL(*client);
1.1930 + theLog.Write(_L8("Test 17 OK\n"));
1.1931 +
1.1932 + CActiveScheduler::Start();
1.1933 + TEST(active->iStatus.Int() >= 0);
1.1934 + active->StartL();
1.1935 + client->NotifyChange(delay, active->iStatus);
1.1936 +
1.1937 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0833 Test global change API "));
1.1938 + TestClientObserverMechanismL(*client);
1.1939 + theLog.Write(_L8("Test 18 OK\n"));
1.1940 +
1.1941 + TheTest.Next(_L("Multiple client access"));
1.1942 + TestMultipleClientAccessL();
1.1943 + theLog.Write(_L8("Test 19 OK\n"));
1.1944 +
1.1945 + theLog.Write(_L8("Destroying: active\n"));
1.1946 + CleanupStack::PopAndDestroy(active);
1.1947 + theLog.Write(_L8("Destroyed ok\n"));
1.1948 + theLog.Write(_L8("Destroying: client\n"));
1.1949 + CleanupStack::PopAndDestroy(client);
1.1950 + theLog.Write(_L8("Destroyed ok\n"));
1.1951 + theLog.Write(_L8("Destroying: notifier\n"));
1.1952 + CleanupStack::PopAndDestroy(notifier);
1.1953 + theLog.Write(_L8("Destroyed ok\n"));
1.1954 +
1.1955 +
1.1956 +#ifdef SYSLIBS_TEST
1.1957 + theLog.Write(_L8("Preparing the context for the test : @SYMTestCaseID:SYSLIB-LOGENG-UT-4015... \n"));
1.1958 + theLog.Write(_L8("Deleting the Log engine database... \n"));
1.1959 + TestUtils::DeleteDatabaseL();
1.1960 + theLog.Write(_L8("Allocating a new CLogClient object... \n"));
1.1961 + CLogClient* theClient = CLogClient::NewL(theFs);
1.1962 + CleanupStack::PushL(theClient);
1.1963 + TheTest.Next(_L("TestGetConfigSettingsFromRepositoryFileL () "));
1.1964 + TestGetConfigSettingsFromRepositoryFileL(*theClient);
1.1965 + theLog.Write(_L8("TestGetConfigSettingsFromRepositoryFileL () OK\n"));
1.1966 + theLog.Write(_L8("Destroying the CLogClient object... \n"));
1.1967 + CleanupStack::PopAndDestroy(theClient);
1.1968 + theLog.Write(_L8("Destroyed ok\n"));
1.1969 +#else
1.1970 + theLog.Write(_L8("The Test PREQ2103 works only when SYSLIBS_TEST macro is defined"));
1.1971 +#endif
1.1972 + }