|
1 // Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). |
|
2 // All rights reserved. |
|
3 // This component and the accompanying materials are made available |
|
4 // under the terms of "Eclipse Public License v1.0" |
|
5 // which accompanies this distribution, and is available |
|
6 // at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
7 // |
|
8 // Initial Contributors: |
|
9 // Nokia Corporation - initial contribution. |
|
10 // |
|
11 // Contributors: |
|
12 // |
|
13 // Description: |
|
14 // t_logapi2.cpp - LogEng API tests |
|
15 // |
|
16 // |
|
17 #include <s32file.h> |
|
18 #include <s32mem.h> |
|
19 #include <e32math.h> |
|
20 #include <bautils.h> |
|
21 #include <logview.h> |
|
22 #include "TEST.H" |
|
23 #include "LogServSqlStrings.h" |
|
24 |
|
25 #undef test //there is a "test" macro which hides "RTest test" declaration. |
|
26 |
|
27 RTest test(_L("t_logapi2")); |
|
28 |
|
29 _LIT(KTestRemoteParty1, "Remote Party"); |
|
30 _LIT(KTestDirection1, "Direction"); |
|
31 _LIT(KTestStatus1, "Status"); |
|
32 _LIT(KTestSubject1, "Subject"); |
|
33 const TUid KTestEventUid = {0x10005393}; |
|
34 const TLogDurationType KTestDurationType1 = 1; |
|
35 const TLogDuration KTestDuration1 = 0x1234; |
|
36 const TLogContactItemId KTestContact1 = 0x1234; |
|
37 const TLogLink KTestLink1 = 0x1234; |
|
38 _LIT8(KTestData1, "ABCDEFGH"); |
|
39 const TLogFlags KTestFlags1 = 0x5; |
|
40 _LIT(KEvNumber1, "11119999"); |
|
41 _LIT(KEvNumber2, "22226666"); |
|
42 const TLogDurationType KEvDurationType1 = 1; |
|
43 const TLogDurationType KEvDurationType2 = 2; |
|
44 const TLogContactItemId KEvContact1 = 1010; |
|
45 const TLogLink KEvLink1 = 2000; |
|
46 _LIT(KEvDesc1, "Event Type Description 1"); |
|
47 |
|
48 #ifdef SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM |
|
49 const TSimId KEvSimId1 = 3000000910U;//Bigger than KMaxTInt, to check that SQL statement formatting works as expected |
|
50 const TSimId KEvSimId2 = 2911; |
|
51 #endif |
|
52 |
|
53 const TInt KDiffEvCount = 10; |
|
54 |
|
55 //KEvDirection2 used together with KEvTypeUid guarantees that the properties of the event being changed |
|
56 //match the conditions of one the LogEng server recent lists and thus the "recent list" related functionality |
|
57 //on the server side will be used. |
|
58 _LIT(KEvDirection2, "Incoming"); |
|
59 |
|
60 const TUid KEvTypeUid = {KLogCallEventType}; |
|
61 const TUid KEvTypeUidLoggingDisabled = {0x447422}; |
|
62 |
|
63 enum TLogAddEventOps {ELogOpAddEvent, ELogOpAddEventInvalidType, ELogOpAddEventLoggingDisabled}; |
|
64 enum TLogGetEventOps {ELogOpGetEvent, ELogOpGetEventZeroId, ELogOpGetEventNotExists}; |
|
65 |
|
66 TLogId TheEvId = -1; |
|
67 TInt TheAddedEventCount = -1; |
|
68 TInt TheMaxLogSize = -1; |
|
69 |
|
70 //The default max log size is 1000. But the test timeouts on hardware with max log size of 1000. |
|
71 const TInt KMaxLogSize = 200; |
|
72 const TInt KMaxRecentLogSize = 10; // Default recent log size is 20 |
|
73 const TInt KMaxPlusEvCount = 100; //Added events count on top of the max log size |
|
74 |
|
75 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// |
|
76 |
|
77 //Add a new event type with "logging disabled" |
|
78 void DoAddEventTypeL(CLogClient& aClient, CTestActive& aActive) |
|
79 { |
|
80 CLogEventType* type = CLogEventType::NewL(); |
|
81 CleanupStack::PushL(type); |
|
82 |
|
83 type->SetUid(KEvTypeUidLoggingDisabled); |
|
84 type->SetDescription(_L("110111011011")); |
|
85 type->SetLoggingEnabled(EFalse); |
|
86 |
|
87 aClient.AddEventType(*type, aActive.iStatus); |
|
88 aActive.StartL(); |
|
89 CActiveScheduler::Start(); |
|
90 TEST2(aActive.iStatus.Int(), KErrNone); |
|
91 |
|
92 CleanupStack::PopAndDestroy(type); |
|
93 } |
|
94 |
|
95 void DoSetNewMaxLogSizeL(CLogClient& aClient, CTestActive& aActive) |
|
96 { |
|
97 //Check what is the max log size. |
|
98 TLogConfig config; |
|
99 aActive.StartL(); |
|
100 aClient.GetConfig(config, aActive.iStatus); |
|
101 CActiveScheduler::Start(); |
|
102 TEST2(aActive.iStatus.Int(), KErrNone); |
|
103 //Set new max log size |
|
104 config.iMaxLogSize = KMaxLogSize; |
|
105 aActive.StartL(); |
|
106 aClient.ChangeConfig(config, aActive.iStatus); |
|
107 CActiveScheduler::Start(); |
|
108 TEST2(aActive.iStatus.Int(), KErrNone); |
|
109 //Test the new max log size |
|
110 aActive.StartL(); |
|
111 aClient.GetConfig(config, aActive.iStatus); |
|
112 CActiveScheduler::Start(); |
|
113 TEST2(aActive.iStatus.Int(), KErrNone); |
|
114 TEST2(config.iMaxLogSize, KMaxLogSize); |
|
115 // |
|
116 TheMaxLogSize = config.iMaxLogSize; |
|
117 TheAddedEventCount = config.iMaxLogSize + KMaxPlusEvCount; |
|
118 } |
|
119 |
|
120 void DoAddEventsL() |
|
121 { |
|
122 CLogClient* client = CLogClient::NewL(theFs); |
|
123 CleanupStack::PushL(client); |
|
124 CTestActive* active = new(ELeave)CTestActive(); |
|
125 CleanupStack::PushL(active); |
|
126 |
|
127 //Set new max log size |
|
128 DoSetNewMaxLogSizeL(*client, *active); |
|
129 |
|
130 //Add TheAddedEventCount events. Some of them with SimId, some - not. |
|
131 //This certainly will involve some log purging operations when the log size reaches the max. |
|
132 CLogEvent* event = CLogEvent::NewL(); |
|
133 CleanupStack::PushL(event); |
|
134 event->SetEventType(KLogCallEventTypeUid); |
|
135 event->SetRemoteParty(KTestRemoteParty1); |
|
136 event->SetDirection(KTestDirection1); |
|
137 event->SetDurationType(KEvDurationType1); |
|
138 event->SetDuration(KTestDuration1); |
|
139 event->SetStatus(KTestStatus1); |
|
140 event->SetSubject(KTestSubject1); |
|
141 event->SetNumber(KEvNumber1); |
|
142 event->SetContact(KEvContact1); |
|
143 event->SetLink(KEvLink1); |
|
144 event->SetDescription(KEvDesc1); |
|
145 event->SetFlags(KTestFlags1); |
|
146 event->SetDataL(KTestData1); |
|
147 |
|
148 TTime st_time; |
|
149 st_time.UniversalTime(); |
|
150 |
|
151 test.Printf(_L("Added events:\n")); |
|
152 TInt diffEvCount = KDiffEvCount; |
|
153 for(TInt i=0;i<TheAddedEventCount;++i) |
|
154 { |
|
155 #ifdef SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM |
|
156 event->SetSimId(KLogNullSimId); |
|
157 #endif |
|
158 event->SetDurationType(KEvDurationType1); |
|
159 event->SetNumber(KEvNumber1); |
|
160 if((i %2) == 0) |
|
161 { |
|
162 #ifdef SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM |
|
163 event->SetSimId(KEvSimId1); |
|
164 #endif |
|
165 if((i > TheMaxLogSize / 2 + 1) && (i % 10) == 0 && --diffEvCount >= 0) |
|
166 {//Add after the second half because when the log grows above the max log size, the first events will be deleted |
|
167 event->SetDurationType(KEvDurationType2); |
|
168 event->SetNumber(KEvNumber2); |
|
169 } |
|
170 } |
|
171 active->StartL(); |
|
172 client->AddEvent(*event, active->iStatus); |
|
173 CActiveScheduler::Start(); |
|
174 TEST(!active->IsActive()); |
|
175 TEST2(active->iStatus.Int(), KErrNone); |
|
176 if((i % 50) == 0 && i > 0) |
|
177 { |
|
178 test.Printf(_L("%d\r"), i); |
|
179 } |
|
180 } |
|
181 test.Printf(_L("%d\n"), TheAddedEventCount); |
|
182 |
|
183 TTime end_time; |
|
184 end_time.UniversalTime(); |
|
185 |
|
186 CleanupStack::PopAndDestroy(event); |
|
187 |
|
188 CleanupStack::PopAndDestroy(active); |
|
189 CleanupStack::PopAndDestroy(client); |
|
190 |
|
191 TTimeIntervalMicroSeconds us = end_time.MicroSecondsFrom(st_time); |
|
192 test.Printf(_L("%d events added. Time: %ld milliseconds\n"), TheAddedEventCount, us.Int64() / 1000); |
|
193 } |
|
194 |
|
195 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// |
|
196 |
|
197 /** |
|
198 @SYMTestCaseID PDS-LOGENG-UT-4042 |
|
199 @SYMTestCaseDesc "Cancel operation" test. |
|
200 The test uses RLogTestSession to establish a connection with the EventViewer server. |
|
201 The the test initializes an "Add Event" opertaion. |
|
202 But instead of completing the operation the test cancels it. |
|
203 @SYMTestActions "Cancel operation" test. |
|
204 @SYMTestExpectedResults Test must not fail |
|
205 @SYMTestPriority Medium |
|
206 @SYMREQ REQ12747 |
|
207 */ |
|
208 void CancelOperationTest() |
|
209 { |
|
210 RLogTestSession sess; |
|
211 TInt err = sess.Connect(); |
|
212 TEST2(err, KErrNone); |
|
213 |
|
214 CLogEvent* event = NULL; |
|
215 TRAP(err, event = CLogEvent::NewL()); |
|
216 TEST2(err, KErrNone); |
|
217 event->SetEventType(KTestEventUid); |
|
218 event->SetRemoteParty(KTestRemoteParty1); |
|
219 event->SetDirection(KTestDirection1); |
|
220 event->SetDurationType(KTestDurationType1); |
|
221 event->SetDuration(KTestDuration1); |
|
222 event->SetStatus(KTestStatus1); |
|
223 event->SetSubject(KTestSubject1); |
|
224 event->SetContact(KTestContact1); |
|
225 event->SetLink(KTestLink1); |
|
226 TRAP(err, event->SetDataL(KTestData1)); |
|
227 TEST2(err, KErrNone); |
|
228 event->SetFlags(KTestFlags1); |
|
229 |
|
230 TBuf8<1024> buf; |
|
231 RDesWriteStream strm(buf); |
|
232 TRAP(err, event->ExternalizeL(strm)); |
|
233 TEST2(err, KErrNone); |
|
234 TRAP(err, strm.CommitL()); |
|
235 TEST2(err, KErrNone); |
|
236 |
|
237 TPckgBuf<TLogClientServerData> data; |
|
238 data().iOperationType = ELogOperationEventAdd; |
|
239 data().iOperationId = KLogNullOperationId; |
|
240 |
|
241 TRequestStatus stat; |
|
242 TIpcArgs args1(&data, &buf); |
|
243 sess.Send(ELogOperationInitiate, args1, stat); |
|
244 TEST2(stat.Int(), KRequestPending); |
|
245 TIpcArgs args2(&data); |
|
246 err = sess.Send(ELogOperationCancel, args2); |
|
247 TEST2(err, KErrCancel); |
|
248 User::WaitForRequest(stat); |
|
249 err = stat.Int(); |
|
250 TEST2(err, KErrCancel); |
|
251 |
|
252 strm.Close(); |
|
253 delete event; |
|
254 sess.Close(); |
|
255 } |
|
256 |
|
257 /** |
|
258 @SYMTestCaseID PDS-LOGENG-UT-4029 |
|
259 @SYMTestCaseDesc AddEvent() server side OOM test. |
|
260 This test uses the results from the previous test cases that |
|
261 the LogEng database contains TheMaxLogSize events. |
|
262 This ensures that the "purge main" functionality on the server side |
|
263 will be used. |
|
264 The properties of the event being added are such (KEvDirection1 and KEvTypeUid) that |
|
265 one of the LogServ recent lists will be used. This ensures that the "purge recent" |
|
266 LogEng server functionality will be used. |
|
267 The test, as any other of the LogEng server OOM tests, does not fully cover the used on the |
|
268 server side functions, because: |
|
269 1) CLogAddEvent will set the iEventAdded flag right after adding the event to the database. |
|
270 After that, any OOM failure that occurs for example in "purge recent" related calls, will be |
|
271 ignored. |
|
272 2) CLogEvent will use the CLogDuplicate active object for the "purge recent" action. |
|
273 When CLogDuplicate fails with KErrNoMemory in DoRunL(), the error is ignored and not reported |
|
274 back. |
|
275 @SYMTestActions AddEvent() server side OOM test. |
|
276 @SYMTestExpectedResults Test must not fail |
|
277 @SYMTestPriority Medium |
|
278 @SYMREQ REQ12746 |
|
279 */ |
|
280 void AddEventOomTestL(TLogAddEventOps aLogAddEventOp, TInt aExpectedError) |
|
281 { |
|
282 CLogClient* client = CLogClient::NewL(theFs); |
|
283 CleanupStack::PushL(client); |
|
284 CTestActive* active = new(ELeave)CTestActive(); |
|
285 CleanupStack::PushL(active); |
|
286 CLogEvent* event = CLogEvent::NewL(); |
|
287 CleanupStack::PushL(event); |
|
288 |
|
289 if(aLogAddEventOp == ELogOpAddEventLoggingDisabled) |
|
290 { |
|
291 DoAddEventTypeL(*client, *active); |
|
292 } |
|
293 |
|
294 TTime now; |
|
295 now.UniversalTime(); |
|
296 |
|
297 TUid eventType = KEvTypeUid; |
|
298 if(aLogAddEventOp == ELogOpAddEventInvalidType) |
|
299 { |
|
300 eventType = TUid::Uid(0x445972); |
|
301 } |
|
302 else if(aLogAddEventOp == ELogOpAddEventLoggingDisabled) |
|
303 { |
|
304 eventType = KEvTypeUidLoggingDisabled; |
|
305 } |
|
306 |
|
307 event->SetEventType(eventType); |
|
308 event->SetRemoteParty(KTestRemoteParty1); |
|
309 event->SetDirection(KTestDirection1); |
|
310 event->SetDurationType(KEvDurationType1); |
|
311 event->SetDuration(KTestDuration1); |
|
312 event->SetStatus(KTestStatus1); |
|
313 event->SetSubject(KTestSubject1); |
|
314 event->SetNumber(KEvNumber1); |
|
315 event->SetContact(KEvContact1); |
|
316 event->SetLink(KEvLink1); |
|
317 event->SetDescription(KEvDesc1); |
|
318 event->SetFlags(KTestFlags1); |
|
319 event->SetDataL(KTestData1); |
|
320 #ifdef SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM |
|
321 event->SetSimId(KEvSimId1); |
|
322 #endif |
|
323 |
|
324 TInt failCount = 0; |
|
325 TBool finished = EFalse; |
|
326 |
|
327 while(!finished) |
|
328 { |
|
329 __LOGSERV_UHEAP_FAILNEXT(++failCount); |
|
330 client->AddEvent(*event, active->iStatus); |
|
331 active->StartL(); |
|
332 CActiveScheduler::Start(); |
|
333 |
|
334 if(active->iStatus.Int() == aExpectedError) |
|
335 { |
|
336 finished = ETrue; |
|
337 } |
|
338 |
|
339 __LOGSERV_UHEAP_RESET; |
|
340 |
|
341 if(active->iStatus.Int() != aExpectedError) |
|
342 { |
|
343 TEST2(active->iStatus.Int(), KErrNoMemory); |
|
344 } |
|
345 } |
|
346 |
|
347 TEST2(active->iStatus.Int(), aExpectedError); |
|
348 if(aLogAddEventOp == ELogOpAddEvent) |
|
349 { |
|
350 TEST(event->Time() >= now); |
|
351 active->StartL(); |
|
352 client->GetEvent(*event, active->iStatus); |
|
353 CActiveScheduler::Start(); |
|
354 TEST2(active->iStatus.Int(), KErrNone); |
|
355 TheEvId = event->Id(); |
|
356 TEST(TheEvId > 0); |
|
357 } |
|
358 |
|
359 CleanupStack::PopAndDestroy(event); |
|
360 CleanupStack::PopAndDestroy(active); |
|
361 CleanupStack::PopAndDestroy(client); |
|
362 |
|
363 test.Printf(_L("===CLogClient::AddEvent() server side OOM test succeeded at iteration %d\n"), failCount); |
|
364 } |
|
365 |
|
366 /** |
|
367 @SYMTestCaseID PDS-LOGENG-UT-4030 |
|
368 @SYMTestCaseDesc ChangeEvent() server side OOM test. |
|
369 This test uses the results from the previous test cases that |
|
370 the LogEng database contains TheMaxLogSize events. |
|
371 This ensures that the "purge main" functionality on the server side |
|
372 will be used. |
|
373 The properties of the event being changed are such (KEvDirection2 and KEvTypeUid) that |
|
374 one of the LogServ recent lists will be used. This ensures that the "purge recent" |
|
375 LogEng server functionality will be used. |
|
376 @SYMTestActions ChangeEvent() server side OOM test. |
|
377 @SYMTestExpectedResults Test must not fail |
|
378 @SYMTestPriority Medium |
|
379 @SYMREQ REQ12746 |
|
380 */ |
|
381 void ChangeEventOomTestL(TBool aEventExists) |
|
382 { |
|
383 CLogClient* client = CLogClient::NewL(theFs); |
|
384 CleanupStack::PushL(client); |
|
385 CTestActive* active = new(ELeave)CTestActive(); |
|
386 CleanupStack::PushL(active); |
|
387 CLogEvent* event = CLogEvent::NewL(); |
|
388 CleanupStack::PushL(event); |
|
389 |
|
390 event->SetId(TheEvId); |
|
391 active->StartL(); |
|
392 client->GetEvent(*event, active->iStatus); |
|
393 CActiveScheduler::Start(); |
|
394 TEST2(active->iStatus.Int(), KErrNone); |
|
395 TEST2(TheEvId, event->Id()); |
|
396 event->SetDirection(KEvDirection2); |
|
397 #ifdef SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM |
|
398 event->SetSimId(KEvSimId2); |
|
399 #endif |
|
400 |
|
401 TInt failCount = 0; |
|
402 TBool finished = EFalse; |
|
403 |
|
404 if(!aEventExists) |
|
405 {//Search for a non-existing event in the OOM loop |
|
406 event->SetId(TheEvId + 5678); |
|
407 } |
|
408 |
|
409 while(!finished) |
|
410 { |
|
411 __LOGSERV_UHEAP_FAILNEXT(++failCount); |
|
412 client->ChangeEvent(*event, active->iStatus); |
|
413 active->StartL(); |
|
414 CActiveScheduler::Start(); |
|
415 |
|
416 TInt err = active->iStatus.Int(); |
|
417 if(err == (aEventExists ? KErrNone : KErrNotFound)) |
|
418 { |
|
419 finished = ETrue; |
|
420 } |
|
421 |
|
422 __LOGSERV_UHEAP_RESET; |
|
423 |
|
424 if(err != (aEventExists ? KErrNone : KErrNotFound)) |
|
425 { |
|
426 TEST2(err, KErrNoMemory); |
|
427 } |
|
428 } |
|
429 |
|
430 active->StartL(); |
|
431 client->GetEvent(*event, active->iStatus); |
|
432 CActiveScheduler::Start(); |
|
433 if(aEventExists) |
|
434 { |
|
435 TEST2(active->iStatus.Int(), KErrNone); |
|
436 #ifdef SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM |
|
437 TEST2(event->SimId(), KEvSimId2); |
|
438 #endif |
|
439 } |
|
440 else |
|
441 { |
|
442 TEST2(active->iStatus.Int(), KErrNotFound); |
|
443 } |
|
444 |
|
445 CleanupStack::PopAndDestroy(event); |
|
446 CleanupStack::PopAndDestroy(active); |
|
447 CleanupStack::PopAndDestroy(client); |
|
448 |
|
449 test.Printf(_L("===CLogClient::ChangeEvent() server side OOM test succeeded at iteration %d\n"), failCount); |
|
450 } |
|
451 |
|
452 /** |
|
453 @SYMTestCaseID PDS-LOGENG-UT-4031 |
|
454 @SYMTestCaseDesc DeleteEvent() server side OOM test. |
|
455 This test uses the results from the previous test cases that |
|
456 the LogEng database contains TheMaxLogSize events. |
|
457 This ensures that the "purge main" functionality on the server side |
|
458 will be used. |
|
459 @SYMTestActions DeleteEvent() server side OOM test. |
|
460 @SYMTestExpectedResults Test must not fail |
|
461 @SYMTestPriority Medium |
|
462 @SYMREQ REQ12746 |
|
463 */ |
|
464 void DeleteEventOomTestL(TBool aEventExists) |
|
465 { |
|
466 CLogClient* client = CLogClient::NewL(theFs); |
|
467 CleanupStack::PushL(client); |
|
468 CTestActive* active = new(ELeave)CTestActive(); |
|
469 CleanupStack::PushL(active); |
|
470 |
|
471 TInt failCount = 0; |
|
472 TBool finished = EFalse; |
|
473 |
|
474 while(!finished) |
|
475 { |
|
476 __LOGSERV_UHEAP_FAILNEXT(++failCount); |
|
477 client->DeleteEvent(TheEvId, active->iStatus); |
|
478 active->StartL(); |
|
479 CActiveScheduler::Start(); |
|
480 |
|
481 TInt err = active->iStatus.Int(); |
|
482 if(err == (aEventExists ? KErrNone : KErrNotFound)) |
|
483 { |
|
484 finished = ETrue; |
|
485 } |
|
486 |
|
487 __LOGSERV_UHEAP_RESET; |
|
488 |
|
489 if(err != (aEventExists ? KErrNone : KErrNotFound)) |
|
490 { |
|
491 TEST2(err, KErrNoMemory); |
|
492 } |
|
493 } |
|
494 |
|
495 CLogEvent* event = CLogEvent::NewL(); |
|
496 CleanupStack::PushL(event); |
|
497 event->SetId(TheEvId); |
|
498 active->StartL(); |
|
499 client->GetEvent(*event, active->iStatus); |
|
500 CActiveScheduler::Start(); |
|
501 TEST2(active->iStatus.Int(), KErrNotFound); |
|
502 CleanupStack::PopAndDestroy(event); |
|
503 |
|
504 CleanupStack::PopAndDestroy(active); |
|
505 CleanupStack::PopAndDestroy(client); |
|
506 |
|
507 test.Printf(_L("===CLogClient::DeleteEvent() server side OOM test succeeded at iteration %d\n"), failCount); |
|
508 } |
|
509 |
|
510 /** |
|
511 @SYMTestCaseID PDS-LOGENG-UT-4032 |
|
512 @SYMTestCaseDesc GetEvent() server side OOM test. |
|
513 This test uses the results from the previous test cases that |
|
514 the LogEng database contains TheMaxLogSize events. |
|
515 GetEvent() is executed in OOM loop. |
|
516 @SYMTestActions GetEvent() server side OOM test. |
|
517 @SYMTestExpectedResults Test must not fail |
|
518 @SYMTestPriority Medium |
|
519 @SYMREQ REQ12746 |
|
520 */ |
|
521 void GetEventOomTestL(TLogGetEventOps aGetEventOp, TInt aExpectedError) |
|
522 { |
|
523 CLogClient* client = CLogClient::NewL(theFs); |
|
524 CleanupStack::PushL(client); |
|
525 CTestActive* active = new(ELeave)CTestActive(); |
|
526 CleanupStack::PushL(active); |
|
527 CLogEvent* event = CLogEvent::NewL(); |
|
528 CleanupStack::PushL(event); |
|
529 |
|
530 event->SetId(aGetEventOp == ELogOpGetEvent ? TheEvId : (aGetEventOp == ELogOpGetEventNotExists ? 0x932271F : 0x0)); |
|
531 |
|
532 TInt failCount = 0; |
|
533 TBool finished = EFalse; |
|
534 |
|
535 while(!finished) |
|
536 { |
|
537 __LOGSERV_UHEAP_FAILNEXT(++failCount); |
|
538 client->GetEvent(*event, active->iStatus); |
|
539 active->StartL(); |
|
540 CActiveScheduler::Start(); |
|
541 |
|
542 if(active->iStatus.Int() == aExpectedError) |
|
543 { |
|
544 finished = ETrue; |
|
545 } |
|
546 |
|
547 __LOGSERV_UHEAP_RESET; |
|
548 |
|
549 if(active->iStatus.Int() != aExpectedError) |
|
550 { |
|
551 TEST2(active->iStatus.Int(), KErrNoMemory); |
|
552 } |
|
553 } |
|
554 |
|
555 TEST2(active->iStatus.Int(), aExpectedError); |
|
556 #ifdef SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM |
|
557 if(aGetEventOp == ELogOpGetEvent) |
|
558 { |
|
559 TEST2(event->SimId(), KEvSimId2); |
|
560 } |
|
561 #endif |
|
562 |
|
563 CleanupStack::PopAndDestroy(event); |
|
564 CleanupStack::PopAndDestroy(active); |
|
565 CleanupStack::PopAndDestroy(client); |
|
566 |
|
567 test.Printf(_L("===CLogClient::GetEvent() server side OOM test succeeded at iteration %d\n"), failCount); |
|
568 } |
|
569 |
|
570 /** |
|
571 @SYMTestCaseID PDS-LOGENG-UT-4033 |
|
572 @SYMTestCaseDesc Change Event Type test. |
|
573 The test attempts to change the type of an existing event. |
|
574 The attempt must fails with KErrPermissionDenied error. |
|
575 @SYMTestActions Change Event Type test. |
|
576 @SYMTestExpectedResults Test must not fail |
|
577 @SYMTestPriority Medium |
|
578 @SYMREQ REQ12746 |
|
579 */ |
|
580 void ChangeStandardEventTypeTestL() |
|
581 { |
|
582 CLogClient* client = CLogClient::NewL(theFs); |
|
583 CleanupStack::PushL(client); |
|
584 CTestActive* active = new(ELeave)CTestActive(); |
|
585 CleanupStack::PushL(active); |
|
586 |
|
587 CLogEventType* evType = CLogEventType::NewL(); |
|
588 CleanupStack::PushL(evType); |
|
589 TUid uid = {KLogCallEventType}; |
|
590 evType->SetUid(uid); |
|
591 evType->SetDescription(_L("aaaaaaaa")); |
|
592 |
|
593 active->StartL(); |
|
594 client->ChangeEventType(*evType, active->iStatus); |
|
595 CActiveScheduler::Start(); |
|
596 TEST2(active->iStatus.Int(), KErrPermissionDenied); |
|
597 |
|
598 CleanupStack::PopAndDestroy(evType); |
|
599 |
|
600 CleanupStack::PopAndDestroy(active); |
|
601 CleanupStack::PopAndDestroy(client); |
|
602 } |
|
603 |
|
604 CLogFilter* DoCreateFilter1LC() |
|
605 { |
|
606 CLogFilter* filter = CLogFilter::NewL(); |
|
607 CleanupStack::PushL(filter); |
|
608 |
|
609 #ifdef SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM |
|
610 filter->SetSimId(KEvSimId2); |
|
611 #endif |
|
612 filter->SetDurationType(KEvDurationType2); |
|
613 filter->SetNumber(KEvNumber2); |
|
614 filter->SetStatus(KTestStatus1); |
|
615 filter->SetDirection(KTestDirection1); |
|
616 |
|
617 return filter; |
|
618 } |
|
619 |
|
620 CLogFilter* DoCreateFilter2LC() |
|
621 { |
|
622 CLogFilter* filter = CLogFilter::NewL(); |
|
623 CleanupStack::PushL(filter); |
|
624 |
|
625 #ifdef SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM |
|
626 filter->SetSimId(KEvSimId1); |
|
627 #endif |
|
628 filter->SetDurationType(KEvDurationType1); |
|
629 filter->SetNumber(KEvNumber1); |
|
630 filter->SetStatus(KTestStatus1); |
|
631 filter->SetDirection(KTestDirection1); |
|
632 filter->SetEventType(KEvTypeUid); |
|
633 filter->SetRemoteParty(KTestRemoteParty1); |
|
634 filter->SetNullFields(ELogFlagsField); |
|
635 |
|
636 return filter; |
|
637 } |
|
638 |
|
639 CLogFilter* DoCreateFilter3LC() |
|
640 { |
|
641 CLogFilter* filter = CLogFilter::NewL(); |
|
642 CleanupStack::PushL(filter); |
|
643 |
|
644 #ifdef SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM |
|
645 filter->SetSimId(KEvSimId1); |
|
646 #endif |
|
647 filter->SetDurationType(KEvDurationType1); |
|
648 filter->SetNumber(KEvNumber1); |
|
649 filter->SetStatus(KTestStatus1); |
|
650 filter->SetDirection(KTestDirection1); |
|
651 filter->SetEventType(KEvTypeUid); |
|
652 filter->SetRemoteParty(KTestRemoteParty1); |
|
653 filter->SetContact(KEvContact1); |
|
654 filter->SetNullFields(ELogFlagsField); |
|
655 |
|
656 return filter; |
|
657 } |
|
658 |
|
659 /** |
|
660 @SYMTestCaseID PDS-LOGENG-UT-4034 |
|
661 @SYMTestCaseDesc Complex view filter set test. |
|
662 The test creates a set of filters using all event properties and duplicating some of them |
|
663 in the filters. Then sets the set of filters to a view and iterates over the view's events. |
|
664 The idea is to test as much as possible the server side filter processing in TLogFilterExprBuilder |
|
665 class implementation. |
|
666 @SYMTestActions Complex view filter set test. |
|
667 @SYMTestExpectedResults Test must not fail |
|
668 @SYMTestPriority Medium |
|
669 @SYMREQ REQ12746 |
|
670 */ |
|
671 void ComplexFilterSetTestL() |
|
672 { |
|
673 CLogClient* client = CLogClient::NewL(theFs); |
|
674 CleanupStack::PushL(client); |
|
675 CTestActive* active = new(ELeave)CTestActive(); |
|
676 CleanupStack::PushL(active); |
|
677 CLogViewEvent* view = CLogViewEvent::NewL(*client); |
|
678 CleanupStack::PushL(view); |
|
679 CLogFilter* filter1 = DoCreateFilter1LC(); |
|
680 CLogFilter* filter2 = DoCreateFilter2LC(); |
|
681 CLogFilter* filter3 = DoCreateFilter3LC(); |
|
682 CLogFilterList* filterList = new(ELeave)CLogFilterList; |
|
683 CleanupStack::PushL(filterList); |
|
684 filterList->AppendL(filter1); |
|
685 filterList->AppendL(filter2); |
|
686 filterList->AppendL(filter3); |
|
687 |
|
688 //Check the "copy filter list" operations |
|
689 CLogFilterList* filterList2 = filterList->CopyL(); |
|
690 TEST2(filterList2->Count(), filterList->Count()); |
|
691 delete filterList2; |
|
692 CLogFilterList* filterList3 = filterList->CopyLC(); |
|
693 TEST2(filterList3->Count(), filterList->Count()); |
|
694 CleanupStack::PopAndDestroy(filterList3); |
|
695 |
|
696 TTime st_time; |
|
697 st_time.UniversalTime(); |
|
698 TBool res = view->SetFilterL(*filterList, active->iStatus); |
|
699 TEST(res); |
|
700 active->StartL(); |
|
701 CActiveScheduler::Start(); |
|
702 TEST2(active->iStatus.Int(), KErrNone); |
|
703 TInt count = view->CountL(); |
|
704 test.Printf(_L("===Events count: %d\n"), count); |
|
705 TTime end_time; |
|
706 end_time.UniversalTime(); |
|
707 TTimeIntervalMicroSeconds us = end_time.MicroSecondsFrom(st_time); |
|
708 test.Printf(_L("SetFilter(). Time: %ld milliseconds\n"), us.Int64() / 1000); |
|
709 |
|
710 st_time.UniversalTime(); |
|
711 if(view->FirstL(active->iStatus)) |
|
712 { |
|
713 count = 0; |
|
714 do |
|
715 { |
|
716 active->StartL(); |
|
717 CActiveScheduler::Start(); |
|
718 TEST2(active->iStatus.Int(), KErrNone); |
|
719 ++count; |
|
720 } |
|
721 while(view->NextL(active->iStatus)); |
|
722 } |
|
723 end_time.UniversalTime(); |
|
724 us = end_time.MicroSecondsFrom(st_time); |
|
725 test.Printf(_L("Event view walk completed. Events count: %d. Time: %ld milliseconds\n"), count, us.Int64() / 1000); |
|
726 |
|
727 CleanupStack::PopAndDestroy(filterList); |
|
728 CleanupStack::PopAndDestroy(filter3); |
|
729 CleanupStack::PopAndDestroy(filter2); |
|
730 CleanupStack::PopAndDestroy(filter1); |
|
731 CleanupStack::PopAndDestroy(view); |
|
732 CleanupStack::PopAndDestroy(active); |
|
733 CleanupStack::PopAndDestroy(client); |
|
734 } |
|
735 |
|
736 #ifdef _DEBUG |
|
737 static void StopLogServerL() |
|
738 { |
|
739 static RLogTestSession logServSession; |
|
740 //this function doesn't have any effect on UREL builds as LogEng server doesn't |
|
741 //support the transient mode in UREL builds |
|
742 //Used for LogEng server side heap failure testing. |
|
743 TInt error = KErrNone; |
|
744 |
|
745 if(!logServSession.Handle()) |
|
746 { |
|
747 error = logServSession.Connect(); |
|
748 } |
|
749 |
|
750 // Is the server running? |
|
751 if(error == KErrNotFound) |
|
752 { |
|
753 return; |
|
754 } |
|
755 LEAVE_IF_ERROR(error); |
|
756 |
|
757 // Make the server transient |
|
758 TInt p0 = 1; |
|
759 TIpcArgs ipcArgs(p0); |
|
760 LEAVE_IF_ERROR(logServSession.Send(ELogMakeTransient, ipcArgs)); |
|
761 |
|
762 logServSession.Close(); |
|
763 |
|
764 User::After(6 * 1000000); // Enough time for the server to exit |
|
765 } |
|
766 #else//_DEBUG |
|
767 static void StopLogServerL() |
|
768 { |
|
769 RDebug::Print(_L("StopLogServerL(): the LogEng server cannot be stopped in release mode. ELogMakeTransient is a debug message.\n")); |
|
770 } |
|
771 #endif//_DEBUG |
|
772 |
|
773 /** |
|
774 @SYMTestCaseID PDS-LOGENG-UT-4047 |
|
775 @SYMTestCaseDesc Configuration value update test. |
|
776 The test changes the configuration values & thne stops the log server. Start the |
|
777 server again & check if the configuration values are updated. |
|
778 Again restores the original value back. |
|
779 @SYMTestActions Configuration value update test. |
|
780 @SYMTestExpectedResults Test must not fail |
|
781 @SYMTestPriority Medium |
|
782 @SYMREQ DEF142142 |
|
783 */ |
|
784 void DoCheckUpdateConfigL() |
|
785 { |
|
786 |
|
787 CLogClient* client = CLogClient::NewL(theFs); |
|
788 CleanupStack::PushL(client); |
|
789 CTestActive* active = new(ELeave)CTestActive(); |
|
790 CleanupStack::PushL(active); |
|
791 |
|
792 //Check for updated configurations. |
|
793 TLogConfig config; |
|
794 active->StartL(); |
|
795 client->GetConfig(config, active->iStatus); |
|
796 CActiveScheduler::Start(); |
|
797 TEST2(active->iStatus.Int(), KErrNone); |
|
798 |
|
799 //Set new max log size |
|
800 TLogSize tmpMaxLogSize = config.iMaxLogSize; |
|
801 config.iMaxLogSize = KMaxLogSize; |
|
802 config.iMaxRecentLogSize = KMaxRecentLogSize; |
|
803 active->StartL(); |
|
804 client->ChangeConfig(config, active->iStatus); |
|
805 CActiveScheduler::Start(); |
|
806 TEST2(active->iStatus.Int(), KErrNone); |
|
807 |
|
808 //Stop the Server |
|
809 StopLogServerL(); |
|
810 |
|
811 //Test the new max log size |
|
812 active->StartL(); |
|
813 client->GetConfig(config, active->iStatus); |
|
814 CActiveScheduler::Start(); |
|
815 TEST2(active->iStatus.Int(), KErrNone); |
|
816 TEST2(config.iMaxLogSize, KMaxLogSize); |
|
817 |
|
818 //Set original max log size |
|
819 config.iMaxLogSize = tmpMaxLogSize; |
|
820 active->StartL(); |
|
821 client->ChangeConfig(config, active->iStatus); |
|
822 CActiveScheduler::Start(); |
|
823 TEST2(active->iStatus.Int(), KErrNone); |
|
824 |
|
825 CleanupStack::PopAndDestroy(active); |
|
826 CleanupStack::PopAndDestroy(client); |
|
827 } |
|
828 |
|
829 ////////////////////////////////////////////////////////////////////////////////////////////////////// |
|
830 #ifdef SYSLIBS_TEST |
|
831 |
|
832 TLogId DoAddEvent2TestRecentListL(CLogClient& aClient, CTestActive& aActive) |
|
833 { |
|
834 CLogEvent* event = CLogEvent::NewL(); |
|
835 CleanupStack::PushL(event); |
|
836 |
|
837 event->SetEventType(KLogCallEventTypeUid); |
|
838 event->SetRemoteParty(KLogRctTListRemoteParty); |
|
839 event->SetDirection(KLogRctTListDirection); |
|
840 event->SetDurationType(KLogRctTListDurationType); |
|
841 event->SetDuration(KTestDuration1); |
|
842 event->SetStatus(KLogRctTListStatus); |
|
843 event->SetSubject(KTestSubject1); |
|
844 event->SetNumber(KLogRctTListNumber); |
|
845 event->SetContact(KEvContact1); |
|
846 event->SetLink(KEvLink1); |
|
847 event->SetDescription(KEvDesc1); |
|
848 event->SetFlags(KLogRctTListFlags); |
|
849 event->SetDataL(KTestData1); |
|
850 #ifdef SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM |
|
851 event->SetSimId(KLogRctTListSimId); |
|
852 #endif |
|
853 |
|
854 aActive.StartL(); |
|
855 aClient.AddEvent(*event, aActive.iStatus); |
|
856 CActiveScheduler::Start(); |
|
857 TEST(!aActive.IsActive()); |
|
858 TEST2(aActive.iStatus.Int(), KErrNone); |
|
859 TLogId logId = event->Id(); |
|
860 |
|
861 //Get the just added event |
|
862 aActive.StartL(); |
|
863 aClient.GetEvent(*event, aActive.iStatus); |
|
864 CActiveScheduler::Start(); |
|
865 TEST2(aActive.iStatus.Int(), KErrNone); |
|
866 |
|
867 CleanupStack::PopAndDestroy(event); |
|
868 |
|
869 return logId; |
|
870 } |
|
871 |
|
872 TLogId DoAddEvent2TestRecentListL() |
|
873 { |
|
874 CLogClient* client = CLogClient::NewL(theFs); |
|
875 CleanupStack::PushL(client); |
|
876 CTestActive* active = new(ELeave)CTestActive(); |
|
877 CleanupStack::PushL(active); |
|
878 |
|
879 TLogId logId = DoAddEvent2TestRecentListL(*client, *active); |
|
880 |
|
881 CleanupStack::PopAndDestroy(active); |
|
882 CleanupStack::PopAndDestroy(client); |
|
883 |
|
884 return logId; |
|
885 } |
|
886 |
|
887 struct TLogViewTestObserver : public MLogViewChangeObserver |
|
888 { |
|
889 TLogViewTestObserver() : |
|
890 iIdAdded(-1), |
|
891 iIdChanged(-1), |
|
892 iIdDeleted(-1) |
|
893 { |
|
894 } |
|
895 virtual void HandleLogViewChangeEventAddedL(TLogId aId, TInt, TInt, TInt) |
|
896 { |
|
897 iIdAdded = aId; |
|
898 } |
|
899 virtual void HandleLogViewChangeEventChangedL(TLogId aId, TInt, TInt, TInt) |
|
900 { |
|
901 iIdChanged = aId; |
|
902 } |
|
903 virtual void HandleLogViewChangeEventDeletedL(TLogId aId, TInt, TInt, TInt) |
|
904 { |
|
905 iIdDeleted = aId; |
|
906 } |
|
907 TLogId iIdAdded; |
|
908 TLogId iIdChanged; |
|
909 TLogId iIdDeleted; |
|
910 }; |
|
911 |
|
912 void DoViewEventFromTestRecentListL(TLogId aId1, TLogId aId2) |
|
913 { |
|
914 CLogClient* client = CLogClient::NewL(theFs); |
|
915 CleanupStack::PushL(client); |
|
916 CTestActive* active = new(ELeave)CTestActive(); |
|
917 CleanupStack::PushL(active); |
|
918 CLogViewRecent* view = CLogViewRecent::NewL(*client); |
|
919 CleanupStack::PushL(view); |
|
920 TLogViewTestObserver observer; |
|
921 CLogViewDuplicate* duplicate = CLogViewDuplicate::NewL(*client, observer); |
|
922 CleanupStack::PushL(duplicate); |
|
923 |
|
924 TBool rc = view->SetRecentListL(KLogRctTListId, active->iStatus); |
|
925 active->StartL(); |
|
926 CActiveScheduler::Start(); |
|
927 TEST2(active->iStatus.Int(), KErrNone); |
|
928 |
|
929 TInt count = 0; |
|
930 if(view->FirstL(active->iStatus)) |
|
931 { |
|
932 do |
|
933 { |
|
934 active->StartL(); |
|
935 CActiveScheduler::Start(); |
|
936 TEST2(active->iStatus.Int(), KErrNone); |
|
937 const CLogEvent& e = view->Event(); |
|
938 TEST2(aId2, e.Id()); |
|
939 ++count; |
|
940 } |
|
941 while(view->NextL(active->iStatus)); |
|
942 } |
|
943 TEST2(count, 1);//The second event is a duplicate => not in the list |
|
944 |
|
945 //Check duplicates |
|
946 active->StartL(); |
|
947 rc = view->DuplicatesL(*duplicate, active->iStatus); |
|
948 TEST(rc); |
|
949 CActiveScheduler::Start(); |
|
950 TEST2(active->iStatus.Int(), KErrNone); |
|
951 TEST2(duplicate->CountL(), 1); |
|
952 |
|
953 //Test the duplicated event |
|
954 rc = duplicate->FirstL(active->iStatus); |
|
955 TEST(rc); |
|
956 active->StartL(); |
|
957 CActiveScheduler::Start(); |
|
958 TEST2(active->iStatus.Int(), KErrNone); |
|
959 const CLogEvent& e2 = duplicate->Event(); |
|
960 TEST2(aId1, e2.Id()); |
|
961 |
|
962 //Get the event |
|
963 CLogEvent* event = CLogEvent::NewL(); |
|
964 CleanupStack::PushL(event); |
|
965 event->SetId(aId1); |
|
966 active->StartL(); |
|
967 client->GetEvent(*event, active->iStatus); |
|
968 CActiveScheduler::Start(); |
|
969 TEST2(active->iStatus.Int(), KErrNone); |
|
970 |
|
971 //Change the event. The observer should register the change. |
|
972 event->SetDataL(_L8("123444555")); |
|
973 client->ChangeEvent(*event, active->iStatus); |
|
974 active->StartL(); |
|
975 CActiveScheduler::Start(); |
|
976 TEST2(active->iStatus.Int(), KErrNone); |
|
977 TEST2(observer.iIdChanged, event->Id()); |
|
978 |
|
979 //Add a new event to the recent list. This operation should be detected as a "delete" one by the observer |
|
980 //and the existing event should be cleared from the recent list. |
|
981 TLogId logId = DoAddEvent2TestRecentListL(*client, *active); |
|
982 TEST2(observer.iIdDeleted, aId1); |
|
983 TEST(logId != observer.iIdDeleted); |
|
984 //No added events detected by the observer |
|
985 TEST2(observer.iIdAdded, -1); |
|
986 |
|
987 //Cleanup |
|
988 CleanupStack::PopAndDestroy(event); |
|
989 CleanupStack::PopAndDestroy(duplicate); |
|
990 CleanupStack::PopAndDestroy(view); |
|
991 CleanupStack::PopAndDestroy(active); |
|
992 CleanupStack::PopAndDestroy(client); |
|
993 } |
|
994 |
|
995 /** |
|
996 @SYMTestCaseID PDS-LOGENG-UT-4035 |
|
997 @SYMTestCaseDesc Complex recent list test. |
|
998 The test works only if SYSLIBS_TEST macro is defined, in which case the server side will |
|
999 create a recent list with a lot of fields. |
|
1000 The test case will add 2 events with the same properties, such that both will be added |
|
1001 to that test recent list. Because the second event is a match of the first one and matches |
|
1002 the recent list "duplicates" mask, the second event will be marked as a duplicate of the |
|
1003 first one. After adding the events a view is used to check for their presence. |
|
1004 @SYMTestActions Complex recent list test. |
|
1005 @SYMTestExpectedResults Test must not fail |
|
1006 @SYMTestPriority Medium |
|
1007 @SYMREQ REQ12747 |
|
1008 */ |
|
1009 void ComplexRecentListTestL() |
|
1010 { |
|
1011 TLogId logId1 = DoAddEvent2TestRecentListL(); |
|
1012 TLogId logId2 = DoAddEvent2TestRecentListL(); |
|
1013 DoViewEventFromTestRecentListL(logId1, logId2); |
|
1014 } |
|
1015 |
|
1016 #endif//SYSLIBS_TEST |
|
1017 ////////////////////////////////////////////////////////////////////////////////////////////////////// |
|
1018 |
|
1019 void doTestsL() |
|
1020 { |
|
1021 TestUtils::DeleteDatabaseL(); |
|
1022 // |
|
1023 test.Start(_L("Preparation. Adding 200 events...")); |
|
1024 DoAddEventsL(); |
|
1025 test.Next(_L(" @SYMTestCaseID:PDS-LOGENG-UT-4029: AddEvent() server side OOM test when logged events count is max (200)")); |
|
1026 AddEventOomTestL(ELogOpAddEvent, KErrNone); |
|
1027 test.Next(_L(" @SYMTestCaseID:PDS-LOGENG-UT-4029: AddEvent() server side OOM test when logged events count is max (200). Invalid event type.")); |
|
1028 AddEventOomTestL(ELogOpAddEventInvalidType, KErrNotFound); |
|
1029 test.Next(_L(" @SYMTestCaseID:PDS-LOGENG-UT-4030: AddEvent() server side OOM test when logged events count is max (200). Logging disabled.")); |
|
1030 AddEventOomTestL(ELogOpAddEventLoggingDisabled, KErrNotSupported); |
|
1031 test.Next(_L(" @SYMTestCaseID:PDS-LOGENG-UT-4030: ChangeEvent() server side OOM test when logged events count is max (200). The event does exist.")); |
|
1032 ChangeEventOomTestL(ETrue); |
|
1033 test.Next(_L(" @SYMTestCaseID:PDS-LOGENG-UT-4030: ChangeEvent() server side OOM test when logged events count is max (200). The event does not exist.")); |
|
1034 ChangeEventOomTestL(EFalse); |
|
1035 test.Next(_L(" @SYMTestCaseID:PDS-LOGENG-UT-4032: GetEvent() server side OOM test when logged events count is max (200).")); |
|
1036 GetEventOomTestL(ELogOpGetEvent, KErrNone); |
|
1037 test.Next(_L(" @SYMTestCaseID:PDS-LOGENG-UT-4032: GetEvent() server side OOM test when logged events count is max (200). The event does not exist.")); |
|
1038 GetEventOomTestL(ELogOpGetEventNotExists, KErrNotFound); |
|
1039 test.Next(_L(" @SYMTestCaseID:PDS-LOGENG-UT-4032: GetEvent() server side OOM test when logged events count is max (200). The event id is 0.")); |
|
1040 GetEventOomTestL(ELogOpGetEventZeroId, KErrNotFound); |
|
1041 test.Next(_L(" @SYMTestCaseID:PDS-LOGENG-UT-4031: DeleteEvent() server side OOM test when logged events count is max (200). The event does exist.")); |
|
1042 DeleteEventOomTestL(ETrue); |
|
1043 test.Next(_L(" @SYMTestCaseID:PDS-LOGENG-UT-4031: DeleteEvent() server side OOM test when logged events count is max (200). The event does not exist.")); |
|
1044 DeleteEventOomTestL(EFalse); |
|
1045 test.Next(_L(" @SYMTestCaseID:PDS-LOGENG-UT-4033: Attempt to change one of the standard event types.")); |
|
1046 ChangeStandardEventTypeTestL(); |
|
1047 test.Next(_L(" @SYMTestCaseID:PDS-LOGENG-UT-4042: \"Cancel Operation\" test")); |
|
1048 CancelOperationTest(); |
|
1049 test.Next(_L(" @SYMTestCaseID:PDS-LOGENG-UT-4034: Complex filter set test.")); |
|
1050 ComplexFilterSetTestL(); |
|
1051 test.Next(_L(" @SYMTestCaseID:PDS-LOGENG-UT-4047: Check for updated configuration values")); |
|
1052 DoCheckUpdateConfigL(); |
|
1053 #ifdef SYSLIBS_TEST |
|
1054 test.Next(_L(" @SYMTestCaseID:PDS-LOGENG-UT-4035: Complex recent list test.")); |
|
1055 ComplexRecentListTestL(); |
|
1056 #endif |
|
1057 // |
|
1058 TestUtils::DeleteDatabaseL(); |
|
1059 } |