|
1 /* |
|
2 * Copyright (c) 2005 Nokia Corporation and/or its subsidiary(-ies). |
|
3 * All rights reserved. |
|
4 * This component and the accompanying materials are made available |
|
5 * under the terms of "Eclipse Public License v1.0" |
|
6 * which accompanies this distribution, and is available |
|
7 * at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
8 * |
|
9 * Initial Contributors: |
|
10 * Nokia Corporation - initial contribution. |
|
11 * |
|
12 * Contributors: |
|
13 * |
|
14 * Description: |
|
15 * ?description_line |
|
16 * |
|
17 */ |
|
18 |
|
19 |
|
20 // INCLUDES |
|
21 #include "FT_CPosTp77.h" |
|
22 #include <EPos_CPosLandmarkDatabase.h> |
|
23 |
|
24 // CONSTANTS |
|
25 // _LIT(KTp77Panic, "Timeout Panic"); |
|
26 const TInt KTp77PanicNumber = 77; |
|
27 |
|
28 // ================= LOCAL FUNCTIONS ======================= |
|
29 |
|
30 // --------------------------------------------------------- |
|
31 // LOCAL_C BadThreadFunction |
|
32 // |
|
33 // (other items were commented in a header). |
|
34 // --------------------------------------------------------- |
|
35 // |
|
36 LOCAL_C TInt BadClientThreadFunction(TAny* aData) |
|
37 { |
|
38 CTrapCleanup* cleanup = CTrapCleanup::New(); |
|
39 CActiveScheduler* actSch = new (ELeave) CActiveScheduler; |
|
40 CActiveScheduler::Install(actSch); |
|
41 |
|
42 TRAPD(err, CPosTp77::RunBadClientTestL(aData)); |
|
43 |
|
44 delete actSch; |
|
45 delete cleanup; |
|
46 return err; |
|
47 } |
|
48 |
|
49 // --------------------------------------------------------- |
|
50 // LOCAL_C KillerThreadFunction |
|
51 // |
|
52 // (other items were commented in a header). |
|
53 // --------------------------------------------------------- |
|
54 // |
|
55 LOCAL_C TInt KillerThreadFunction(TAny* aData) |
|
56 { |
|
57 CTrapCleanup* cleanup = CTrapCleanup::New(); |
|
58 CActiveScheduler* actSch = new (ELeave) CActiveScheduler; |
|
59 CActiveScheduler::Install(actSch); |
|
60 |
|
61 TRAPD(err, CPosTp77::RunThreadKillerL(aData)); |
|
62 |
|
63 delete actSch; |
|
64 delete cleanup; |
|
65 return err; |
|
66 } |
|
67 |
|
68 // ================= MEMBER FUNCTIONS ======================= |
|
69 |
|
70 // --------------------------------------------------------- |
|
71 // CPosTp77::GetName |
|
72 // |
|
73 // (other items were commented in a header). |
|
74 // --------------------------------------------------------- |
|
75 // |
|
76 void CPosTp77::GetName(TDes& aName) const |
|
77 { |
|
78 _LIT(KTestName, "TP77 - Bad server usage"); |
|
79 aName = KTestName; |
|
80 } |
|
81 |
|
82 // --------------------------------------------------------- |
|
83 // CPosTp77::InitTestL |
|
84 // |
|
85 // (other items were commented in a header). |
|
86 // --------------------------------------------------------- |
|
87 // |
|
88 void CPosTp77::InitTestL() |
|
89 { |
|
90 MakeSurePanicDebugFileExistsL(); |
|
91 } |
|
92 |
|
93 // --------------------------------------------------------- |
|
94 // CPosTp77::CloseTest |
|
95 // |
|
96 // (other items were commented in a header). |
|
97 // --------------------------------------------------------- |
|
98 // |
|
99 void CPosTp77::CloseTest() |
|
100 { |
|
101 iBadThread.Close(); |
|
102 } |
|
103 |
|
104 // --------------------------------------------------------- |
|
105 // CPosTp77::StartL |
|
106 // |
|
107 // (other items were commented in a header). |
|
108 // --------------------------------------------------------- |
|
109 // |
|
110 void CPosTp77::StartL() |
|
111 { |
|
112 // Test multiple Notify Db events |
|
113 iLog->Put(_L("1st part, testing multiple notify Db event")); |
|
114 iTestCase = ETestNotifyDbEvent; |
|
115 CPosLandmarkDatabase* db = InitDbLC(); |
|
116 iTimeToWait = 3000000; |
|
117 ResumeThreadsAndVerifyExitL(); |
|
118 TBool errors = VerifyThreadExitResultsL(KTp77PanicNumber); |
|
119 (errors) ? |
|
120 VerifyLmServerIsAliveL(db) : |
|
121 errors = VerifyLmServerIsAliveL(db); |
|
122 CleanupStack::PopAndDestroy(db); |
|
123 |
|
124 // Test non terminated single Notify Db event |
|
125 iLog->Put(_L("2nd part, testing non terminated sinlge notify Db event")); |
|
126 iTestCase = ETestNotifyDbEvent2; |
|
127 db = InitDbLC(); |
|
128 ResumeThreadsAndVerifyExitL(); |
|
129 (errors) ? |
|
130 VerifyThreadExitResultsL(0) : |
|
131 errors = VerifyThreadExitResultsL(0); |
|
132 (errors) ? |
|
133 VerifyLmServerIsAliveL(db) : |
|
134 errors = VerifyLmServerIsAliveL(db); |
|
135 CleanupStack::PopAndDestroy(db); |
|
136 |
|
137 // Test non terminated single InitializeL() |
|
138 iLog->Put(_L("3rd part, testing non terminated single Initialize db operations")); |
|
139 iTestCase = ETestInitialize; |
|
140 RemoveDefaultDbL(); |
|
141 db = CPosLandmarkDatabase::OpenL(); |
|
142 CleanupStack::PushL(db); |
|
143 ResumeThreadsAndVerifyExitL(); |
|
144 (errors) ? |
|
145 VerifyThreadExitResultsL(0) : |
|
146 errors = VerifyThreadExitResultsL(0); |
|
147 CPosLmOperation* initOp = db->InitializeL(); |
|
148 CleanupStack::PushL(initOp); |
|
149 TRAPD(err, initOp->ExecuteL()); |
|
150 if (err != KErrNone) |
|
151 { |
|
152 _LIT(KError, "Trying to initialize after badThread failed with %d"); |
|
153 iBuf.Format(KError, err); |
|
154 iLog->PutError(iBuf); |
|
155 errors = ETrue; |
|
156 } |
|
157 CleanupStack::PopAndDestroy(initOp); |
|
158 (errors) ? |
|
159 VerifyLmServerIsAliveL(db) : |
|
160 errors = VerifyLmServerIsAliveL(db); |
|
161 CleanupStack::PopAndDestroy(db); |
|
162 |
|
163 // Test non terminated multiple InitializeL() |
|
164 iLog->Put(_L("4th part, testing non terminated multiple Initialize db operations")); |
|
165 iTestCase = ETestInitialize2; |
|
166 RemoveDefaultDbL(); |
|
167 db = CPosLandmarkDatabase::OpenL(); |
|
168 CleanupStack::PushL(db); |
|
169 ResumeThreadsAndVerifyExitL(); |
|
170 (errors) ? |
|
171 VerifyThreadExitResultsL(0) : |
|
172 errors = VerifyThreadExitResultsL(0); |
|
173 initOp = db->InitializeL(); |
|
174 CleanupStack::PushL(initOp); |
|
175 TRAP(err, initOp->ExecuteL()); |
|
176 if (err != KErrNone) |
|
177 { |
|
178 _LIT(KError, "Trying to initialize after badThread failed with %d"); |
|
179 iBuf.Format(KError, err); |
|
180 iLog->PutError(iBuf); |
|
181 errors = ETrue; |
|
182 } |
|
183 CleanupStack::PopAndDestroy(initOp); |
|
184 (errors) ? |
|
185 VerifyLmServerIsAliveL(db) : |
|
186 errors = VerifyLmServerIsAliveL(db); |
|
187 CleanupStack::PopAndDestroy(db); |
|
188 |
|
189 // Test write lock on non terminated import operation |
|
190 iLog->Put(_L("5th part, testing write lock on non terminated import operation")); |
|
191 iTestCase = ETestWriteLock; |
|
192 db = UseGeneratedDbFileL(); |
|
193 CleanupStack::PushL(db); |
|
194 ResumeThreadsAndVerifyExitL(); |
|
195 (errors) ? |
|
196 VerifyThreadExitResultsL(0) : |
|
197 errors = VerifyThreadExitResultsL(0); |
|
198 (errors) ? |
|
199 VerifyLmServerIsAliveL(db) : |
|
200 errors = VerifyLmServerIsAliveL(db); |
|
201 CleanupStack::PopAndDestroy(db); |
|
202 |
|
203 // The test below should be successful. This is the case on WINS but not in THUMB. On |
|
204 // THUMB it runs for a while and then fails with KErrNoMemory. A duration test is needed! |
|
205 /* |
|
206 // Test RegisterUri (executed during OpenL()) |
|
207 iLog->Put(_L("2nd part, testing registering URI...")); |
|
208 iTestCase = ETestRegisterUri; |
|
209 db = InitDbLC(); |
|
210 |
|
211 TBool ready = EFalse; |
|
212 TInt diff; |
|
213 iTimeToWait = 3000000; |
|
214 while (!ready) |
|
215 { |
|
216 diff = iTimeToWait.Int() - iLastTimeToWait.Int(); |
|
217 iLastTimeToWait = iTimeToWait; |
|
218 ResumeThreadsAndVerifyExitL(); |
|
219 VerifyLmServerIsAliveL(db); |
|
220 if (iBadThreadExitReason == KTp77PanicNumber && |
|
221 iBadThreadExitType == EExitKill) |
|
222 { |
|
223 // Increase iTimeToWait |
|
224 iTimeToWait = iTimeToWait.Int() + Abs(diff / 2); |
|
225 } |
|
226 else if (iBadThreadExitReason == 0 && |
|
227 iBadThreadExitType == EExitKill) |
|
228 { |
|
229 // Decrease iTimeToWait |
|
230 iTimeToWait = iTimeToWait.Int() - Abs(diff / 2); |
|
231 } |
|
232 else |
|
233 { |
|
234 LogErrorAndLeave(_L("Got unexpected exit code from badThread")); |
|
235 } |
|
236 ready = iTimeToWait == iLastTimeToWait; |
|
237 } |
|
238 iBuf.Format(_L("Estimated critical code after %d microseconds"), iTimeToWait.Int()); |
|
239 iLog->Put(buf); |
|
240 |
|
241 // Execute vulnarable code |
|
242 iTimeToWait = iTimeToWait.Int() - 3000; |
|
243 diff = 20; |
|
244 ready = EFalse; |
|
245 TInt i = 0; |
|
246 while (!ready) |
|
247 { |
|
248 iTimeToWait = iTimeToWait.Int() + diff; |
|
249 ResumeThreadsAndVerifyExitL(); |
|
250 VerifyLmServerIsAliveL(db); |
|
251 ready = iBadThreadExitReason != KTp77PanicNumber; |
|
252 i++; |
|
253 } |
|
254 |
|
255 buf.Format(_L("Tested %d loops"), i); |
|
256 iLog->Put(buf); |
|
257 |
|
258 CleanupStack::PopAndDestroy(db);*/ |
|
259 |
|
260 if (errors) |
|
261 { |
|
262 User::Leave(KErrGeneral); |
|
263 } |
|
264 } |
|
265 |
|
266 // --------------------------------------------------------- |
|
267 // CPosTp77::InitDbLC |
|
268 // |
|
269 // (other items were commented in a header). |
|
270 // --------------------------------------------------------- |
|
271 // |
|
272 CPosLandmarkDatabase* CPosTp77::InitDbLC() |
|
273 { |
|
274 RemoveDefaultDbL(); |
|
275 CPosLandmarkDatabase* database = CPosLandmarkDatabase::OpenL(); |
|
276 CleanupStack::PushL(database); |
|
277 |
|
278 if (database->IsInitializingNeeded()) |
|
279 { |
|
280 ExecuteAndDeleteLD(database->InitializeL()); |
|
281 } |
|
282 |
|
283 return database; |
|
284 } |
|
285 |
|
286 // --------------------------------------------------------- |
|
287 // CPosTp77::RunBadClientTestL |
|
288 // |
|
289 // (other items were commented in a header). |
|
290 // --------------------------------------------------------- |
|
291 // |
|
292 void CPosTp77::RunBadClientTestL(TAny* aData) |
|
293 { |
|
294 CPosTp77* tp77 = reinterpret_cast <CPosTp77*> (aData); |
|
295 switch (tp77->iTestCase) |
|
296 { |
|
297 case ETestNotifyDbEvent: |
|
298 { |
|
299 TPosLmEvent event1, event2, event3, event4, event5; |
|
300 TRequestStatus status1 = KErrNone; |
|
301 TRequestStatus status2 = KErrNone; |
|
302 TRequestStatus status3 = KErrNone; |
|
303 TRequestStatus status4 = KErrNone; |
|
304 TRequestStatus status5 = KErrNone; |
|
305 TRequestStatus status[5] = {status1, status2, status3, status4, status5}; |
|
306 |
|
307 CPosLandmarkDatabase* db1 = CPosLandmarkDatabase::OpenL(); |
|
308 CleanupStack::PushL(db1); |
|
309 CPosLandmarkDatabase* db2 = CPosLandmarkDatabase::OpenL(); |
|
310 CleanupStack::PushL(db2); |
|
311 CPosLandmarkDatabase* db3 = CPosLandmarkDatabase::OpenL(); |
|
312 CleanupStack::PushL(db3); |
|
313 CPosLandmarkDatabase* db4 = CPosLandmarkDatabase::OpenL(); |
|
314 CleanupStack::PushL(db4); |
|
315 CPosLandmarkDatabase* db5 = CPosLandmarkDatabase::OpenL(); |
|
316 CleanupStack::PushL(db5); |
|
317 |
|
318 db1->NotifyDatabaseEvent(event1, status[0]); |
|
319 db2->NotifyDatabaseEvent(event2, status[1]); |
|
320 db3->NotifyDatabaseEvent(event3, status[2]); |
|
321 db4->NotifyDatabaseEvent(event4, status[3]); |
|
322 db5->NotifyDatabaseEvent(event5, status[4]); |
|
323 |
|
324 for (TInt i = 0; i < 5; i++) |
|
325 { |
|
326 User::WaitForRequest(status[i]); |
|
327 } |
|
328 |
|
329 CleanupStack::PopAndDestroy(5, db1); |
|
330 } |
|
331 break; |
|
332 |
|
333 case ETestNotifyDbEvent2: |
|
334 { |
|
335 CPosLandmarkDatabase* db1 = CPosLandmarkDatabase::OpenL(); |
|
336 |
|
337 // Observe events |
|
338 TPosLmEvent event1; |
|
339 TRequestStatus status1; |
|
340 db1->NotifyDatabaseEvent(event1, status1); |
|
341 } |
|
342 break; |
|
343 |
|
344 case ETestInitialize: |
|
345 { |
|
346 CPosLandmarkDatabase* db = CPosLandmarkDatabase::OpenL(); |
|
347 |
|
348 // Start to initialize db |
|
349 CPosLmOperation* op = db->InitializeL(); |
|
350 TRequestStatus status; |
|
351 TReal32 progress; |
|
352 op->NextStep(status, progress); |
|
353 } |
|
354 break; |
|
355 |
|
356 case ETestInitialize2: |
|
357 { |
|
358 TRequestStatus status1, status2, status3, status4, status5; |
|
359 TReal32 progress1, progress2, progress3, progress4, progress5; |
|
360 CPosLandmarkDatabase* db1 = CPosLandmarkDatabase::OpenL(); |
|
361 CPosLandmarkDatabase* db2 = CPosLandmarkDatabase::OpenL(); |
|
362 CPosLandmarkDatabase* db3 = CPosLandmarkDatabase::OpenL(); |
|
363 CPosLandmarkDatabase* db4 = CPosLandmarkDatabase::OpenL(); |
|
364 CPosLandmarkDatabase* db5 = CPosLandmarkDatabase::OpenL(); |
|
365 |
|
366 // Start to initialize db |
|
367 CPosLmOperation* op1 = db1->InitializeL(); |
|
368 CPosLmOperation* op2 = db2->InitializeL(); |
|
369 CPosLmOperation* op3 = db3->InitializeL(); |
|
370 CPosLmOperation* op4 = db4->InitializeL(); |
|
371 CPosLmOperation* op5 = db5->InitializeL(); |
|
372 op1->NextStep(status1, progress1); |
|
373 op2->NextStep(status2, progress2); |
|
374 op3->NextStep(status3, progress3); |
|
375 op4->NextStep(status4, progress4); |
|
376 op5->NextStep(status5, progress5); |
|
377 } |
|
378 break; |
|
379 |
|
380 case ETestWriteLock: |
|
381 { |
|
382 CPosLandmarkDatabase* db = CPosLandmarkDatabase::OpenL(); |
|
383 CleanupStack::PushL(db); |
|
384 CPosLmOperation* removeOp = db->RemoveAllLandmarksL(); |
|
385 TReal32 progress(0); |
|
386 TRequestStatus status; |
|
387 while (progress < 0.4) |
|
388 { |
|
389 removeOp->NextStep(status, progress); |
|
390 User::WaitForRequest(status); |
|
391 } |
|
392 CleanupStack::Pop(db); |
|
393 } |
|
394 break; |
|
395 |
|
396 case ETestRegisterUri: |
|
397 { |
|
398 CPosLandmarkDatabase* db1 = CPosLandmarkDatabase::OpenL(); |
|
399 delete db1; |
|
400 } |
|
401 break; |
|
402 |
|
403 }; |
|
404 } |
|
405 |
|
406 // --------------------------------------------------------- |
|
407 // CPosTp77::RunThreadKillerL |
|
408 // |
|
409 // (other items were commented in a header). |
|
410 // --------------------------------------------------------- |
|
411 // |
|
412 void CPosTp77::RunThreadKillerL(TAny* aData) |
|
413 { |
|
414 CPosTp77* tp77 = reinterpret_cast <CPosTp77*>(aData); |
|
415 |
|
416 // Enter a infinite loop. This reason to this is that I want to be sure |
|
417 // that it is killed by the TP77-thread. |
|
418 TBool forever = ETrue; |
|
419 while (forever) |
|
420 { |
|
421 // Panic badThread if it is still alive |
|
422 if (tp77->iBadThread.ExitType() == EExitPending) |
|
423 { |
|
424 TRequestStatus status; |
|
425 tp77->iBadThread.Logon(status); |
|
426 |
|
427 switch (tp77->iTestCase) |
|
428 { |
|
429 case ETestNotifyDbEvent: |
|
430 { |
|
431 // Make sure that the badThread has started 5 observers of db events |
|
432 User::After(tp77->iTimeToWait); |
|
433 |
|
434 // Generate db event |
|
435 CPosLandmarkDatabase* db = CPosLandmarkDatabase::OpenL(); |
|
436 CleanupStack::PushL(db); |
|
437 CPosLandmark* lm = CPosLandmark::NewLC(); |
|
438 db->AddLandmarkL(*lm); |
|
439 |
|
440 // Kill Event observing thread |
|
441 tp77->iBadThread.Kill(KTp77PanicNumber); |
|
442 User::WaitForRequest(status); |
|
443 |
|
444 CleanupStack::PopAndDestroy(2, db); |
|
445 } |
|
446 break; |
|
447 |
|
448 case ETestNotifyDbEvent2: |
|
449 case ETestInitialize: |
|
450 case ETestInitialize2: |
|
451 case ETestWriteLock: |
|
452 { |
|
453 // Do nothing |
|
454 User::LeaveIfError(tp77->iBadThread.LogonCancel(status)); |
|
455 forever = EFalse; |
|
456 } |
|
457 break; |
|
458 |
|
459 case ETestRegisterUri: |
|
460 { |
|
461 User::After(tp77->iTimeToWait); |
|
462 |
|
463 // Kill Event observing thread |
|
464 tp77->iBadThread.Kill(KTp77PanicNumber); |
|
465 User::WaitForRequest(status); |
|
466 } |
|
467 break; |
|
468 |
|
469 }; |
|
470 } |
|
471 else |
|
472 { |
|
473 forever = EFalse; |
|
474 } |
|
475 } |
|
476 } |
|
477 |
|
478 // --------------------------------------------------------- |
|
479 // CPosTp77::ResumeThreadsAndVerifyExitL |
|
480 // |
|
481 // (other items were commented in a header). |
|
482 // --------------------------------------------------------- |
|
483 // |
|
484 void CPosTp77::ResumeThreadsAndVerifyExitL() |
|
485 { |
|
486 _LIT(KCreateThreadErr, "Creating thread failed with %d"); |
|
487 |
|
488 // Create bad thread |
|
489 _LIT(KBadThreadName, "TP77 - Bad thread"); |
|
490 iBadThread.Close(); |
|
491 TInt err = iBadThread.Create(KBadThreadName, BadClientThreadFunction, |
|
492 KDefaultStackSize, KMinHeapSize, KMaxHeapSize, this); |
|
493 AssertTrueSecL(err == KErrNone, KCreateThreadErr, err); |
|
494 |
|
495 // Create killer thread |
|
496 RThread killerThread; |
|
497 CleanupClosePushL(killerThread); |
|
498 _LIT(KKillerThreadName, "TP77 - Killer thread"); |
|
499 err = killerThread.Create(KKillerThreadName, KillerThreadFunction, |
|
500 KDefaultStackSize, KMinHeapSize, KMaxHeapSize, this); |
|
501 AssertTrueSecL(err == KErrNone, KCreateThreadErr, err); |
|
502 |
|
503 // Start threads and wait until either of them exits. |
|
504 TRequestStatus badThreadStatus, killerThreadStatus; |
|
505 iBadThread.Logon(badThreadStatus); |
|
506 iBadThread.Resume(); |
|
507 killerThread.Logon(killerThreadStatus); |
|
508 killerThread.Resume(); |
|
509 User::WaitForRequest(badThreadStatus); |
|
510 User::WaitForRequest(killerThreadStatus); |
|
511 |
|
512 // Fetch exit data |
|
513 iBadThreadExitType = iBadThread.ExitType(); |
|
514 iBadThreadExitCategory = iBadThread.ExitCategory(); |
|
515 iBadThreadExitReason = iBadThread.ExitReason(); |
|
516 iKillerThreadExitType = killerThread.ExitType(); |
|
517 iKillerThreadExitCategory = killerThread.ExitCategory(); |
|
518 iKillerThreadExitReason = killerThread.ExitReason(); |
|
519 |
|
520 // Log threads' exit results |
|
521 iBuf.Format( |
|
522 _L("BadThread ended with exit type: %d, exit reason: %d, exit category: %S"), |
|
523 iBadThreadExitType, iBadThreadExitReason, &iBadThreadExitCategory); |
|
524 // iLog->Put(buf); |
|
525 iBuf.Format( |
|
526 _L("KillerThread ended with exit type: %d, exit reason: %d, exit category: %S"), |
|
527 iKillerThreadExitType, iKillerThreadExitReason, &iKillerThreadExitCategory); |
|
528 // iLog->Put(buf); |
|
529 |
|
530 CleanupStack::PopAndDestroy(&killerThread); |
|
531 } |
|
532 |
|
533 // --------------------------------------------------------- |
|
534 // CPosTp77::VerifyThreadExitResultsL |
|
535 // |
|
536 // (other items were commented in a header). |
|
537 // --------------------------------------------------------- |
|
538 // |
|
539 TBool CPosTp77::VerifyThreadExitResultsL(TInt aBadThreadExitReason) |
|
540 { |
|
541 TBool error = EFalse; |
|
542 _LIT(KKillCategory, "Kill"); |
|
543 |
|
544 if (iBadThreadExitType != EExitKill) |
|
545 { |
|
546 _LIT(KExitTypeErr, "BadThread was not killed as expected."); |
|
547 iLog->PutError(KExitTypeErr); |
|
548 error = ETrue; |
|
549 } |
|
550 if (iBadThreadExitCategory != KKillCategory) |
|
551 { |
|
552 _LIT(KPanicErr, "BadThread had unexpected exit category"); |
|
553 iLog->PutError(KPanicErr); |
|
554 error = ETrue; |
|
555 } |
|
556 if (iBadThreadExitReason != aBadThreadExitReason) |
|
557 { |
|
558 _LIT(KPanicCodeErr, "BadThread had unexpected exit reason"); |
|
559 iLog->PutError(KPanicCodeErr); |
|
560 error = ETrue; |
|
561 } |
|
562 if (iKillerThreadExitType != EExitKill) |
|
563 { |
|
564 _LIT(KExitTypeErr, "KillerThread was not killed as expected."); |
|
565 iLog->PutError(KExitTypeErr); |
|
566 error = ETrue; |
|
567 } |
|
568 if (iKillerThreadExitCategory != KKillCategory) |
|
569 { |
|
570 _LIT(KPanicErr, "KillerThread had unexpected exit category"); |
|
571 iLog->PutError(KPanicErr); |
|
572 error = ETrue; |
|
573 } |
|
574 if (iKillerThreadExitReason != 0) |
|
575 { |
|
576 _LIT(KPanicCodeErr, "KillerThread had unexpected exit reason"); |
|
577 iLog->PutError(KPanicCodeErr); |
|
578 error = ETrue; |
|
579 } |
|
580 |
|
581 return error; |
|
582 } |
|
583 |
|
584 // --------------------------------------------------------- |
|
585 // CPosTp77::VerifyLmServerIsAliveL |
|
586 // |
|
587 // (other items were commented in a header). |
|
588 // --------------------------------------------------------- |
|
589 // |
|
590 TBool CPosTp77::VerifyLmServerIsAliveL(CPosLandmarkDatabase* aDb) |
|
591 { |
|
592 TRAPD(err, aDb->RemoveLandmarkL(1)); |
|
593 TBool errorExists = err != KErrNone && err != KErrNotFound; |
|
594 if (errorExists) |
|
595 { |
|
596 _LIT(KError, "Unable to use db instance. Using db failed with %d."); |
|
597 iBuf.Format(KError, err); |
|
598 iLog->PutError(iBuf); |
|
599 } |
|
600 |
|
601 return errorExists; |
|
602 } |
|
603 |
|
604 // End of File |