1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/persistentdata/loggingservices/eventlogger/test/src/t_logpurge.cpp Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,1307 @@
1.4 +// Copyright (c) 2003-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 +#include <logview.h>
1.22 +
1.23 +RTest TheTest(_L("t_logpurge"));
1.24 +
1.25 +const TInt KTestEventNum = 10;
1.26 +const TInt KTestEventAge = 5;
1.27 +const TInt KTestRecentNum = 10;
1.28 +const TInt KTestDuplicateNum = 10;
1.29 +
1.30 +_LIT(KTestRemoteParty, "Test Remote Party %d");
1.31 +
1.32 +/**
1.33 +@SYMTestCaseID SYSLIB-LOGENG-CT-0875
1.34 +@SYMTestCaseDesc Tests for maximum logging of configuration data
1.35 +@SYMTestPriority High
1.36 +@SYMTestActions Get the event type configuration data.Set the log size to maximum.
1.37 + Change the log engine configuration data with the new one.Add events to the log
1.38 + Set the filter on the view and check for KErrNone flag.
1.39 + Add a new event and disable logging by setting the maximum logging size to zero
1.40 + Clear all the events and test for KErrNone and the total count of events.
1.41 +@SYMTestExpectedResults Test must not fail
1.42 +@SYMREQ REQ0000
1.43 +*/
1.44 +LOCAL_C void TestMaxLogSizeL(CLogClient& aClient)
1.45 + {
1.46 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0875 "));
1.47 + CLogEvent* event = CLogEvent::NewL();
1.48 + CleanupStack::PushL(event);
1.49 + event->SetEventType(KLogCallEventTypeUid);
1.50 +
1.51 + CTestActive* active = new(ELeave)CTestActive();
1.52 + CleanupStack::PushL(active);
1.53 +
1.54 + CLogViewEvent* view = CLogViewEvent::NewL(aClient);
1.55 + CleanupStack::PushL(view);
1.56 +
1.57 + CLogFilter* filter = CLogFilter::NewL();
1.58 + CleanupStack::PushL(filter);
1.59 +
1.60 + TLogConfig config;
1.61 +
1.62 + // Get log configuration
1.63 + active->StartL();
1.64 + aClient.GetConfig(config, active->iStatus);
1.65 + CActiveScheduler::Start();
1.66 + TEST2(active->iStatus.Int(), KErrNone);
1.67 +
1.68 + // Set the maximum log size
1.69 + config.iMaxLogSize = KTestEventNum;
1.70 +
1.71 + // Change the log engine config
1.72 + active->StartL();
1.73 + aClient.ChangeConfig(config, active->iStatus);
1.74 + CActiveScheduler::Start();
1.75 + TEST2(active->iStatus.Int(), KErrNone);
1.76 +
1.77 + // Initialise the view - There should be no events
1.78 + TEST(!view->SetFilterL(*filter, active->iStatus));
1.79 +
1.80 + // Add the number of allowed events
1.81 + TInt count;
1.82 + for(count = 0; count < KTestEventNum; count++)
1.83 + {
1.84 + active->StartL();
1.85 + aClient.AddEvent(*event, active->iStatus);
1.86 + CActiveScheduler::Start();
1.87 + TEST2(active->iStatus.Int(), KErrNone);
1.88 + }
1.89 +
1.90 + TEST(view->SetFilterL(*filter, active->iStatus));
1.91 + active->StartL();
1.92 + CActiveScheduler::Start();
1.93 + TEST2(active->iStatus.Int(), KErrNone);
1.94 +
1.95 + // The view should now have the correct number of events
1.96 + TEST(view->CountL() == KTestEventNum);
1.97 +
1.98 + // Add the same number of events again - the old ones should be deleted
1.99 + for(count = 0; count < KTestEventNum; count++)
1.100 + {
1.101 + TEST(view->SetFilterL(*filter, active->iStatus));
1.102 + active->StartL();
1.103 + CActiveScheduler::Start();
1.104 + TEST2(active->iStatus.Int(), KErrNone);
1.105 +
1.106 + // Get the last (oldest) event
1.107 + active->StartL();
1.108 + view->LastL(active->iStatus);
1.109 + CActiveScheduler::Start();
1.110 + TEST2(active->iStatus.Int(), KErrNone);
1.111 +
1.112 + // Remember the Id
1.113 + TLogId id = view->Event().Id();
1.114 +
1.115 + // Add another event - the oldest should be removed
1.116 + active->StartL();
1.117 + aClient.AddEvent(*event, active->iStatus);
1.118 + CActiveScheduler::Start();
1.119 + TEST2(active->iStatus.Int(), KErrNone);
1.120 +
1.121 + // There should be the same number of events in view
1.122 + TEST(view->CountL() == KTestEventNum);
1.123 +
1.124 + event->SetId(id);
1.125 +
1.126 + // Try and get the old event
1.127 + active->StartL();
1.128 + aClient.GetEvent(*event, active->iStatus);
1.129 + CActiveScheduler::Start();
1.130 + TEST2(active->iStatus.Int(), KErrNotFound);
1.131 + }
1.132 +
1.133 + // Add an event
1.134 + active->StartL();
1.135 + aClient.AddEvent(*event, active->iStatus);
1.136 + CActiveScheduler::Start();
1.137 + TEST2(active->iStatus.Int(), KErrNone);
1.138 +
1.139 + // Check it's there
1.140 + active->StartL();
1.141 + aClient.GetEvent(*event, active->iStatus);
1.142 + CActiveScheduler::Start();
1.143 + TEST2(active->iStatus.Int(), KErrNone);
1.144 +
1.145 + // Set the maximum log size to zero, i.e. disable logging
1.146 + config.iMaxLogSize = 0;
1.147 +
1.148 + // Change the log engine config
1.149 + active->StartL();
1.150 + aClient.ChangeConfig(config, active->iStatus);
1.151 + CActiveScheduler::Start();
1.152 + TEST2(active->iStatus.Int(), KErrNone);
1.153 +
1.154 + // Check the event has gone
1.155 + active->StartL();
1.156 + aClient.GetEvent(*event, active->iStatus);
1.157 + CActiveScheduler::Start();
1.158 + TEST2(active->iStatus.Int(), KErrNotFound);;
1.159 +
1.160 + // Add an event
1.161 + active->StartL();
1.162 + aClient.AddEvent(*event, active->iStatus);
1.163 + CActiveScheduler::Start();
1.164 + TEST2(active->iStatus.Int(), KErrNotSupported);
1.165 +
1.166 + // Check that event doesn't exist
1.167 + active->StartL();
1.168 + aClient.GetEvent(*event, active->iStatus);
1.169 + CActiveScheduler::Start();
1.170 + TEST2(active->iStatus.Int(), KErrNotFound);;
1.171 +
1.172 + User::After(1000000);
1.173 +
1.174 + TTime now;
1.175 + now.UniversalTime();
1.176 + now+=(TTimeIntervalDays) 1;
1.177 + // Clear all the events
1.178 + active->StartL();
1.179 + aClient.ClearLog(now, active->iStatus);
1.180 + CActiveScheduler::Start();
1.181 + TEST2(active->iStatus.Int(), KErrNone);
1.182 +
1.183 + TEST(!view->SetFilterL(*filter, active->iStatus));
1.184 + TEST(view->CountL() == 0);
1.185 +
1.186 + CleanupStack::PopAndDestroy(4); // filter, view, active, event
1.187 + }
1.188 +
1.189 +/**
1.190 +@SYMTestCaseID SYSLIB-LOGENG-CT-0876
1.191 +@SYMTestCaseDesc Tests for maximum logging of configuration data
1.192 +@SYMTestPriority High
1.193 +@SYMTestActions Get the event type configuration data.Set the log size to maximum.
1.194 + Change the log engine configuration data and add the number of allowed events
1.195 + Reduce the number of allowed events.The old ones should be purged
1.196 + Change the log engine config and check for the event count.
1.197 +@SYMTestExpectedResults Test must not fail
1.198 +@SYMREQ REQ0000
1.199 +*/
1.200 +LOCAL_C void TestMaxLogSizeConfigL(CLogClient& aClient)
1.201 + {
1.202 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0876 "));
1.203 + CLogEvent* event = CLogEvent::NewL();
1.204 + CleanupStack::PushL(event);
1.205 + event->SetEventType(KLogCallEventTypeUid);
1.206 +
1.207 + CTestActive* active = new(ELeave)CTestActive();
1.208 + CleanupStack::PushL(active);
1.209 +
1.210 + CLogViewEvent* view = CLogViewEvent::NewL(aClient);
1.211 + CleanupStack::PushL(view);
1.212 +
1.213 + CLogFilter* filter = CLogFilter::NewL();
1.214 + CleanupStack::PushL(filter);
1.215 +
1.216 + TLogConfig config;
1.217 +
1.218 + // Get log configuration
1.219 + active->StartL();
1.220 + aClient.GetConfig(config, active->iStatus);
1.221 + CActiveScheduler::Start();
1.222 + TEST2(active->iStatus.Int(), KErrNone);
1.223 +
1.224 + // Set the maximum log size
1.225 + config.iMaxLogSize = KTestEventNum;
1.226 +
1.227 + // Change the log engine config
1.228 + active->StartL();
1.229 + aClient.ChangeConfig(config, active->iStatus);
1.230 + CActiveScheduler::Start();
1.231 + TEST2(active->iStatus.Int(), KErrNone);
1.232 +
1.233 + // Initialise the view - There should be no events
1.234 + TEST(!view->SetFilterL(*filter, active->iStatus));
1.235 +
1.236 + // Add the number of allowed events
1.237 + TInt count;
1.238 + for(count = 0; count < KTestEventNum; count++)
1.239 + {
1.240 + active->StartL();
1.241 + aClient.AddEvent(*event, active->iStatus);
1.242 + CActiveScheduler::Start();
1.243 + TEST2(active->iStatus.Int(), KErrNone);
1.244 + }
1.245 +
1.246 + TEST(view->SetFilterL(*filter, active->iStatus));
1.247 + active->StartL();
1.248 + CActiveScheduler::Start();
1.249 + TEST2(active->iStatus.Int(), KErrNone);
1.250 +
1.251 + // The view should now have the correct number of events
1.252 + TEST(view->CountL() == KTestEventNum);
1.253 +
1.254 + // Reduce the number of allowed events
1.255 + // The old ones should be purged
1.256 + config.iMaxLogSize = KTestEventNum / 2;
1.257 +
1.258 + // Change the log engine config
1.259 + active->StartL();
1.260 + aClient.ChangeConfig(config, active->iStatus);
1.261 + CActiveScheduler::Start();
1.262 + TEST2(active->iStatus.Int(), KErrNone);
1.263 +
1.264 + // Check the event count
1.265 + TEST(view->SetFilterL(*filter, active->iStatus));
1.266 + active->StartL();
1.267 + CActiveScheduler::Start();
1.268 + TEST2(active->iStatus.Int(), KErrNone);
1.269 + TEST(view->CountL() == KTestEventNum / 2);
1.270 +
1.271 + User::After(0x1000000);
1.272 +
1.273 + TTime now;
1.274 + now.UniversalTime();
1.275 + now+=(TTimeIntervalDays )1;
1.276 + // Clear all the events
1.277 + active->StartL();
1.278 + aClient.ClearLog(now, active->iStatus);
1.279 + CActiveScheduler::Start();
1.280 + TEST2(active->iStatus.Int(), KErrNone);
1.281 +
1.282 + TEST(!view->SetFilterL(*filter, active->iStatus));
1.283 + TEST(view->CountL() == 0);
1.284 +
1.285 + CleanupStack::PopAndDestroy(4); // filter, view, active, event
1.286 + }
1.287 +
1.288 +/**
1.289 +@SYMTestCaseID SYSLIB-LOGENG-CT-0877
1.290 +@SYMTestCaseDesc Tests for maximum time for which events can be retained in the log
1.291 +@SYMTestPriority High
1.292 +@SYMTestActions Get the event type configuration data.Set maximum log age.
1.293 + Change the log engine configuration data with the new one.Add events to the log
1.294 + Set the date and time of events clear the log and check for errors
1.295 +@SYMTestExpectedResults Test must not fail
1.296 +@SYMREQ REQ0000
1.297 +*/
1.298 +LOCAL_C void TestMaxLogAgeL(CLogClient& aClient, TLogAge aMaxLogAge)
1.299 + {
1.300 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0877 "));
1.301 + CLogEvent* event = CLogEvent::NewL();
1.302 + CleanupStack::PushL(event);
1.303 + event->SetEventType(KLogCallEventTypeUid);
1.304 +
1.305 + CTestActive* active = new(ELeave)CTestActive();
1.306 + CleanupStack::PushL(active);
1.307 +
1.308 + CLogViewEvent* view = CLogViewEvent::NewL(aClient);
1.309 + CleanupStack::PushL(view);
1.310 +
1.311 + CLogFilter* filter = CLogFilter::NewL();
1.312 + CleanupStack::PushL(filter);
1.313 +
1.314 + TLogConfig config;
1.315 +
1.316 + // Get log configuration
1.317 + active->StartL();
1.318 + aClient.GetConfig(config, active->iStatus);
1.319 + CActiveScheduler::Start();
1.320 + TEST2(active->iStatus.Int(), KErrNone);
1.321 +
1.322 + // Set the maximum log age
1.323 + config.iMaxLogSize = KTestEventAge * 2;
1.324 + config.iMaxEventAge = aMaxLogAge;
1.325 +
1.326 + // Change the log engine config
1.327 + active->StartL();
1.328 + aClient.ChangeConfig(config, active->iStatus);
1.329 + CActiveScheduler::Start();
1.330 + TEST2(active->iStatus.Int(), KErrNone);
1.331 +
1.332 + // Initialise the view - There should be no events
1.333 + TEST(!view->SetFilterL(*filter, active->iStatus));
1.334 +
1.335 + TTime date;
1.336 + date.UniversalTime();
1.337 +
1.338 + // Wait a second
1.339 + User::After(0x1000000);
1.340 +
1.341 + // Add events
1.342 + TInt count;
1.343 + for(count = 0; count < KTestEventAge * 2; count++)
1.344 + {
1.345 + active->StartL();
1.346 + aClient.AddEvent(*event, active->iStatus);
1.347 + CActiveScheduler::Start();
1.348 + TEST2(active->iStatus.Int(), KErrNone);
1.349 +
1.350 + // Set the time and date of the event
1.351 + event->SetTime(date);
1.352 + date -= TTimeIntervalDays(1);
1.353 +
1.354 + active->StartL();
1.355 + aClient.ChangeEvent(*event, active->iStatus);
1.356 + CActiveScheduler::Start();
1.357 + TEST2(active->iStatus.Int(), KErrNone);
1.358 + User::After(1000000);
1.359 +
1.360 + TEST(view->SetFilterL(*filter, active->iStatus));
1.361 + active->StartL();
1.362 + CActiveScheduler::Start();
1.363 + TEST2(active->iStatus.Int(), KErrNone);
1.364 +
1.365 + // Check the old events have been removed
1.366 + if ((count < KTestEventAge) || !aMaxLogAge)
1.367 + TEST(view->CountL() == count + 1);
1.368 + else
1.369 + TEST(view->CountL() == KTestEventAge);
1.370 + }
1.371 +
1.372 + User::After(0x1000000);
1.373 + date.UniversalTime();
1.374 +
1.375 + date+=(TTimeIntervalYears )1;
1.376 +
1.377 + // Clear all the events
1.378 + active->StartL();
1.379 + aClient.ClearLog(date, active->iStatus);
1.380 + CActiveScheduler::Start();
1.381 + TEST2(active->iStatus.Int(), KErrNone);
1.382 +
1.383 + TEST(!view->SetFilterL(*filter, active->iStatus));
1.384 + TEST(view->CountL() == 0);
1.385 +
1.386 + CleanupStack::PopAndDestroy(4); // filter, view, active, event
1.387 + }
1.388 +
1.389 +/**
1.390 +@SYMTestCaseID SYSLIB-LOGENG-CT-0878
1.391 +@SYMTestCaseDesc Tests for maximum number of events that a recent event list holds
1.392 +@SYMTestPriority High
1.393 +@SYMTestActions Set the event configuration data of recent log size(10) to maximum and
1.394 + Add events to the log.Set the filter on the view and check for NO error.
1.395 + Add a new event and disable logging by setting the maximum logging size to zero
1.396 + Clear all the events and test for no errors and the total count of events and the logviewrecent should be zero.
1.397 +@SYMTestExpectedResults Test must not fail
1.398 +@SYMREQ REQ0000
1.399 +*/
1.400 +LOCAL_C void TestMaxRecentSize1L(CLogClient& aClient)
1.401 + {
1.402 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0878 "));
1.403 + CLogEvent* event = CLogEvent::NewL();
1.404 + CleanupStack::PushL(event);
1.405 +
1.406 + // Incoming
1.407 + TBuf<KLogMaxDirectionLength> buf;
1.408 + aClient.GetString(buf, R_LOG_DIR_IN);
1.409 +
1.410 + event->SetEventType(KLogCallEventTypeUid);
1.411 + event->SetDirection(buf);
1.412 +
1.413 + CTestActive* active = new(ELeave)CTestActive();
1.414 + CleanupStack::PushL(active);
1.415 +
1.416 + CLogViewEvent* view = CLogViewEvent::NewL(aClient);
1.417 + CleanupStack::PushL(view);
1.418 +
1.419 + CLogViewRecent* recent = CLogViewRecent::NewL(aClient);
1.420 + CleanupStack::PushL(recent);
1.421 +
1.422 + CLogFilter* filter = CLogFilter::NewL();
1.423 + CleanupStack::PushL(filter);
1.424 +
1.425 + TLogConfig config;
1.426 +
1.427 + // Get log configuration
1.428 + active->StartL();
1.429 + aClient.GetConfig(config, active->iStatus);
1.430 + CActiveScheduler::Start();
1.431 + TEST2(active->iStatus.Int(), KErrNone);
1.432 +
1.433 + // Set the maximum log size
1.434 + config.iMaxLogSize = KTestRecentNum * 2;
1.435 + config.iMaxRecentLogSize = KTestRecentNum;
1.436 +
1.437 + // Change the log engine config
1.438 + active->StartL();
1.439 + aClient.ChangeConfig(config, active->iStatus);
1.440 + CActiveScheduler::Start();
1.441 + TEST2(active->iStatus.Int(), KErrNone);
1.442 +
1.443 + // Initialise the views - There should be no events
1.444 + TEST(!view->SetFilterL(*filter, active->iStatus));
1.445 + TEST(!recent->SetRecentListL(KLogRecentIncomingCalls, active->iStatus));
1.446 +
1.447 + // Add a number of events
1.448 + TInt count;
1.449 + for(count = 0; count < KTestRecentNum; count++)
1.450 + {
1.451 + event->SetContact(count);
1.452 +
1.453 + active->StartL();
1.454 + aClient.AddEvent(*event, active->iStatus);
1.455 + CActiveScheduler::Start();
1.456 + TEST2(active->iStatus.Int(), KErrNone);
1.457 + }
1.458 +
1.459 + TEST(recent->SetRecentListL(KLogRecentIncomingCalls, active->iStatus));
1.460 + active->StartL();
1.461 + CActiveScheduler::Start();
1.462 + TEST2(active->iStatus.Int(), KErrNone);
1.463 +
1.464 + TEST(recent->CountL() == KTestRecentNum);
1.465 +
1.466 + // Add the same number of events again - the old ones should be removed
1.467 + for(count = 0; count < KTestRecentNum; count++)
1.468 + {
1.469 + // Add another event - the oldest should be removed from recent list
1.470 + active->StartL();
1.471 + aClient.AddEvent(*event, active->iStatus);
1.472 + CActiveScheduler::Start();
1.473 + TEST2(active->iStatus.Int(), KErrNone);
1.474 +
1.475 + TEST(view->SetFilterL(*filter, active->iStatus));
1.476 + active->StartL();
1.477 + CActiveScheduler::Start();
1.478 + TEST2(active->iStatus.Int(), KErrNone);
1.479 +
1.480 + TEST(recent->SetRecentListL(KLogRecentIncomingCalls, active->iStatus));
1.481 + active->StartL();
1.482 + CActiveScheduler::Start();
1.483 + TEST2(active->iStatus.Int(), KErrNone);
1.484 +
1.485 + // Check an event has been removed from recent view
1.486 + TEST(recent->CountL() == KTestRecentNum);
1.487 + TEST(view->CountL() == count + KTestRecentNum + 1);
1.488 + }
1.489 +
1.490 + User::After(0x1000000);
1.491 +
1.492 + TTime now;
1.493 + now.UniversalTime();
1.494 + now+=(TTimeIntervalDays )1;
1.495 +
1.496 + // Clear all the events
1.497 + active->StartL();
1.498 + aClient.ClearLog(now, active->iStatus);
1.499 + CActiveScheduler::Start();
1.500 + TEST2(active->iStatus.Int(), KErrNone);
1.501 +
1.502 + TEST(!view->SetFilterL(*filter, active->iStatus));
1.503 + TEST(!recent->SetRecentListL(KLogRecentIncomingCalls, active->iStatus));
1.504 + TEST(view->CountL() == 0 && recent->CountL() == 0);
1.505 +
1.506 + CleanupStack::PopAndDestroy(5); // filter, recent, view, active, event
1.507 + }
1.508 +
1.509 +/**
1.510 +@SYMTestCaseID SYSLIB-LOGENG-CT-0879
1.511 +@SYMTestCaseDesc Tests for maximum number of events that a recent event list holds
1.512 +@SYMTestPriority High
1.513 +@SYMTestActions Set the event configuration data of recent log size(10) to maximum and
1.514 + Add events to the log.Set the filter on the view and check for NO error.
1.515 + Reduce the recent log size(5) and set the new configuration.
1.516 + Clear all the events and test for no errors and the total count of events and the logviewrecent should be zero.
1.517 + Tests for CLogViewRecent::SetRecentListL
1.518 +@SYMTestExpectedResults Test must not fail
1.519 +@SYMREQ REQ0000
1.520 +*/
1.521 +LOCAL_C void TestMaxRecentSizeConfigL(CLogClient& aClient)
1.522 + {
1.523 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0879 "));
1.524 + CLogEvent* event = CLogEvent::NewL();
1.525 + CleanupStack::PushL(event);
1.526 +
1.527 + // Incoming
1.528 + TBuf<KLogMaxDirectionLength> buf;
1.529 + aClient.GetString(buf, R_LOG_DIR_IN);
1.530 +
1.531 + event->SetEventType(KLogCallEventTypeUid);
1.532 + event->SetDirection(buf);
1.533 +
1.534 + CTestActive* active = new(ELeave)CTestActive();
1.535 + CleanupStack::PushL(active);
1.536 +
1.537 + CLogViewRecent* recent = CLogViewRecent::NewL(aClient);
1.538 + CleanupStack::PushL(recent);
1.539 +
1.540 + TLogConfig config;
1.541 +
1.542 + // Get log configuration
1.543 + active->StartL();
1.544 + aClient.GetConfig(config, active->iStatus);
1.545 + CActiveScheduler::Start();
1.546 + TEST2(active->iStatus.Int(), KErrNone);
1.547 +
1.548 + // Set the maximum log size
1.549 + config.iMaxLogSize = KTestRecentNum * 2;
1.550 + config.iMaxRecentLogSize = KTestRecentNum;
1.551 +
1.552 + // Change the log engine config
1.553 + active->StartL();
1.554 + aClient.ChangeConfig(config, active->iStatus);
1.555 + CActiveScheduler::Start();
1.556 + TEST2(active->iStatus.Int(), KErrNone);
1.557 +
1.558 + // Initialise the views - There should be no events
1.559 + TEST(!recent->SetRecentListL(KLogRecentIncomingCalls, active->iStatus));
1.560 +
1.561 + // Add a number of events
1.562 + TInt count;
1.563 + for(count = 0; count < KTestRecentNum; count++)
1.564 + {
1.565 + event->SetContact(count);
1.566 +
1.567 + active->StartL();
1.568 + aClient.AddEvent(*event, active->iStatus);
1.569 + CActiveScheduler::Start();
1.570 + TEST2(active->iStatus.Int(), KErrNone);
1.571 + }
1.572 +
1.573 + TEST(recent->SetRecentListL(KLogRecentIncomingCalls, active->iStatus));
1.574 + active->StartL();
1.575 + CActiveScheduler::Start();
1.576 + TEST2(active->iStatus.Int(), KErrNone);
1.577 +
1.578 + TEST(recent->CountL() == KTestRecentNum);
1.579 +
1.580 + // Reduce the maximum allowed recent list size
1.581 + // The oldest ones should be removed
1.582 + config.iMaxRecentLogSize = KTestRecentNum / 2;
1.583 +
1.584 + active->StartL();
1.585 + aClient.ChangeConfig(config, active->iStatus);
1.586 + CActiveScheduler::Start();
1.587 + TEST2(active->iStatus.Int(), KErrNone);
1.588 +
1.589 + TEST(recent->SetRecentListL(KLogRecentIncomingCalls, active->iStatus));
1.590 + active->StartL();
1.591 + CActiveScheduler::Start();
1.592 + TEST2(active->iStatus.Int(), KErrNone);
1.593 +
1.594 + TEST(recent->CountL() == KTestRecentNum / 2);
1.595 + User::After(0x1000000);
1.596 +
1.597 + TTime now;
1.598 + now.UniversalTime();
1.599 + now+=(TTimeIntervalDays )1;
1.600 +
1.601 + // Clear all the events
1.602 + active->StartL();
1.603 + aClient.ClearLog(now, active->iStatus);
1.604 + CActiveScheduler::Start();
1.605 + TEST2(active->iStatus.Int(), KErrNone);
1.606 +
1.607 + TEST(!recent->SetRecentListL(KLogRecentIncomingCalls, active->iStatus));
1.608 + TEST(recent->CountL() == 0);
1.609 +
1.610 + CleanupStack::PopAndDestroy(3); // recent, active, event
1.611 + }
1.612 +
1.613 +/**
1.614 +@SYMTestCaseID SYSLIB-LOGENG-CT-0880
1.615 +@SYMTestCaseDesc Tests for CLogViewRecent::SetRecentListL(),CLogViewRecent::DuplicatesL() functions
1.616 +@SYMTestPriority High
1.617 +@SYMTestActions Set the event configuration data of recent log size(10) to maximum and
1.618 + Add events to the log.Set the filter on the view and check for NO error.
1.619 + Reduce the recent log size(5) and set the new configuration.
1.620 + Clear all the events and test for no errors and the total count of events and the logviewrecent should be zero.
1.621 + Tests for CLogViewRecent::SetRecentListL()
1.622 +@SYMTestExpectedResults Test must not fail
1.623 +@SYMREQ REQ0000
1.624 +*/
1.625 +LOCAL_C void TestMaxRecentSize2L(CLogClient& aClient)
1.626 + {
1.627 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0880 "));
1.628 + CLogEvent* event = CLogEvent::NewL();
1.629 + CleanupStack::PushL(event);
1.630 +
1.631 + // Incoming
1.632 + TBuf<KLogMaxDirectionLength> buf;
1.633 + aClient.GetString(buf, R_LOG_DIR_IN);
1.634 +
1.635 + event->SetEventType(KLogCallEventTypeUid);
1.636 + event->SetDirection(buf);
1.637 +
1.638 + CTestActive* active = new(ELeave)CTestActive();
1.639 + CleanupStack::PushL(active);
1.640 +
1.641 + CLogViewRecent* recent = CLogViewRecent::NewL(aClient);
1.642 + CleanupStack::PushL(recent);
1.643 +
1.644 + CLogViewDuplicate* dup = CLogViewDuplicate::NewL(aClient);
1.645 + CleanupStack::PushL(dup);
1.646 +
1.647 + CLogFilter* filter = CLogFilter::NewL();
1.648 + CleanupStack::PushL(filter);
1.649 +
1.650 + TLogConfig config;
1.651 +
1.652 + // Get log configuration
1.653 + active->StartL();
1.654 + aClient.GetConfig(config, active->iStatus);
1.655 + CActiveScheduler::Start();
1.656 + TEST2(active->iStatus.Int(), KErrNone);
1.657 +
1.658 + // Set the maximum log size
1.659 + config.iMaxLogSize = (KTestRecentNum * KTestDuplicateNum) * 2;
1.660 + config.iMaxRecentLogSize = KTestRecentNum;
1.661 +
1.662 + // Change the log engine config
1.663 + active->StartL();
1.664 + aClient.ChangeConfig(config, active->iStatus);
1.665 + CActiveScheduler::Start();
1.666 + TEST2(active->iStatus.Int(), KErrNone);
1.667 +
1.668 + // Initialise the view - There should be no events
1.669 + TEST(!recent->SetRecentListL(KLogRecentIncomingCalls, active->iStatus));
1.670 +
1.671 + // Add a number of events
1.672 + TInt count;
1.673 + for(count = 0; count < KTestRecentNum; count++)
1.674 + {
1.675 + TBuf<KLogMaxRemotePartyLength> buf;
1.676 + buf.Format(KTestRemoteParty, count);
1.677 + event->SetRemoteParty(buf);
1.678 +
1.679 + active->StartL();
1.680 + aClient.AddEvent(*event, active->iStatus);
1.681 + CActiveScheduler::Start();
1.682 + TEST2(active->iStatus.Int(), KErrNone);
1.683 +
1.684 + // Add some duplicates
1.685 + TInt duplicate;
1.686 + for(duplicate = 0; duplicate < KTestDuplicateNum; duplicate++)
1.687 + {
1.688 + active->StartL();
1.689 + aClient.AddEvent(*event, active->iStatus);
1.690 + CActiveScheduler::Start();
1.691 + TEST2(active->iStatus.Int(), KErrNone);
1.692 + }
1.693 +
1.694 + // The views should now have the correct number of events
1.695 + TEST(recent->SetRecentListL(KLogRecentIncomingCalls, active->iStatus));
1.696 + active->StartL();
1.697 + CActiveScheduler::Start();
1.698 + TEST2(active->iStatus.Int(), KErrNone);
1.699 +
1.700 + TEST(recent->CountL() == count + 1);
1.701 +
1.702 + TEST(recent->DuplicatesL(*dup, active->iStatus));
1.703 + active->StartL();
1.704 + CActiveScheduler::Start();
1.705 + TEST2(active->iStatus.Int(), KErrNone);
1.706 +
1.707 + TEST(dup->CountL() == KTestDuplicateNum);
1.708 + }
1.709 +
1.710 + event->SetRemoteParty(KNullDesC);
1.711 +
1.712 + // Add the more events - the old ones should be removed
1.713 + for(count = 0; count < KTestRecentNum; count++)
1.714 + {
1.715 + // Add another event - the oldest should be removed from recent list
1.716 + active->StartL();
1.717 + aClient.AddEvent(*event, active->iStatus);
1.718 + CActiveScheduler::Start();
1.719 + TEST2(active->iStatus.Int(), KErrNone);
1.720 +
1.721 + TEST(recent->SetRecentListL(KLogRecentIncomingCalls, active->iStatus));
1.722 + active->StartL();
1.723 + CActiveScheduler::Start();
1.724 + TEST2(active->iStatus.Int(), KErrNone);
1.725 +
1.726 + // Check an event has been removed from recent view
1.727 + TEST(recent->CountL() == KTestRecentNum);
1.728 + }
1.729 +
1.730 + User::After(0x1000000);
1.731 +
1.732 + TTime now;
1.733 + now.UniversalTime();
1.734 + now+=(TTimeIntervalDays )1;
1.735 +
1.736 + // Clear all the events
1.737 + active->StartL();
1.738 + aClient.ClearLog(now, active->iStatus);
1.739 + CActiveScheduler::Start();
1.740 + TEST2(active->iStatus.Int(), KErrNone);
1.741 +
1.742 + TEST(!recent->DuplicatesL(*dup, active->iStatus));
1.743 +
1.744 + CleanupStack::PopAndDestroy(5); // filter, dup, recent, active, event
1.745 + }
1.746 +
1.747 +/**
1.748 +@SYMTestCaseID SYSLIB-LOGENG-CT-0881
1.749 +@SYMTestCaseDesc Tests for purge
1.750 +@SYMTestPriority High
1.751 +@SYMTestActions Get the event type data
1.752 +@SYMTestExpectedResults Test must not fail
1.753 +@SYMREQ REQ0000
1.754 +*/
1.755 +LOCAL_C void TestNoPurgeWithGetL(CLogClient& aClient)
1.756 + {
1.757 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0881 "));
1.758 + CLogEvent* event = CLogEvent::NewL();
1.759 + CleanupStack::PushL(event);
1.760 + event->SetEventType(KLogCallEventTypeUid);
1.761 +
1.762 + CTestActive* active = new(ELeave)CTestActive();
1.763 + CleanupStack::PushL(active);
1.764 +
1.765 + TLogConfig config;
1.766 +
1.767 + // Get log configuration
1.768 + active->StartL();
1.769 + aClient.GetConfig(config, active->iStatus);
1.770 + CActiveScheduler::Start();
1.771 + TEST2(active->iStatus.Int(), KErrNone);
1.772 +
1.773 + // Set the maximum log age
1.774 + TInt oldAge = config.iMaxEventAge;
1.775 + config.iMaxEventAge = 24 * 60 * 60;
1.776 +
1.777 + // Change the log engine config
1.778 + active->StartL();
1.779 + aClient.ChangeConfig(config, active->iStatus);
1.780 + CActiveScheduler::Start();
1.781 + TEST2(active->iStatus.Int(), KErrNone);
1.782 +
1.783 + active->StartL();
1.784 + aClient.AddEvent(*event, active->iStatus);
1.785 + CActiveScheduler::Start();
1.786 + TEST2(active->iStatus.Int(), KErrNone);
1.787 +
1.788 + // Check that the event can be retrieved
1.789 + active->StartL();
1.790 + aClient.GetEvent(*event, active->iStatus);
1.791 + CActiveScheduler::Start();
1.792 + TEST2(active->iStatus.Int(), KErrNone);
1.793 +
1.794 + // Wait for 15 seconds (just to be safe)
1.795 + User::After(15000000);
1.796 +
1.797 + // Check that the event can still be retrieved
1.798 + active->StartL();
1.799 + aClient.GetEvent(*event, active->iStatus);
1.800 + CActiveScheduler::Start();
1.801 + TEST2(active->iStatus.Int(), KErrNone);
1.802 +
1.803 + // Perform a dummy change
1.804 + event->SetTime(event->Time() - TTimeIntervalDays(2));
1.805 + active->StartL();
1.806 + aClient.ChangeEvent(*event, active->iStatus);
1.807 + CActiveScheduler::Start();
1.808 + TEST2(active->iStatus.Int(), KErrNone);
1.809 +
1.810 + // Check the event has been removed
1.811 + active->StartL();
1.812 + aClient.GetEvent(*event, active->iStatus);
1.813 + CActiveScheduler::Start();
1.814 + TEST2(active->iStatus.Int(), KErrNotFound);;
1.815 +
1.816 + // Reset the config
1.817 + config.iMaxEventAge = oldAge;
1.818 +
1.819 + // Change the log engine config
1.820 + active->StartL();
1.821 + aClient.ChangeConfig(config, active->iStatus);
1.822 + CActiveScheduler::Start();
1.823 + TEST2(active->iStatus.Int(), KErrNone);
1.824 +
1.825 + CleanupStack::PopAndDestroy(2); // active, event
1.826 + }
1.827 +
1.828 +/**
1.829 +@SYMTestCaseID SYSLIB-LOGENG-CT-0882
1.830 +@SYMTestCaseDesc Tests for CLogClient::ClearLog() function
1.831 +@SYMTestPriority High
1.832 +@SYMTestActions Change locale settings and log duration to 1 day and test for number of event types in log
1.833 +@SYMTestExpectedResults Test must not fail
1.834 +@SYMREQ REQ0000
1.835 +*/
1.836 +LOCAL_C void TestClearLog1L(CLogClient& aClient)
1.837 + {
1.838 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0882 "));
1.839 + CLogEvent* event = CLogEvent::NewL();
1.840 + CleanupStack::PushL(event);
1.841 + event->SetEventType(KLogCallEventTypeUid);
1.842 +
1.843 + CTestActive* active = new(ELeave)CTestActive();
1.844 + CleanupStack::PushL(active);
1.845 +
1.846 + CLogViewEvent* view = CLogViewEvent::NewL(aClient);
1.847 + CleanupStack::PushL(view);
1.848 +
1.849 + // change Locale
1.850 + TLocale locale;
1.851 + locale.SetCountryCode(47);//Norway
1.852 + locale.SetDateFormat(EDateEuropean);
1.853 + locale.SetTimeFormat(ETime12);
1.854 + for (int i=0; i<4; i++)
1.855 + {
1.856 + locale.SetTimeSeparator(TChar('.'),i);
1.857 + locale.SetDateSeparator(TChar(':'),i);
1.858 + }
1.859 + locale.Set();
1.860 +
1.861 + // change the log duration settings to 1 day
1.862 + TLogConfig config;
1.863 + active->StartL();
1.864 + aClient.GetConfig(config, active->iStatus);
1.865 + CActiveScheduler::Start();
1.866 + TEST2(active->iStatus.Int(), KErrNone);
1.867 +
1.868 + config.iMaxLogSize = KTestEventAge * 2;
1.869 + config.iMaxEventAge = 86400;
1.870 + active->StartL();
1.871 + aClient.ChangeConfig(config, active->iStatus);
1.872 + CActiveScheduler::Start();
1.873 + TEST2(active->iStatus.Int(), KErrNone);
1.874 +
1.875 + // add a call event
1.876 + active->StartL();
1.877 + aClient.AddEvent(*event, active->iStatus);
1.878 + CActiveScheduler::Start();
1.879 + TEST2(active->iStatus.Int(), KErrNone);
1.880 + User::After(1000000);
1.881 + TTime now;
1.882 + now.HomeTime();
1.883 + event->SetTime(now);
1.884 + active->StartL();
1.885 + aClient.ChangeEvent(*event, active->iStatus);
1.886 + CActiveScheduler::Start();
1.887 + TEST2(active->iStatus.Int(), KErrNone);
1.888 +
1.889 + // forward two days
1.890 + now+=(TTimeIntervalDays )2;
1.891 + User::SetHomeTime(now);
1.892 +
1.893 + // dummy call ensures ClearLog() is called
1.894 + active->StartL();
1.895 + aClient.ChangeConfig(config, active->iStatus);
1.896 + CActiveScheduler::Start();
1.897 + TEST2(active->iStatus.Int(), KErrNone);
1.898 +
1.899 + // try to retrieve event
1.900 + active->StartL();
1.901 + aClient.GetEvent(*event, active->iStatus);
1.902 + CActiveScheduler::Start();
1.903 + TEST2(active->iStatus.Int(), KErrNotFound);;
1.904 +
1.905 + TEST(view->CountL() == 0);
1.906 +
1.907 + CleanupStack::PopAndDestroy(3); // view, active, event
1.908 + }
1.909 +
1.910 +/**
1.911 +@SYMTestCaseID SYSLIB-LOGENG-CT-0883
1.912 +@SYMTestCaseDesc Tests for CLogClient::ClearLog() function
1.913 +@SYMTestPriority High
1.914 +@SYMTestActions Change locale settings,call up ClearLog and try to retrieve event,test for count of number of events in the view.
1.915 +@SYMTestExpectedResults Test must not fail
1.916 +@SYMREQ REQ0000
1.917 +*/
1.918 +LOCAL_C void TestClearLog2L(CLogClient& aClient)
1.919 + {
1.920 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0883 "));
1.921 + CLogEvent* event = CLogEvent::NewL();
1.922 + CleanupStack::PushL(event);
1.923 + event->SetEventType(KLogCallEventTypeUid);
1.924 +
1.925 + CTestActive* active = new(ELeave)CTestActive();
1.926 + CleanupStack::PushL(active);
1.927 +
1.928 + CLogViewEvent* view = CLogViewEvent::NewL(aClient);
1.929 + CleanupStack::PushL(view);
1.930 +
1.931 + // change Locale
1.932 + TLocale locale;
1.933 + locale.SetCountryCode(47);//Norway
1.934 + locale.SetDateFormat(EDateEuropean);
1.935 + locale.SetTimeFormat(ETime12);
1.936 + for (int i=0; i<4; i++)
1.937 + {
1.938 + locale.SetTimeSeparator(TChar('.'),i);
1.939 + locale.SetDateSeparator(TChar(':'),i);
1.940 + }
1.941 + locale.Set();
1.942 +
1.943 + // change the log duration settings to 1 day
1.944 + TLogConfig config;
1.945 + active->StartL();
1.946 + aClient.GetConfig(config, active->iStatus);
1.947 + CActiveScheduler::Start();
1.948 + TEST2(active->iStatus.Int(), KErrNone);
1.949 +
1.950 + config.iMaxLogSize = KTestEventAge * 2;
1.951 + config.iMaxEventAge = 86400;
1.952 + active->StartL();
1.953 + aClient.ChangeConfig(config, active->iStatus);
1.954 + CActiveScheduler::Start();
1.955 + TEST2(active->iStatus.Int(), KErrNone);
1.956 +
1.957 + // add a call event
1.958 + active->StartL();
1.959 + aClient.AddEvent(*event, active->iStatus);
1.960 + CActiveScheduler::Start();
1.961 + TEST2(active->iStatus.Int(), KErrNone);
1.962 + User::After(1000000);
1.963 + TTime now;
1.964 + now.HomeTime();
1.965 + event->SetTime(now);
1.966 + active->StartL();
1.967 + aClient.ChangeEvent(*event, active->iStatus);
1.968 + CActiveScheduler::Start();
1.969 + TEST2(active->iStatus.Int(), KErrNone);
1.970 +
1.971 + // forward two days
1.972 + now+=(TTimeIntervalDays )2;
1.973 + User::SetHomeTime(now);
1.974 +
1.975 + active->StartL();
1.976 + aClient.ClearLog(now, active->iStatus);
1.977 + CActiveScheduler::Start();
1.978 + TEST2(active->iStatus.Int(), KErrNone);
1.979 +
1.980 + // try to retrieve event
1.981 + active->StartL();
1.982 + aClient.GetEvent(*event, active->iStatus);
1.983 + CActiveScheduler::Start();
1.984 + TEST2(active->iStatus.Int(), KErrNotFound);;
1.985 +
1.986 + TEST(view->CountL() == 0);
1.987 +
1.988 + CleanupStack::PopAndDestroy(3); // view, active, event
1.989 + }
1.990 +
1.991 +#ifdef SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM
1.992 +
1.993 +/**
1.994 +@SYMTestCaseID PDS-LOGENG-UT-4036
1.995 +@SYMTestCaseDesc Clear log events with specific SimId test.
1.996 + The test adds 3 events with different SimIds and then checks that
1.997 + CLogEvent::ClearLog() deletes only the event with the specified id.
1.998 +@SYMTestActions Clear log events with specific SimId test.
1.999 +@SYMTestExpectedResults Test must not fail
1.1000 +@SYMTestPriority High
1.1001 +@SYMREQ REQ12748
1.1002 +*/
1.1003 +void ClearLogSimIdL(CLogClient& aClient)
1.1004 + {//This test case is compiled only when SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM macro is defined.
1.1005 + const TSimId KSimId1 = 4100000000U;
1.1006 + const TSimId KSimId2 = 100;
1.1007 + const TSimId KSimId3 = 1678;
1.1008 +
1.1009 + TTime now;
1.1010 + now.UniversalTime();
1.1011 +
1.1012 + TDateTime dt(now.DateTime());
1.1013 + dt.SetHour(dt.Hour() - 1);
1.1014 + TTime date(dt);
1.1015 +
1.1016 + TTime threshold(date);
1.1017 + threshold += TTimeIntervalSeconds(10);
1.1018 +
1.1019 + CTestActive* active = new(ELeave)CTestActive();
1.1020 + CleanupStack::PushL(active);
1.1021 +
1.1022 + //////// Event1 ///////////////////////////
1.1023 + CLogEvent* event1 = CLogEvent::NewL();
1.1024 + CleanupStack::PushL(event1);
1.1025 + event1->SetEventType(KLogCallEventTypeUid);
1.1026 + event1->SetSimId(KSimId1);
1.1027 +
1.1028 + active->StartL();
1.1029 + aClient.AddEvent(*event1, active->iStatus);
1.1030 + CActiveScheduler::Start();
1.1031 + TEST2(active->iStatus.Int(), KErrNone);
1.1032 +
1.1033 + event1->SetTime(date);
1.1034 +
1.1035 + active->StartL();
1.1036 + aClient.ChangeEvent(*event1, active->iStatus);
1.1037 + CActiveScheduler::Start();
1.1038 + TEST2(active->iStatus.Int(), KErrNone);
1.1039 +
1.1040 + //////// Event2 ///////////////////////////
1.1041 + CLogEvent* event2 = CLogEvent::NewL();
1.1042 + CleanupStack::PushL(event2);
1.1043 + event2->SetEventType(KLogCallEventTypeUid);
1.1044 + event2->SetSimId(KSimId2);
1.1045 +
1.1046 + active->StartL();
1.1047 + aClient.AddEvent(*event2, active->iStatus);
1.1048 + CActiveScheduler::Start();
1.1049 + TEST2(active->iStatus.Int(), KErrNone);
1.1050 +
1.1051 + event2->SetTime(date);
1.1052 +
1.1053 + active->StartL();
1.1054 + aClient.ChangeEvent(*event2, active->iStatus);
1.1055 + CActiveScheduler::Start();
1.1056 + TEST2(active->iStatus.Int(), KErrNone);
1.1057 +
1.1058 + //////// Event3 ///////////////////////////
1.1059 + CLogEvent* event3 = CLogEvent::NewL();
1.1060 + CleanupStack::PushL(event3);
1.1061 + event3->SetEventType(KLogCallEventTypeUid);
1.1062 + event3->SetSimId(KSimId3);
1.1063 +
1.1064 + active->StartL();
1.1065 + aClient.AddEvent(*event3, active->iStatus);
1.1066 + CActiveScheduler::Start();
1.1067 + TEST2(active->iStatus.Int(), KErrNone);
1.1068 +
1.1069 + event3->SetTime(date);
1.1070 +
1.1071 + active->StartL();
1.1072 + aClient.ChangeEvent(*event3, active->iStatus);
1.1073 + CActiveScheduler::Start();
1.1074 + TEST2(active->iStatus.Int(), KErrNone);
1.1075 +
1.1076 + //////////////////////////////////////////////////////////////////////////////////////////////////
1.1077 +
1.1078 + //Delete event3 /////////////////////////
1.1079 + aClient.ClearLog(threshold, KSimId3, active->iStatus);
1.1080 + active->StartL();
1.1081 + CActiveScheduler::Start();
1.1082 + TEST2(active->iStatus.Int(), KErrNone);
1.1083 + //Event1 and event2 should be there
1.1084 + active->StartL();
1.1085 + aClient.GetEvent(*event1, active->iStatus);
1.1086 + CActiveScheduler::Start();
1.1087 + TEST2(active->iStatus.Int(), KErrNone);
1.1088 + active->StartL();
1.1089 + aClient.GetEvent(*event2, active->iStatus);
1.1090 + CActiveScheduler::Start();
1.1091 + TEST2(active->iStatus.Int(), KErrNone);
1.1092 + active->StartL();
1.1093 + aClient.GetEvent(*event3, active->iStatus);
1.1094 + CActiveScheduler::Start();
1.1095 + TEST2(active->iStatus.Int(), KErrNotFound);
1.1096 +
1.1097 + //Delete event2 /////////////////////////
1.1098 + aClient.ClearLog(threshold, KSimId2, active->iStatus);
1.1099 + active->StartL();
1.1100 + CActiveScheduler::Start();
1.1101 + TEST2(active->iStatus.Int(), KErrNone);
1.1102 + //Event1 should be there
1.1103 + active->StartL();
1.1104 + aClient.GetEvent(*event1, active->iStatus);
1.1105 + CActiveScheduler::Start();
1.1106 + TEST2(active->iStatus.Int(), KErrNone);
1.1107 + active->StartL();
1.1108 + aClient.GetEvent(*event2, active->iStatus);
1.1109 + CActiveScheduler::Start();
1.1110 + TEST2(active->iStatus.Int(), KErrNotFound);
1.1111 + active->StartL();
1.1112 + aClient.GetEvent(*event3, active->iStatus);
1.1113 + CActiveScheduler::Start();
1.1114 + TEST2(active->iStatus.Int(), KErrNotFound);
1.1115 +
1.1116 + //Delete event1 /////////////////////////
1.1117 + aClient.ClearLog(threshold, KSimId1, active->iStatus);
1.1118 + active->StartL();
1.1119 + CActiveScheduler::Start();
1.1120 + TEST2(active->iStatus.Int(), KErrNone);
1.1121 + //All events deleted
1.1122 + active->StartL();
1.1123 + aClient.GetEvent(*event1, active->iStatus);
1.1124 + CActiveScheduler::Start();
1.1125 + TEST2(active->iStatus.Int(), KErrNotFound);
1.1126 + active->StartL();
1.1127 + aClient.GetEvent(*event2, active->iStatus);
1.1128 + CActiveScheduler::Start();
1.1129 + TEST2(active->iStatus.Int(), KErrNotFound);
1.1130 + active->StartL();
1.1131 + aClient.GetEvent(*event3, active->iStatus);
1.1132 + CActiveScheduler::Start();
1.1133 + TEST2(active->iStatus.Int(), KErrNotFound);
1.1134 +
1.1135 + CleanupStack::PopAndDestroy(4); //event3, event2, event1, active
1.1136 + }
1.1137 +
1.1138 +/**
1.1139 +@SYMTestCaseID PDS-LOGENG-UT-4037
1.1140 +@SYMTestCaseDesc Clear log events from a recent list with specific SimId test.
1.1141 + The test adds 3 events to a recent list with different SimIds and then checks that
1.1142 + CLogEvent::ClearLog() deletes only the event with the specified id.
1.1143 +@SYMTestActions Clear log events from a recent list with specific SimId test.
1.1144 +@SYMTestExpectedResults Test must not fail
1.1145 +@SYMTestPriority High
1.1146 +@SYMREQ REQ12748
1.1147 +*/
1.1148 +void ClearLogRecentSimIdL(CLogClient& aClient)
1.1149 + {//This test case is compiled only when SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM macro is defined.
1.1150 + const TSimId KSimId1 = 4200110000U;
1.1151 + const TSimId KSimId2 = 38223;
1.1152 + const TSimId KSimId3 = 239816;
1.1153 +
1.1154 + const TUid KEvTypeUid = {KLogCallEventType};
1.1155 + _LIT(KEvDirection, "Missed call");
1.1156 +
1.1157 + CTestActive* active = new(ELeave)CTestActive();
1.1158 + CleanupStack::PushL(active);
1.1159 +
1.1160 + //////// Event1 ///////////////////////////
1.1161 + CLogEvent* event1 = CLogEvent::NewL();
1.1162 + CleanupStack::PushL(event1);
1.1163 + event1->SetEventType(KEvTypeUid);
1.1164 + event1->SetDirection(KEvDirection);
1.1165 + event1->SetNumber(_L("12345678"));
1.1166 + event1->SetSimId(KSimId1);
1.1167 + active->StartL();
1.1168 + aClient.AddEvent(*event1, active->iStatus);
1.1169 + CActiveScheduler::Start();
1.1170 + TEST2(active->iStatus.Int(), KErrNone);
1.1171 + //////// Event2 ///////////////////////////
1.1172 + CLogEvent* event2 = CLogEvent::NewL();
1.1173 + CleanupStack::PushL(event2);
1.1174 + event2->SetEventType(KEvTypeUid);
1.1175 + event2->SetDirection(KEvDirection);
1.1176 + event2->SetNumber(_L("87654321"));
1.1177 + event2->SetSimId(KSimId2);
1.1178 + active->StartL();
1.1179 + aClient.AddEvent(*event2, active->iStatus);
1.1180 + CActiveScheduler::Start();
1.1181 + TEST2(active->iStatus.Int(), KErrNone);
1.1182 + //////// Event3 ///////////////////////////
1.1183 + CLogEvent* event3 = CLogEvent::NewL();
1.1184 + CleanupStack::PushL(event3);
1.1185 + event3->SetEventType(KEvTypeUid);
1.1186 + event3->SetDirection(KEvDirection);
1.1187 + event3->SetNumber(_L("99229922"));
1.1188 + event3->SetSimId(KSimId3);
1.1189 + active->StartL();
1.1190 + aClient.AddEvent(*event3, active->iStatus);
1.1191 + CActiveScheduler::Start();
1.1192 + TEST2(active->iStatus.Int(), KErrNone);
1.1193 + //////////////////////////////////////////////////////////////////////////////////////////////////
1.1194 +
1.1195 + //Delete event3 /////////////////////////
1.1196 + aClient.ClearLog(KLogRecentMissedCalls, KSimId3, active->iStatus);
1.1197 + active->StartL();
1.1198 + CActiveScheduler::Start();
1.1199 + TEST2(active->iStatus.Int(), KErrNone);
1.1200 + //Event1 and event2 should be there
1.1201 + CLogViewRecent* view = CLogViewRecent::NewL(aClient);
1.1202 + CleanupStack::PushL(view);
1.1203 + TBool rc = view->SetRecentListL(KLogRecentMissedCalls, active->iStatus);
1.1204 + TEST(rc);
1.1205 + active->StartL();
1.1206 + CActiveScheduler::Start();
1.1207 + TEST2(active->iStatus.Int(), KErrNone);
1.1208 +
1.1209 + TInt count = view->CountL();
1.1210 + TEST2(count, 2);
1.1211 + rc = view->FirstL(active->iStatus);
1.1212 + TEST(rc);
1.1213 + active->StartL();
1.1214 + CActiveScheduler::Start();
1.1215 + TEST2(active->iStatus.Int(), KErrNone);
1.1216 + const CLogEvent& e1 = view->Event();
1.1217 + TEST(e1.SimId() == KSimId2 || e1.SimId() == KSimId1);
1.1218 + rc = view->NextL(active->iStatus);
1.1219 + TEST(rc);
1.1220 + active->StartL();
1.1221 + CActiveScheduler::Start();
1.1222 + TEST2(active->iStatus.Int(), KErrNone);
1.1223 + const CLogEvent& e2 = view->Event();
1.1224 + TEST(e2.SimId() == KSimId2 || e2.SimId() == KSimId1);
1.1225 + TEST(e1.Id() != e2.Id());
1.1226 +
1.1227 + CleanupStack::PopAndDestroy(view);
1.1228 +
1.1229 + //Delete event1 /////////////////////////
1.1230 + aClient.ClearLog(KLogRecentMissedCalls, KSimId1, active->iStatus);
1.1231 + active->StartL();
1.1232 + CActiveScheduler::Start();
1.1233 + TEST2(active->iStatus.Int(), KErrNone);
1.1234 + //Only event2 should be there
1.1235 + view = CLogViewRecent::NewL(aClient);
1.1236 + CleanupStack::PushL(view);
1.1237 + rc = view->SetRecentListL(KLogRecentMissedCalls, active->iStatus);
1.1238 + TEST(rc);
1.1239 + active->StartL();
1.1240 + CActiveScheduler::Start();
1.1241 + TEST2(active->iStatus.Int(), KErrNone);
1.1242 + count = view->CountL();
1.1243 + TEST2(count, 1);
1.1244 + rc = view->FirstL(active->iStatus);
1.1245 + TEST(rc);
1.1246 + active->StartL();
1.1247 + CActiveScheduler::Start();
1.1248 + TEST2(active->iStatus.Int(), KErrNone);
1.1249 + const CLogEvent& e3 = view->Event();
1.1250 + TEST(e3.SimId() == KSimId2);
1.1251 +
1.1252 + CleanupStack::PopAndDestroy(5); //view, event3, event2, event1, active
1.1253 + }
1.1254 +
1.1255 +#endif//SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM
1.1256 +
1.1257 +void doTestsL()
1.1258 + {
1.1259 + TestUtils::Initialize(_L("t_logpurge"));
1.1260 + TestUtils::DeleteDatabaseL();
1.1261 +
1.1262 + CLogClient* client = CLogClient::NewL(theFs);
1.1263 + CleanupStack::PushL(client);
1.1264 +
1.1265 + TheTest.Start(_L("Maximum Log Size"));
1.1266 + TestMaxLogSizeL(*client);
1.1267 + theLog.Write(_L8("Test 1 OK\n"));
1.1268 +
1.1269 + TheTest.Next(_L("Purge Log When Config Changed"));
1.1270 + TestMaxLogSizeConfigL(*client);
1.1271 + theLog.Write(_L8("Test 2 OK\n"));
1.1272 +
1.1273 + TheTest.Next(_L("Test purge by Maximum Log Age enabled/disabled"));
1.1274 + TestMaxLogAgeL(*client, 0); // disable purging by age
1.1275 + TestMaxLogAgeL(*client, KTestEventAge * 60 * 60 * 24);
1.1276 + theLog.Write(_L8("Test 3 OK\n"));
1.1277 +
1.1278 + TheTest.Next(_L("Maximum Recent List Size"));
1.1279 + TestMaxRecentSize1L(*client);
1.1280 + theLog.Write(_L8("Test 4 OK\n"));
1.1281 +
1.1282 + TheTest.Next(_L("Purge Recent Lists When Config Changed"));
1.1283 + TestMaxRecentSizeConfigL(*client);
1.1284 + theLog.Write(_L8("Test 5 OK\n"));
1.1285 +
1.1286 + TheTest.Next(_L("Maximum Recent List Size With Duplicates"));
1.1287 + TestMaxRecentSize2L(*client);
1.1288 + theLog.Write(_L8("Test 6 OK\n"));
1.1289 +
1.1290 + TheTest.Next(_L("Check no purge when retrieving event"));
1.1291 + TestNoPurgeWithGetL(*client);
1.1292 + theLog.Write(_L8("Test 7 OK\n"));
1.1293 +
1.1294 + TheTest.Next(_L("Check ClearLog works for different locales"));
1.1295 + TestClearLog1L(*client);
1.1296 + TestClearLog2L(*client);
1.1297 + theLog.Write(_L8("Test 8 OK\n"));
1.1298 +
1.1299 +#ifdef SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM
1.1300 + TheTest.Next(_L(" @SYMTestCaseID:PDS-LOGENG-UT-4036 CLogClient::ClearLog() + SimId test"));
1.1301 + ClearLogSimIdL(*client);
1.1302 + theLog.Write(_L8("Test 9 OK\n"));
1.1303 +
1.1304 + TheTest.Next(_L(" @SYMTestCaseID:PDS-LOGENG-UT-4037 CLogClient::ClearLog()/recent + SimId test"));
1.1305 + ClearLogRecentSimIdL(*client);
1.1306 + theLog.Write(_L8("Test 10 OK\n"));
1.1307 +#endif
1.1308 +
1.1309 + CleanupStack::PopAndDestroy(); // client;
1.1310 + }