1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/persistentdata/loggingservices/eventlogger/test/src/t_logfile.cpp Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,1297 @@
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 "t_logutil2.h"
1.21 +
1.22 +/*
1.23 +This test may fail occasionally, especially after changing the LogEng server code. The reported error is KErrCorrupt.
1.24 +The typical scenario when the test fails is:
1.25 +1) Some of the test functions calls "__FILE_FAILNEXT(failCount++)"
1.26 +2) The test calls some CLogClient method, typically "aClient.GetEventType()".
1.27 +3) The statement "test(active->iStatus == KErrNone)" fails.
1.28 +This behaviour might be related to INC044553 "DBMS does not handle OOD error
1.29 +scenarios correctly when committing a transaction".
1.30 +"__FILE_FAILNEXT" is a macro, which calls theFs.SetErrorCondition(KErrGeneral, X).
1.31 +If you perform a search with "SetErrorCondition" keyword in "Programming" database, you will find
1.32 +some explanations that the programmer has to be careful when using SetErrorCondition() method,
1.33 +because:
1.34 +
1.35 +"You have to be careful if you use this in the same way as you do for heap testing, because you
1.36 +can get the file system in a state where it think the file you're working on is corrupted."
1.37 +
1.38 +Anyway, LOGENG server internally uses DBMS component. Calling SetErrorCondition() we test DBMS
1.39 +component actually not LOGENG component!
1.40 +There is one addidtional thing in the test, which makes me believing that the problem is not
1.41 +in LOGENG but in SetErrorCondition()/DBMS interaction - in many if the test functions a statement
1.42 +like:
1.43 +
1.44 + if (failCount == 5)
1.45 + failCount++;
1.46 +
1.47 +may be found. I think that it is there to prevent exactly the problem with
1.48 +SetErrorCondition()/DBMS interaction.
1.49 +*/
1.50 +
1.51 +RTest TheTest(_L("t_logfile"));
1.52 +
1.53 +const TUid KTestEventUid = {0x10005393};
1.54 +_LIT(KTestEventDesc1, "Event Type Description");
1.55 +_LIT(KTestEventDesc2, "Changed Event Description");
1.56 +_LIT(KTestRemoteParty1, "Remote Party");
1.57 +_LIT(KTestRemoteParty2, "Changed Remote Party");
1.58 +_LIT(KTestDirection1, "Direction");
1.59 +_LIT(KTestDirection2, "Changed Direction");
1.60 +const TLogDurationType KTestDurationType1 = 1;
1.61 +const TLogDurationType KTestDurationType2 = 2;
1.62 +const TLogDuration KTestDuration1 = 0x1234;
1.63 +const TLogDuration KTestDuration2 = 0x1234567;
1.64 +_LIT(KTestStatus1, "Status");
1.65 +_LIT(KTestStatus2, "Changed Status");
1.66 +_LIT(KTestSubject1, "Subject");
1.67 +_LIT(KTestSubject2, "Changed Subject");
1.68 +_LIT(KTestNumber1, "Number");
1.69 +_LIT(KTestNumber2, "Changed Number");
1.70 +const TLogContactItemId KTestContact1 = 0x1234;
1.71 +const TLogContactItemId KTestContact2 = 0x1234567;
1.72 +const TLogLink KTestLink1 = 0x1234;
1.73 +const TLogLink KTestLink2 = 0x1234567;
1.74 +_LIT8(KTestData1, "ABCDEFGH");
1.75 +_LIT8(KTestData2, "IJKLMNOPQRSTUVWXYZ");
1.76 +const TLogSize KTestMaxLogSize = 0xFFF;
1.77 +const TLogRecentSize KTestMaxRecentLogSize = 0xF;
1.78 +const TLogAge KTestMaxEventAge = 0xFFFFFFF;
1.79 +
1.80 +/**
1.81 +@SYMTestCaseID SYSLIB-LOGENG-CT-1334
1.82 +@SYMTestCaseDesc Basic test to add events
1.83 +@SYMTestPriority High
1.84 +@SYMTestActions Tests for CLogClient::AddEvent() function
1.85 +@SYMTestExpectedResults Test must not fail
1.86 +@SYMREQ REQ0000
1.87 +*/
1.88 +LOCAL_C void TestBasicL(CLogClient& aClient)
1.89 + {
1.90 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-1334 "));
1.91 + CTestActive* active = new(ELeave)CTestActive();
1.92 + CleanupStack::PushL(active);
1.93 +
1.94 + CLogEvent* event = CLogEvent::NewL();
1.95 + CleanupStack::PushL(event);
1.96 +
1.97 + TTime now;
1.98 + now.UniversalTime();
1.99 +
1.100 + event->SetEventType(KLogCallEventTypeUid);
1.101 +
1.102 + active->StartL();
1.103 + aClient.AddEvent(*event, active->iStatus);
1.104 + CActiveScheduler::Start();
1.105 + TEST2(active->iStatus.Int(), KErrNone);
1.106 +
1.107 + TEST(event->EventType() == KLogCallEventTypeUid);
1.108 + TEST(event->Description().Length() > 0);
1.109 + TEST(event->Time() >= now);
1.110 + now = event->Time();
1.111 +
1.112 + TLogId id = event->Id();
1.113 +
1.114 + event->SetRemoteParty(KTestRemoteParty1);
1.115 + event->SetDirection(KTestDirection1);
1.116 + event->SetDurationType(KTestDurationType1);
1.117 + event->SetDuration(KTestDuration1);
1.118 + event->SetStatus(KTestStatus1);
1.119 + event->SetSubject(KTestSubject1);
1.120 + event->SetNumber(KTestNumber1);
1.121 + event->SetContact(KTestContact1);
1.122 + event->SetLink(KTestLink1);
1.123 + event->SetDataL(KTestData1);
1.124 +
1.125 + active->StartL();
1.126 + aClient.ChangeEvent(*event, active->iStatus);
1.127 + CActiveScheduler::Start();
1.128 + TEST2(active->iStatus.Int(), KErrNone);
1.129 +
1.130 + TEST(event->Id() == id);
1.131 + TEST(event->EventType() == KLogCallEventTypeUid);
1.132 + TEST(event->Description().Length() > 0);
1.133 + TEST(event->Time() == now);
1.134 + TEST(event->RemoteParty() == KTestRemoteParty1);
1.135 + TEST(event->Direction() == KTestDirection1);
1.136 + TEST(event->DurationType() == KTestDurationType1);
1.137 + TEST(event->Duration() == KTestDuration1);
1.138 + TEST(event->Status() == KTestStatus1);
1.139 + TEST(event->Subject() == KTestSubject1);
1.140 + TEST(event->Number() == KTestNumber1);
1.141 + TEST(event->Contact() == KTestContact1);
1.142 + TEST(event->Link() == KTestLink1);
1.143 + TEST(event->Data() == KTestData1);
1.144 +
1.145 + CleanupStack::PopAndDestroy(); // event;
1.146 +
1.147 + event = CLogEvent::NewL();
1.148 + CleanupStack::PushL(event);
1.149 +
1.150 + event->SetId(id);
1.151 +
1.152 + active->StartL();
1.153 + aClient.GetEvent(*event, active->iStatus);
1.154 + CActiveScheduler::Start();
1.155 + TEST2(active->iStatus.Int(),KErrNone);
1.156 +
1.157 + TEST(event->Id() == id);
1.158 + TEST(event->EventType() == KLogCallEventTypeUid);
1.159 + TEST(event->Description().Length() > 0);
1.160 + TEST(event->Time() == now);
1.161 + TEST(event->RemoteParty() == KTestRemoteParty1);
1.162 + TEST(event->Direction() == KTestDirection1);
1.163 + TEST(event->DurationType() == KTestDurationType1);
1.164 + TEST(event->Duration() == KTestDuration1);
1.165 + TEST(event->Status() == KTestStatus1);
1.166 + TEST(event->Subject() == KTestSubject1);
1.167 + TEST(event->Number() == KTestNumber1);
1.168 + TEST(event->Contact() == KTestContact1);
1.169 + TEST(event->Link() == KTestLink1);
1.170 + TEST(event->Data() == KTestData1);
1.171 +
1.172 + active->StartL();
1.173 + aClient.DeleteEvent(id, active->iStatus);
1.174 + CActiveScheduler::Start();
1.175 + TEST2(active->iStatus.Int(),KErrNone);
1.176 +
1.177 + active->StartL();
1.178 + aClient.GetEvent(*event, active->iStatus);
1.179 + CActiveScheduler::Start();
1.180 + TEST2(active->iStatus.Int(), KErrNotFound);
1.181 +
1.182 + CleanupStack::PopAndDestroy(2); // event, active
1.183 + }
1.184 +
1.185 +/**
1.186 +@SYMTestCaseID SYSLIB-LOGENG-CT-0911
1.187 +@SYMTestCaseDesc Tests for new CLogClient object creation
1.188 +@SYMTestPriority High
1.189 +@SYMTestActions Create a new CLogClient check for memory errors
1.190 +@SYMTestExpectedResults Test must not fail
1.191 +@SYMREQ REQ0000
1.192 +*/
1.193 +LOCAL_C void TestConstructionL()
1.194 + {
1.195 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0911 "));
1.196 + CLogClient* client = NULL;
1.197 +
1.198 + TInt failCount = 0;
1.199 + TBool finished = EFalse;
1.200 + TInt error;
1.201 +
1.202 + while(!finished)
1.203 + {
1.204 + TheTest.Printf(_L("%d\r\n"), failCount);
1.205 +
1.206 + if(failCount > 8)
1.207 + {
1.208 + TRAP(error, client = CLogClient::NewL(theFs));
1.209 + TEST2(error, KErrNone);
1.210 + TestBasicL(*client);
1.211 + finished = ETrue;
1.212 + continue;
1.213 + }
1.214 +
1.215 + __FILE_FAILNEXT(KErrNoMemory, failCount++);
1.216 +
1.217 + TRAP(error, client = CLogClient::NewL(theFs));
1.218 +
1.219 + __FILE_RESET;
1.220 +
1.221 + if (error == KErrNone)
1.222 + {
1.223 + finished = ETrue;
1.224 + TestBasicL(*client);
1.225 + }
1.226 + else
1.227 + {
1.228 + TEST2(error, KErrNoMemory);
1.229 + TestUtils::DeleteDatabaseL();
1.230 + }
1.231 + }
1.232 +
1.233 + delete client;
1.234 + TheTest.Printf(_L("\r\nThe test has succeeded at iteration %d\n"), failCount);
1.235 + }
1.236 +
1.237 +/**
1.238 +@SYMTestCaseID SYSLIB-LOGENG-CT-0912
1.239 +@SYMTestCaseDesc Adding an event type test,
1.240 + Tests for CLogClient::AddEventType() function
1.241 +@SYMTestPriority High
1.242 +@SYMTestActions Check for file failure errors while adding event types
1.243 +@SYMTestExpectedResults Test must not fail
1.244 +@SYMREQ REQ0000
1.245 +*/
1.246 +LOCAL_C void TestAddEventTypeL(CLogClient& aClient)
1.247 + {
1.248 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0912 "));
1.249 + CLogEventType* type = CLogEventType::NewL();
1.250 + CleanupStack::PushL(type);
1.251 +
1.252 + type->SetUid(KTestEventUid);
1.253 + type->SetDescription(KTestEventDesc1);
1.254 + type->SetLoggingEnabled(ETrue);
1.255 +
1.256 + CTestActive* active = new(ELeave)CTestActive();
1.257 + CleanupStack::PushL(active);
1.258 +
1.259 + TInt failCount = 0;
1.260 + TBool finished = EFalse;
1.261 + TInt error;
1.262 +
1.263 + while(!finished)
1.264 + {
1.265 + error = KErrNone;
1.266 + if(failCount == 8)
1.267 + {
1.268 + aClient.AddEventType(*type, active->iStatus);
1.269 + active->StartL();
1.270 + CActiveScheduler::Start();
1.271 + TEST2(active->iStatus.Int(), KErrNone);
1.272 + finished = ETrue;
1.273 + continue;
1.274 + }
1.275 +
1.276 + TheTest.Printf(_L("%d \r"), failCount);
1.277 +
1.278 + __FILE_FAILNEXT(KErrNoMemory, failCount++);
1.279 +
1.280 + aClient.AddEventType(*type, active->iStatus);
1.281 +
1.282 + active->StartL();
1.283 + CActiveScheduler::Start();
1.284 +
1.285 + if (active->iStatus == KErrNone)
1.286 + finished = ETrue;
1.287 + else
1.288 + error = active->iStatus.Int();
1.289 +
1.290 + __FILE_RESET;
1.291 +
1.292 + if (error == KErrNoMemory)
1.293 + {
1.294 + active->StartL();
1.295 + aClient.GetEventType(*type, active->iStatus);
1.296 + CActiveScheduler::Start();
1.297 + TEST2(active->iStatus.Int(), KErrNotFound);
1.298 + }
1.299 + else
1.300 + TEST2(error, KErrNone);
1.301 +
1.302 + }
1.303 +
1.304 + active->StartL();
1.305 + aClient.AddEventType(*type, active->iStatus);
1.306 + CActiveScheduler::Start();
1.307 + TEST2(active->iStatus.Int(), KErrAlreadyExists);
1.308 +
1.309 + CleanupStack::PopAndDestroy(2); // active, type
1.310 + TheTest.Printf(_L("\r\nThe test has succeeded at iteration %d\n"), failCount);
1.311 + }
1.312 +
1.313 +/**
1.314 +@SYMTestCaseID SYSLIB-LOGENG-CT-0913
1.315 +@SYMTestCaseDesc Getting an event type test.
1.316 + Tests for CLogClient::GetEventType() function
1.317 +@SYMTestPriority High
1.318 +@SYMTestActions Check for file failure errors while getting event types
1.319 +@SYMTestExpectedResults Test must not fail
1.320 +@SYMREQ REQ0000
1.321 +*/
1.322 +LOCAL_C void TestGetEventTypeL(CLogClient& aClient)
1.323 + {
1.324 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0913 "));
1.325 + CLogEventType* type = CLogEventType::NewL();
1.326 + CleanupStack::PushL(type);
1.327 +
1.328 + type->SetUid(KTestEventUid);
1.329 +
1.330 + CTestActive* active = new(ELeave)CTestActive();
1.331 + CleanupStack::PushL(active);
1.332 +
1.333 + TInt failCount = 0;
1.334 + TBool finished = EFalse;
1.335 +
1.336 + while(!finished)
1.337 + {
1.338 + TheTest.Printf(_L("%d \r"), failCount);
1.339 + __FILE_FAILNEXT(KErrNoMemory, failCount++);
1.340 +
1.341 + aClient.GetEventType(*type, active->iStatus);
1.342 +
1.343 + active->StartL();
1.344 + CActiveScheduler::Start();
1.345 +
1.346 + if (active->iStatus == KErrNone)
1.347 + finished = ETrue;
1.348 + else
1.349 + {
1.350 + TEST2(active->iStatus.Int(), KErrNoMemory);
1.351 + TEST(type->Description() == KNullDesC);
1.352 + }
1.353 +
1.354 + __FILE_RESET;
1.355 + }
1.356 +
1.357 + TEST(type->Uid() == KTestEventUid);
1.358 + TEST(type->Description() == KTestEventDesc1);
1.359 + TEST(type->LoggingEnabled());
1.360 +
1.361 + CleanupStack::PopAndDestroy(2); // active, type
1.362 + TheTest.Printf(_L("\r\nThe test has succeeded at iteration %d\n"), failCount);
1.363 + }
1.364 +
1.365 +/**
1.366 +@SYMTestCaseID SYSLIB-LOGENG-CT-0914
1.367 +@SYMTestCaseDesc Changing an event type test,
1.368 + Tests for CLogClient::ChangeEventType() function
1.369 +@SYMTestPriority High
1.370 +@SYMTestActions Check for file failure errors while changing event types
1.371 +@SYMTestExpectedResults Test must not fail
1.372 +@SYMREQ REQ0000
1.373 +*/
1.374 +LOCAL_C void TestChangeEventTypeL(CLogClient& aClient)
1.375 + {
1.376 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0914 "));
1.377 + CTestActive* active = new(ELeave)CTestActive();
1.378 + CleanupStack::PushL(active);
1.379 +
1.380 + CLogEventType* type = CLogEventType::NewL();
1.381 + CleanupStack::PushL(type);
1.382 +
1.383 + type->SetUid(KTestEventUid);
1.384 +
1.385 + TInt failCount = 0;
1.386 + TBool finished = EFalse;
1.387 + TInt error;
1.388 +
1.389 + while(!finished)
1.390 + {
1.391 + error = KErrNone;
1.392 +
1.393 + type->SetDescription(KTestEventDesc2);
1.394 + type->SetLoggingEnabled(EFalse);
1.395 +
1.396 + if(failCount == 8)
1.397 + {
1.398 + aClient.ChangeEventType(*type, active->iStatus);
1.399 + active->StartL();
1.400 + CActiveScheduler::Start();
1.401 + TEST2(active->iStatus.Int(), KErrNone);
1.402 + finished = ETrue;
1.403 + continue;
1.404 + }
1.405 +
1.406 + TheTest.Printf(_L("%d \r"), failCount);
1.407 + __FILE_FAILNEXT(KErrNoMemory, failCount++);
1.408 +
1.409 + aClient.ChangeEventType(*type, active->iStatus);
1.410 +
1.411 + active->StartL();
1.412 + CActiveScheduler::Start();
1.413 +
1.414 + if (active->iStatus == KErrNone)
1.415 + finished = ETrue;
1.416 + else
1.417 + error = active->iStatus.Int();
1.418 +
1.419 + __FILE_RESET;
1.420 +
1.421 + if (error == KErrNoMemory)
1.422 + {
1.423 + active->StartL();
1.424 + aClient.GetEventType(*type, active->iStatus);
1.425 + CActiveScheduler::Start();
1.426 + TEST2(active->iStatus.Int(), KErrNone);
1.427 +
1.428 + TEST(type->Description() == KTestEventDesc1);
1.429 + TEST(type->LoggingEnabled());
1.430 + }
1.431 + else
1.432 + TEST2(error, KErrNone);
1.433 + }
1.434 +
1.435 + type->SetUid(KTestEventUid);
1.436 +
1.437 + active->StartL();
1.438 + aClient.GetEventType(*type, active->iStatus);
1.439 + CActiveScheduler::Start();
1.440 + TEST2(active->iStatus.Int(), KErrNone);
1.441 +
1.442 + TEST(type->Uid() == KTestEventUid);
1.443 + TEST(type->Description() == KTestEventDesc2);
1.444 + TEST(type->LoggingEnabled() == EFalse);
1.445 +
1.446 + CleanupStack::PopAndDestroy(2); // type, active
1.447 + TheTest.Printf(_L("\r\nThe test has succeeded at iteration %d\n"), failCount);
1.448 + }
1.449 +
1.450 +/**
1.451 +@SYMTestCaseID SYSLIB-LOGENG-CT-0915
1.452 +@SYMTestCaseDesc Deleting an event type test
1.453 + Tests for CLogClient::DeleteEventType() function
1.454 +@SYMTestPriority High
1.455 +@SYMTestActions Check for file failure errors while deleting event types
1.456 +@SYMTestExpectedResults Test must not fail
1.457 +@SYMREQ REQ0000
1.458 +*/
1.459 +LOCAL_C void TestDeleteEventTypeL(CLogClient& aClient)
1.460 + {
1.461 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0915 "));
1.462 + CTestActive* active = new(ELeave)CTestActive();
1.463 + CleanupStack::PushL(active);
1.464 +
1.465 + CLogEventType* type = CLogEventType::NewL();
1.466 + CleanupStack::PushL(type);
1.467 +
1.468 + type->SetUid(KTestEventUid);
1.469 +
1.470 + TInt failCount = 0;
1.471 + TBool finished = EFalse;
1.472 + TInt error;
1.473 +
1.474 + while(!finished)
1.475 + {
1.476 + error = KErrNone;
1.477 +
1.478 + if(failCount == 8)
1.479 + {
1.480 + aClient.DeleteEventType(KTestEventUid, active->iStatus);
1.481 + active->StartL();
1.482 + CActiveScheduler::Start();
1.483 + TEST2(active->iStatus.Int(), KErrNone);
1.484 + finished = ETrue;
1.485 + continue;
1.486 + }
1.487 +
1.488 + TheTest.Printf(_L("%d \r"), failCount);
1.489 + __FILE_FAILNEXT(KErrNoMemory, failCount++);
1.490 +
1.491 + aClient.DeleteEventType(KTestEventUid, active->iStatus);
1.492 +
1.493 + active->StartL();
1.494 + CActiveScheduler::Start();
1.495 +
1.496 + if (active->iStatus == KErrNone)
1.497 + finished = ETrue;
1.498 + else
1.499 + error = active->iStatus.Int();
1.500 +
1.501 + __FILE_RESET;
1.502 +
1.503 + if (error == KErrNoMemory)
1.504 + {
1.505 + active->StartL();
1.506 + aClient.GetEventType(*type, active->iStatus);
1.507 + CActiveScheduler::Start();
1.508 + TEST2(active->iStatus.Int(), KErrNone);
1.509 + }
1.510 + else
1.511 + TEST2(error, KErrNone);
1.512 + }
1.513 +
1.514 + active->StartL();
1.515 + aClient.GetEventType(*type, active->iStatus);
1.516 + CActiveScheduler::Start();
1.517 + TEST2(active->iStatus.Int(), KErrNotFound);
1.518 +
1.519 + CleanupStack::PopAndDestroy(2); // type, active
1.520 + TheTest.Printf(_L("\r\nThe test has succeeded at iteration %d\n"), failCount);
1.521 + }
1.522 +
1.523 +/**
1.524 +@SYMTestCaseID SYSLIB-LOGENG-CT-0916
1.525 +@SYMTestCaseDesc Adding an event test,
1.526 + Tests for CLogClient::AddEvent() function
1.527 +@SYMTestPriority High
1.528 +@SYMTestActions Check for file failure errors while adding event
1.529 + Tests for no error conditons,and the event information
1.530 +@SYMTestExpectedResults Test must not fail
1.531 +@SYMREQ REQ0000
1.532 +*/
1.533 +LOCAL_C void TestAddEventL(CLogClient& aClient)
1.534 + {
1.535 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0916 "));
1.536 + // Ensure we always start from the same state
1.537 + TestUtils::DeleteDatabaseL();
1.538 +
1.539 + CLogEventType* type = CLogEventType::NewL();
1.540 + CleanupStack::PushL(type);
1.541 +
1.542 + type->SetUid(KTestEventUid);
1.543 + type->SetDescription(KTestEventDesc1);
1.544 + type->SetLoggingEnabled(ETrue);
1.545 +
1.546 + CTestActive* active = new(ELeave)CTestActive();
1.547 + CleanupStack::PushL(active);
1.548 +
1.549 + active->StartL();
1.550 + aClient.AddEventType(*type, active->iStatus);
1.551 + CActiveScheduler::Start();
1.552 + TEST2(active->iStatus.Int(), KErrNone);
1.553 +
1.554 + CLogEvent* event = CLogEvent::NewL();
1.555 + CleanupStack::PushL(event);
1.556 +
1.557 + TTime now;
1.558 + now.UniversalTime();
1.559 +
1.560 + event->SetEventType(KTestEventUid);
1.561 + event->SetRemoteParty(KTestRemoteParty1);
1.562 + event->SetDirection(KTestDirection1);
1.563 + event->SetDurationType(KTestDurationType1);
1.564 + event->SetDuration(KTestDuration1);
1.565 + event->SetStatus(KTestStatus1);
1.566 + event->SetSubject(KTestSubject1);
1.567 + event->SetNumber(KTestNumber1);
1.568 + event->SetContact(KTestContact1);
1.569 + event->SetLink(KTestLink1);
1.570 + event->SetDataL(KTestData1);
1.571 +
1.572 + TInt failCount = 0;
1.573 + TBool finished = EFalse;
1.574 + TInt error;
1.575 +
1.576 + while(!finished)
1.577 + {
1.578 + error = KErrNone;
1.579 +
1.580 + if(failCount == 8)
1.581 + {
1.582 + aClient.AddEvent(*event, active->iStatus);
1.583 + active->StartL();
1.584 + CActiveScheduler::Start();
1.585 + TEST2(active->iStatus.Int(), KErrNone);
1.586 + finished = ETrue;
1.587 + continue;
1.588 + }
1.589 +
1.590 + TheTest.Printf(_L("%d \r"), failCount);
1.591 + __FILE_FAILNEXT(KErrNoMemory, failCount++);
1.592 + aClient.AddEvent(*event, active->iStatus);
1.593 +
1.594 + active->StartL();
1.595 + CActiveScheduler::Start();
1.596 +
1.597 + if (active->iStatus == KErrNone)
1.598 + finished = ETrue;
1.599 + else
1.600 + error = active->iStatus.Int();
1.601 +
1.602 + __FILE_RESET;
1.603 +
1.604 + if (error == KErrNoMemory)
1.605 + {
1.606 + event->SetId(0);
1.607 +
1.608 + active->StartL();
1.609 + aClient.GetEvent(*event, active->iStatus);
1.610 + CActiveScheduler::Start();
1.611 + TEST2(active->iStatus.Int(), KErrNotFound);
1.612 +
1.613 + event->SetId(KLogNullId);
1.614 + }
1.615 + else
1.616 + TEST2(error, KErrNone);
1.617 + }
1.618 +
1.619 + TEST(event->Id() == 0);
1.620 + TEST(event->Time() >= now);
1.621 + TEST(event->Description() == KTestEventDesc1);
1.622 +
1.623 + active->StartL();
1.624 + aClient.GetEvent(*event, active->iStatus);
1.625 + CActiveScheduler::Start();
1.626 + TEST2(active->iStatus.Int(), KErrNone);
1.627 +
1.628 + CleanupStack::PopAndDestroy(3); // event, active, type
1.629 + TheTest.Printf(_L("\r\nThe test has succeeded at iteration %d\n"), failCount);
1.630 + }
1.631 +
1.632 +/**
1.633 +@SYMTestCaseID SYSLIB-LOGENG-CT-0917
1.634 +@SYMTestCaseDesc Get an events' information test
1.635 + Tests for CLogClient::GetEvent() function
1.636 +@SYMTestPriority High
1.637 +@SYMTestActions Check for file failure errors while getting an event
1.638 + Tests for no error conditons,and the event information.
1.639 +@SYMTestExpectedResults Test must not fail
1.640 +@SYMREQ REQ0000
1.641 +*/
1.642 +LOCAL_C void TestGetEventL(CLogClient& aClient)
1.643 + {
1.644 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0917 "));
1.645 + CTestActive* active = new(ELeave)CTestActive();
1.646 + CleanupStack::PushL(active);
1.647 +
1.648 + CLogEvent* event = CLogEvent::NewL();
1.649 + CleanupStack::PushL(event);
1.650 +
1.651 + event->SetId(0);
1.652 +
1.653 + TInt failCount = 0;
1.654 + TBool finished = EFalse;
1.655 +
1.656 + while(!finished)
1.657 + {
1.658 + TheTest.Printf(_L("%d \r"), failCount);
1.659 + __FILE_FAILNEXT(KErrNoMemory, failCount++);
1.660 + aClient.GetEvent(*event, active->iStatus);
1.661 +
1.662 + active->StartL();
1.663 + CActiveScheduler::Start();
1.664 +
1.665 + if (active->iStatus == KErrNone)
1.666 + finished = ETrue;
1.667 + else
1.668 + TEST2(active->iStatus.Int(), KErrNoMemory);
1.669 +
1.670 + __FILE_RESET;
1.671 + }
1.672 +
1.673 + TEST(event->Id() == 0);
1.674 + TEST(event->Time() > TTime(0));
1.675 + TEST(event->Description() == KTestEventDesc1);
1.676 + TEST(event->EventType() == KTestEventUid);
1.677 + TEST(event->RemoteParty() == KTestRemoteParty1);
1.678 + TEST(event->Direction() == KTestDirection1);
1.679 + TEST(event->DurationType() == KTestDurationType1);
1.680 + TEST(event->Duration() == KTestDuration1);
1.681 + TEST(event->Status() == KTestStatus1);
1.682 + TEST(event->Subject() == KTestSubject1);
1.683 + TEST(event->Number() == KTestNumber1);
1.684 + TEST(event->Contact() == KTestContact1);
1.685 + TEST(event->Link() == KTestLink1);
1.686 + TEST(event->Data() == KTestData1);
1.687 +
1.688 + CleanupStack::PopAndDestroy(2); // event, active
1.689 + TheTest.Printf(_L("\r\nThe test has succeeded at iteration %d\n"), failCount);
1.690 + }
1.691 +
1.692 +/**
1.693 +@SYMTestCaseID SYSLIB-LOGENG-CT-0918
1.694 +@SYMTestCaseDesc Changing an event type test
1.695 + Tests for CLogClient::ChangeEvent() function
1.696 +@SYMTestPriority High
1.697 +@SYMTestActions Check for file failure errors while changing an event
1.698 + Tests for no error conditons,and the event information for the changed event
1.699 +@SYMTestExpectedResults Test must not fail
1.700 +@SYMREQ REQ0000
1.701 +*/
1.702 +LOCAL_C void TestChangeEventL(CLogClient& aClient)
1.703 + {
1.704 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0918 "));
1.705 + CTestActive* active = new(ELeave)CTestActive();
1.706 + CleanupStack::PushL(active);
1.707 +
1.708 + CLogEvent* event = CLogEvent::NewL();
1.709 + CleanupStack::PushL(event);
1.710 +
1.711 + TTime now;
1.712 + now.UniversalTime();
1.713 +
1.714 + TInt failCount = 0;
1.715 + TBool finished = EFalse;
1.716 + TInt error;
1.717 +
1.718 + while(!finished)
1.719 + {
1.720 + error = KErrNone;
1.721 +
1.722 + event->SetId(0);
1.723 + event->SetTime(now);
1.724 + event->SetRemoteParty(KTestRemoteParty2);
1.725 + event->SetDirection(KTestDirection2);
1.726 + event->SetDurationType(KTestDurationType2);
1.727 + event->SetDuration(KTestDuration2);
1.728 + event->SetStatus(KTestStatus2);
1.729 + event->SetSubject(KTestSubject2);
1.730 + event->SetNumber(KTestNumber2);
1.731 + event->SetContact(KTestContact2);
1.732 + event->SetLink(KTestLink2);
1.733 + event->SetDataL(KTestData2);
1.734 +
1.735 + if(failCount == 14)
1.736 + {
1.737 + aClient.ChangeEvent(*event, active->iStatus);
1.738 + active->StartL();
1.739 + CActiveScheduler::Start();
1.740 + TEST2(active->iStatus.Int(), KErrNone);
1.741 + finished = ETrue;
1.742 + continue;
1.743 + }
1.744 +
1.745 + TheTest.Printf(_L("%d \r"), failCount);
1.746 + __FILE_FAILNEXT(KErrNoMemory, failCount++);
1.747 +
1.748 + aClient.ChangeEvent(*event, active->iStatus);
1.749 +
1.750 + active->StartL();
1.751 + CActiveScheduler::Start();
1.752 + if (active->iStatus == KErrNone)
1.753 + finished = ETrue;
1.754 + else
1.755 + error = active->iStatus.Int();
1.756 +
1.757 + __FILE_RESET;
1.758 +
1.759 + if (error == KErrNoMemory)
1.760 + {
1.761 + active->StartL();
1.762 + aClient.GetEvent(*event, active->iStatus);
1.763 + CActiveScheduler::Start();
1.764 + if (active->iStatus != KErrNone)
1.765 + TheTest.Printf(_L("\nerror code:%d failcount:%d\n"),active->iStatus.Int(),failCount);
1.766 + TEST2(active->iStatus.Int(), KErrNone);
1.767 +
1.768 + TEST(event->Id() == 0);
1.769 + TEST(event->Time() > TTime(0));
1.770 + TEST(event->Description() == KTestEventDesc1);
1.771 + TEST(event->EventType() == KTestEventUid);
1.772 + TEST(event->RemoteParty() == KTestRemoteParty1);
1.773 + TEST(event->Direction() == KTestDirection1);
1.774 + TEST(event->DurationType() == KTestDurationType1);
1.775 + TEST(event->Duration() == KTestDuration1);
1.776 + TEST(event->Status() == KTestStatus1);
1.777 + TEST(event->Subject() == KTestSubject1);
1.778 + TEST(event->Number() == KTestNumber1);
1.779 + TEST(event->Contact() == KTestContact1);
1.780 + TEST(event->Link() == KTestLink1);
1.781 + TEST(event->Data() == KTestData1);
1.782 + }
1.783 + else
1.784 + TEST2(error, KErrNone);
1.785 + }
1.786 +
1.787 + active->StartL();
1.788 + aClient.GetEvent(*event, active->iStatus);
1.789 + CActiveScheduler::Start();
1.790 + TEST2(active->iStatus.Int(), KErrNone);
1.791 +
1.792 + TEST(event->Id() == 0);
1.793 + TEST(event->Time() == now);
1.794 + TEST(event->Description() == KTestEventDesc1);
1.795 + TEST(event->EventType() == KTestEventUid);
1.796 + TEST(event->RemoteParty() == KTestRemoteParty2);
1.797 + TEST(event->Direction() == KTestDirection2);
1.798 + TEST(event->DurationType() == KTestDurationType2);
1.799 + TEST(event->Duration() == KTestDuration2);
1.800 + TEST(event->Status() == KTestStatus2);
1.801 + TEST(event->Subject() == KTestSubject2);
1.802 + TEST(event->Number() == KTestNumber2);
1.803 + TEST(event->Contact() == KTestContact2);
1.804 + TEST(event->Link() == KTestLink2);
1.805 + TEST(event->Data() == KTestData2);
1.806 +
1.807 + CleanupStack::PopAndDestroy(2); // event, active
1.808 + TheTest.Printf(_L("\r\nThe test has succeeded at iteration %d\n"), failCount);
1.809 + }
1.810 +
1.811 +/**
1.812 +@SYMTestCaseID SYSLIB-LOGENG-CT-0919
1.813 +@SYMTestCaseDesc Deleting an event test,
1.814 + Tests for CLogClient::DeleteEvent() function
1.815 +@SYMTestPriority High
1.816 +@SYMTestActions Check for file failure errors while deleting an event
1.817 + Tests for ErrNone flag.
1.818 +@SYMTestExpectedResults Test must not fail
1.819 +@SYMREQ REQ0000
1.820 +*/
1.821 +LOCAL_C void TestDeleteEventL(CLogClient& aClient)
1.822 + {
1.823 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0919 "));
1.824 + CTestActive* active = new(ELeave)CTestActive();
1.825 + CleanupStack::PushL(active);
1.826 +
1.827 + CLogEvent* event = CLogEvent::NewL();
1.828 + CleanupStack::PushL(event);
1.829 +
1.830 + event->SetId(0);
1.831 +
1.832 + TInt failCount = 0;
1.833 + TBool finished = EFalse;
1.834 + TInt error;
1.835 +
1.836 + while(!finished)
1.837 + {
1.838 + error = KErrNone;
1.839 +
1.840 + if(failCount == 10)
1.841 + {
1.842 + aClient.DeleteEvent(0, active->iStatus);
1.843 + active->StartL();
1.844 + CActiveScheduler::Start();
1.845 + TEST2(active->iStatus.Int(), KErrNone);
1.846 + finished = ETrue;
1.847 + continue;
1.848 + }
1.849 +
1.850 + TheTest.Printf(_L("%d \r"), failCount);
1.851 + __FILE_FAILNEXT(KErrNoMemory, failCount++);
1.852 +
1.853 + aClient.DeleteEvent(0, active->iStatus);
1.854 +
1.855 + active->StartL();
1.856 + CActiveScheduler::Start();
1.857 +
1.858 + if (active->iStatus == KErrNone)
1.859 + finished = ETrue;
1.860 + else
1.861 + error = active->iStatus.Int();
1.862 +
1.863 + __FILE_RESET;
1.864 +
1.865 + if (error == KErrNoMemory)
1.866 + {
1.867 + active->StartL();
1.868 + aClient.GetEvent(*event, active->iStatus);
1.869 + CActiveScheduler::Start();
1.870 + TEST2(active->iStatus.Int(), KErrNone);
1.871 + }
1.872 + else
1.873 + TEST2(error, KErrNone);
1.874 + }
1.875 +
1.876 + active->StartL();
1.877 + aClient.GetEvent(*event, active->iStatus);
1.878 + CActiveScheduler::Start();
1.879 + TEST2(active->iStatus.Int(), KErrNotFound);
1.880 +
1.881 + CleanupStack::PopAndDestroy(2); // event, active
1.882 + TheTest.Printf(_L("\r\nThe test has succeeded at iteration %d\n"), failCount);
1.883 + }
1.884 +
1.885 +/**
1.886 +@SYMTestCaseID SYSLIB-LOGENG-CT-0920
1.887 +@SYMTestCaseDesc Getting the Log Engine configuration information test
1.888 + Tests for CLogClient::GetConfig() function
1.889 +@SYMTestPriority High
1.890 +@SYMTestActions Check for file failure errors while getting the configuration data
1.891 + Tests for ErrNone flag.Tests for the retrieved information
1.892 +@SYMTestExpectedResults Test must not fail
1.893 +@SYMREQ REQ0000
1.894 +*/
1.895 +LOCAL_C void TestGetConfigL(CLogClient& aClient)
1.896 + {
1.897 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0920 "));
1.898 + CTestActive* active = new(ELeave)CTestActive();
1.899 + CleanupStack::PushL(active);
1.900 +
1.901 + TLogConfig config;
1.902 +
1.903 + TEST(config.iMaxEventAge == 0);
1.904 + TEST(config.iMaxLogSize == 0);
1.905 + TEST(config.iMaxRecentLogSize == 0);
1.906 +
1.907 + TInt failCount = 0;
1.908 + TBool finished = EFalse;
1.909 +
1.910 + while(!finished)
1.911 + {
1.912 + TheTest.Printf(_L("%d \r"), failCount);
1.913 + __FILE_FAILNEXT(KErrNoMemory, failCount++);
1.914 + aClient.GetConfig(config, active->iStatus);
1.915 +
1.916 + active->StartL();
1.917 + CActiveScheduler::Start();
1.918 +
1.919 + if (active->iStatus == KErrNone)
1.920 + finished = ETrue;
1.921 + else
1.922 + TEST2(active->iStatus.Int(), KErrNoMemory);
1.923 +
1.924 + __FILE_RESET;
1.925 + }
1.926 +
1.927 + TEST(config.iMaxEventAge > 0);
1.928 + TEST(config.iMaxLogSize > 0);
1.929 + TEST(config.iMaxRecentLogSize > 0);
1.930 +
1.931 + CleanupStack::PopAndDestroy(); // active
1.932 + TheTest.Printf(_L("\r\nThe test has succeeded at iteration %d\n"), failCount);
1.933 + }
1.934 +
1.935 +/**
1.936 +@SYMTestCaseID SYSLIB-LOGENG-CT-0921
1.937 +@SYMTestCaseDesc Changing the configuration of Log Engine test,
1.938 + Tests for CLogClient::ChangeConfig() function
1.939 +@SYMTestPriority High
1.940 +@SYMTestActions Check for file failure errors while changing the log engine configuration data
1.941 + Tests for ErrNone error conditons.Tests for the changed configuration data
1.942 +@SYMTestExpectedResults Test must not fail
1.943 +@SYMREQ REQ0000
1.944 +*/
1.945 +LOCAL_C void TestChangeConfigL(CLogClient& aClient)
1.946 + {
1.947 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0921 "));
1.948 + CTestActive* active = new(ELeave)CTestActive();
1.949 + CleanupStack::PushL(active);
1.950 +
1.951 + TLogConfig configOld;
1.952 +
1.953 + active->StartL();
1.954 + aClient.GetConfig(configOld, active->iStatus);
1.955 + CActiveScheduler::Start();
1.956 + TEST2(active->iStatus.Int(), KErrNone);
1.957 +
1.958 + TLogConfig config;
1.959 +
1.960 + TInt failCount = 0;
1.961 + TBool finished = EFalse;
1.962 + TInt error;
1.963 +
1.964 + while(!finished)
1.965 + {
1.966 + error = KErrNone;
1.967 +
1.968 + config.iMaxLogSize = KTestMaxLogSize;
1.969 + config.iMaxRecentLogSize = KTestMaxRecentLogSize;
1.970 + config.iMaxEventAge = KTestMaxEventAge;
1.971 +
1.972 + if(failCount == 11)
1.973 + {
1.974 + aClient.ChangeConfig(config, active->iStatus);
1.975 + active->StartL();
1.976 + CActiveScheduler::Start();
1.977 + TEST2(active->iStatus.Int(), KErrNone);
1.978 + finished = ETrue;
1.979 + continue;
1.980 + }
1.981 +
1.982 + TheTest.Printf(_L("%d \r"), failCount);
1.983 + __FILE_FAILNEXT(KErrNoMemory, failCount++);
1.984 +
1.985 + aClient.ChangeConfig(config, active->iStatus);
1.986 +
1.987 + active->StartL();
1.988 + CActiveScheduler::Start();
1.989 +
1.990 + if (active->iStatus == KErrNone)
1.991 + finished = ETrue;
1.992 + else
1.993 + error = active->iStatus.Int();
1.994 +
1.995 + __FILE_RESET;
1.996 +
1.997 + if (error == KErrNoMemory)
1.998 + {
1.999 + active->StartL();
1.1000 + aClient.GetConfig(config, active->iStatus);
1.1001 + CActiveScheduler::Start();
1.1002 + TEST2(active->iStatus.Int(), KErrNone);
1.1003 +
1.1004 + TEST(config.iMaxLogSize == configOld.iMaxLogSize);
1.1005 + TEST(config.iMaxRecentLogSize == configOld.iMaxRecentLogSize);
1.1006 + TEST(config.iMaxEventAge == configOld.iMaxEventAge);
1.1007 + }
1.1008 + else
1.1009 + TEST2(error, KErrNone);
1.1010 + }
1.1011 +
1.1012 + TEST(config.iMaxLogSize == KTestMaxLogSize);
1.1013 + TEST(config.iMaxRecentLogSize == KTestMaxRecentLogSize);
1.1014 + TEST(config.iMaxEventAge == KTestMaxEventAge);
1.1015 +
1.1016 + CleanupStack::PopAndDestroy(); // active
1.1017 + TheTest.Printf(_L("\r\nThe test has succeeded at iteration %d\n"), failCount);
1.1018 + }
1.1019 +
1.1020 +/**
1.1021 +@SYMTestCaseID SYSLIB-LOGENG-CT-0922
1.1022 +@SYMTestCaseDesc Getting a standard string from the specified resource file test
1.1023 + Tests for CLogClient::GetString() function
1.1024 +@SYMTestPriority High
1.1025 +@SYMTestActions Check for file failure errors while changing the log engine configuration data
1.1026 + Check for ErrNone flag.Tests for general errors,and retrieved string length.
1.1027 +@SYMTestExpectedResults Test must not fail
1.1028 +@SYMREQ REQ0000
1.1029 +*/
1.1030 +LOCAL_C void TestGetStringL(CLogClient& aClient)
1.1031 + {
1.1032 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0922 "));
1.1033 + TBuf<KLogMaxSharedStringLength> str;
1.1034 +
1.1035 + TInt failCount = 0;
1.1036 + TBool finished = EFalse;
1.1037 + TInt error;
1.1038 +
1.1039 + while(!finished)
1.1040 + {
1.1041 + TheTest.Printf(_L("%d \r"), failCount);
1.1042 + __FILE_FAILNEXT(KErrNoMemory, failCount++);
1.1043 +
1.1044 + error = aClient.GetString(str, R_LOG_DIR_IN);
1.1045 +
1.1046 + __FILE_RESET;
1.1047 +
1.1048 + if (error == KErrNone)
1.1049 + {
1.1050 + finished = ETrue;
1.1051 + TEST(str.Length() > 0);
1.1052 + }
1.1053 + else
1.1054 + {
1.1055 + TEST2(error, KErrNoMemory);
1.1056 + TEST(str.Length() == 0);
1.1057 + }
1.1058 + }
1.1059 + TheTest.Printf(_L("\r\nThe test has succeeded at iteration %d\n"), failCount);
1.1060 + }
1.1061 +
1.1062 +/**
1.1063 +@SYMTestCaseID SYSLIB-LOGENG-CT-0923
1.1064 +@SYMTestCaseDesc Clearing the Log Event test.
1.1065 + Tests for CLogClient::ClearLog() function
1.1066 +@SYMTestPriority High
1.1067 +@SYMTestActions Add 4 events to the event log,check for ErrNone flag
1.1068 + Clear the log by calling CLogClient::ClearLog() function.
1.1069 + Try for getting the added 4 events.Check for not found error.
1.1070 +@SYMTestExpectedResults Test must not fail
1.1071 +@SYMREQ REQ12748
1.1072 +*/
1.1073 +LOCAL_C void TestClearEventLogL(CLogClient& aClient
1.1074 +#ifdef SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM
1.1075 + , TBool aUseSimId = EFalse
1.1076 +#endif
1.1077 + )
1.1078 + {
1.1079 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0923 "));
1.1080 + TTime now;
1.1081 + now.UniversalTime();
1.1082 +
1.1083 + TDateTime dt(now.DateTime());
1.1084 + dt.SetYear(dt.Year() - 1);
1.1085 + TTime date1(dt);
1.1086 +
1.1087 + dt.SetYear(dt.Year() - 1);
1.1088 + TTime date2(dt);
1.1089 +
1.1090 + CTestActive* active = new(ELeave)CTestActive();
1.1091 + CleanupStack::PushL(active);
1.1092 +
1.1093 + CLogEvent* event1 = CLogEvent::NewL();
1.1094 + CleanupStack::PushL(event1);
1.1095 + event1->SetEventType(KTestEventUid);
1.1096 +
1.1097 + active->StartL();
1.1098 + aClient.AddEvent(*event1, active->iStatus);
1.1099 + CActiveScheduler::Start();
1.1100 + TEST2(active->iStatus.Int(), KErrNone);
1.1101 +
1.1102 + event1->SetTime(date1);
1.1103 +
1.1104 + active->StartL();
1.1105 + aClient.ChangeEvent(*event1, active->iStatus);
1.1106 + CActiveScheduler::Start();
1.1107 + TEST2(active->iStatus.Int(), KErrNone);
1.1108 +
1.1109 + CLogEvent* event2 = CLogEvent::NewL();
1.1110 + CleanupStack::PushL(event2);
1.1111 + event2->SetEventType(KTestEventUid);
1.1112 +
1.1113 + active->StartL();
1.1114 + aClient.AddEvent(*event2, active->iStatus);
1.1115 + CActiveScheduler::Start();
1.1116 + TEST2(active->iStatus.Int(), KErrNone);
1.1117 +
1.1118 + event2->SetTime(date1);
1.1119 +
1.1120 + active->StartL();
1.1121 + aClient.ChangeEvent(*event2, active->iStatus);
1.1122 + CActiveScheduler::Start();
1.1123 + TEST2(active->iStatus.Int(), KErrNone);
1.1124 +
1.1125 + CLogEvent* event3 = CLogEvent::NewL();
1.1126 + CleanupStack::PushL(event3);
1.1127 + event3->SetEventType(KTestEventUid);
1.1128 +
1.1129 + active->StartL();
1.1130 + aClient.AddEvent(*event3, active->iStatus);
1.1131 + CActiveScheduler::Start();
1.1132 + TEST2(active->iStatus.Int(), KErrNone);
1.1133 +
1.1134 + event3->SetTime(date2);
1.1135 +
1.1136 + active->StartL();
1.1137 + aClient.ChangeEvent(*event3, active->iStatus);
1.1138 + CActiveScheduler::Start();
1.1139 + TEST2(active->iStatus.Int(), KErrNone);
1.1140 +
1.1141 + CLogEvent* event4 = CLogEvent::NewL();
1.1142 + CleanupStack::PushL(event4);
1.1143 + event4->SetEventType(KTestEventUid);
1.1144 +
1.1145 + active->StartL();
1.1146 + aClient.AddEvent(*event4, active->iStatus);
1.1147 + CActiveScheduler::Start();
1.1148 + TEST2(active->iStatus.Int(), KErrNone);
1.1149 +
1.1150 + event4->SetTime(date2);
1.1151 +
1.1152 + active->StartL();
1.1153 + aClient.ChangeEvent(*event4, active->iStatus);
1.1154 + CActiveScheduler::Start();
1.1155 + TEST2(active->iStatus.Int(), KErrNone);
1.1156 +
1.1157 + TInt failCount = 0;
1.1158 + TBool finished = EFalse;
1.1159 +
1.1160 + while(!finished)
1.1161 + {
1.1162 + TheTest.Printf(_L("%d \r"), failCount);
1.1163 + __FILE_FAILNEXT(KErrNoMemory, failCount++);
1.1164 +
1.1165 +#ifdef SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM
1.1166 + if(aUseSimId)
1.1167 + {
1.1168 + aClient.ClearLog(date1, KLogNullSimId, active->iStatus);
1.1169 + }
1.1170 + else
1.1171 +#endif
1.1172 + {
1.1173 + aClient.ClearLog(date1, active->iStatus);
1.1174 + }
1.1175 +
1.1176 + __FILE_RESET;
1.1177 +
1.1178 + active->StartL();
1.1179 + CActiveScheduler::Start();
1.1180 +
1.1181 + if (active->iStatus == KErrNone)
1.1182 + finished = ETrue;
1.1183 + else
1.1184 + TEST2(active->iStatus.Int(), KErrNoMemory);
1.1185 + }
1.1186 +
1.1187 + active->StartL();
1.1188 + aClient.GetEvent(*event1, active->iStatus);
1.1189 + CActiveScheduler::Start();
1.1190 + if (active->iStatus != KErrNone)
1.1191 + TheTest.Printf(_L("error code:%d\n"),active->iStatus.Int());
1.1192 + TEST2(active->iStatus.Int(), KErrNone);
1.1193 +
1.1194 + active->StartL();
1.1195 + aClient.GetEvent(*event2, active->iStatus);
1.1196 + CActiveScheduler::Start();
1.1197 + TEST2(active->iStatus.Int(), KErrNone);
1.1198 +
1.1199 + active->StartL();
1.1200 + aClient.GetEvent(*event3, active->iStatus);
1.1201 + CActiveScheduler::Start();
1.1202 + TEST2(active->iStatus.Int(), KErrNotFound);
1.1203 +
1.1204 + active->StartL();
1.1205 + aClient.GetEvent(*event4, active->iStatus);
1.1206 + CActiveScheduler::Start();
1.1207 + TEST2(active->iStatus.Int(), KErrNotFound);
1.1208 +
1.1209 + active->StartL();
1.1210 + aClient.ClearLog(now, active->iStatus);
1.1211 + CActiveScheduler::Start();
1.1212 + TEST2(active->iStatus.Int(), KErrNone);
1.1213 +
1.1214 + active->StartL();
1.1215 + aClient.GetEvent(*event1, active->iStatus);
1.1216 + CActiveScheduler::Start();
1.1217 + TEST2(active->iStatus.Int(), KErrNotFound);
1.1218 +
1.1219 + active->StartL();
1.1220 + aClient.GetEvent(*event2, active->iStatus);
1.1221 + CActiveScheduler::Start();
1.1222 + TEST2(active->iStatus.Int(), KErrNotFound);
1.1223 +
1.1224 + CleanupStack::PopAndDestroy(5); // event4, event3, event2, event1, active
1.1225 + TheTest.Printf(_L("\r\nThe test has succeeded at iteration %d\n"), failCount);
1.1226 + }
1.1227 +
1.1228 +void doTestsL()
1.1229 + {
1.1230 + TestUtils::Initialize(_L("t_logfile"));
1.1231 +
1.1232 + TheTest.Start(_L("Construction + create db"));
1.1233 + TestUtils::DeleteDatabaseL();
1.1234 + TestConstructionL(); // Creates database
1.1235 + TheTest.Next(_L("Construction + open db"));
1.1236 + TestConstructionL(); // Opens existing database
1.1237 + TestUtils::DeleteDatabaseL();
1.1238 + theLog.Write(_L8("Test 1 OK\n"));
1.1239 +
1.1240 + CLogClient* client = CLogClient::NewL(theFs);
1.1241 + CleanupStack::PushL(client);
1.1242 +
1.1243 + TheTest.Next(_L("Add Event Type"));
1.1244 + TestAddEventTypeL(*client);
1.1245 + theLog.Write(_L8("Test 2 OK\n"));
1.1246 +
1.1247 + TheTest.Next(_L("Get Event Type"));
1.1248 + TestGetEventTypeL(*client);
1.1249 + theLog.Write(_L8("Test 3 OK\n"));
1.1250 +
1.1251 + TheTest.Next(_L("Change Event Type"));
1.1252 + TestChangeEventTypeL(*client);
1.1253 + theLog.Write(_L8("Test 4 OK\n"));
1.1254 +
1.1255 + TheTest.Next(_L("Delete Event Type"));
1.1256 + TestDeleteEventTypeL(*client);
1.1257 + theLog.Write(_L8("Test 5 OK\n"));
1.1258 +
1.1259 + TestUtils::DeleteDatabaseL();
1.1260 +
1.1261 + TheTest.Next(_L("Add Event"));
1.1262 + TestAddEventL(*client);
1.1263 + theLog.Write(_L8("Test 6 OK\n"));
1.1264 +
1.1265 + TheTest.Next(_L("Get Event"));
1.1266 + TestGetEventL(*client);
1.1267 + theLog.Write(_L8("Test 7 OK\n"));
1.1268 +
1.1269 + TheTest.Next(_L("Change Event"));
1.1270 + TestChangeEventL(*client);
1.1271 + theLog.Write(_L8("Test 8 OK\n"));
1.1272 +
1.1273 + TheTest.Next(_L("Delete Event"));
1.1274 + TestDeleteEventL(*client);
1.1275 + theLog.Write(_L8("Test 9 OK\n"));
1.1276 +
1.1277 + TheTest.Next(_L("Get Config"));
1.1278 + TestGetConfigL(*client);
1.1279 + theLog.Write(_L8("Test 10 OK\n"));
1.1280 +
1.1281 + TheTest.Next(_L("Change Config"));
1.1282 + TestChangeConfigL(*client);
1.1283 + theLog.Write(_L8("Test 11 OK\n"));
1.1284 +
1.1285 + TheTest.Next(_L("Get String"));
1.1286 + TestGetStringL(*client);
1.1287 + theLog.Write(_L8("Test 12 OK\n"));
1.1288 +
1.1289 + TheTest.Next(_L("Clear Event Log"));
1.1290 + TestClearEventLogL(*client);
1.1291 + theLog.Write(_L8("Test 13 OK\n"));
1.1292 +
1.1293 +#ifdef SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM
1.1294 + TheTest.Next(_L("Clear Event Log + SimId"));
1.1295 + TestClearEventLogL(*client, ETrue);
1.1296 + theLog.Write(_L8("Test 14 OK\n"));
1.1297 +#endif
1.1298 +
1.1299 + CleanupStack::PopAndDestroy(); // client
1.1300 + }