|
1 // Copyright (c) 2005-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 // Example CTestStep derived implementation |
|
15 // |
|
16 // |
|
17 |
|
18 /** |
|
19 @file CriteriaClassesStep.cpp |
|
20 @internalTechnology |
|
21 */ |
|
22 #include "criteriaclassesstep.h" |
|
23 #include "te_lbsapisuitedefs.h" |
|
24 |
|
25 #include "lcfsbucommondefinitions.h" |
|
26 |
|
27 #include <lbs.h> |
|
28 #include <lbssatellite.h> |
|
29 |
|
30 |
|
31 CCriteriaClassesStep::~CCriteriaClassesStep() |
|
32 /** |
|
33 * Destructor |
|
34 */ |
|
35 { |
|
36 } |
|
37 |
|
38 CCriteriaClassesStep::CCriteriaClassesStep() |
|
39 /** |
|
40 * Constructor |
|
41 */ |
|
42 { |
|
43 // **MUST** call SetTestStepName in the constructor as the controlling |
|
44 // framework uses the test step name immediately following construction to set |
|
45 // up the step's unique logging ID. |
|
46 SetTestStepName(KCriteriaClassesStep); |
|
47 } |
|
48 |
|
49 TVerdict CCriteriaClassesStep::doTestStepPreambleL() |
|
50 /** |
|
51 * @return - TVerdict code |
|
52 * Override of base class virtual |
|
53 */ |
|
54 { |
|
55 CTe_LbsApiSuiteStepBase::doTestStepPreambleL(); |
|
56 if (TestStepResult()!=EPass) |
|
57 return TestStepResult(); |
|
58 // process some pre setting to this test step then set SetTestStepResult to EFail or Epass. |
|
59 SetTestStepResult(EPass); |
|
60 return TestStepResult(); |
|
61 } |
|
62 |
|
63 |
|
64 TVerdict CCriteriaClassesStep::doTestStepL() |
|
65 /** |
|
66 * @return - TVerdict code |
|
67 * Override of base class pure virtual |
|
68 * Our implementation only gets called if the base class doTestStepPreambleL() did |
|
69 * not leave. That being the case, the current test result value will be EPass. |
|
70 */ |
|
71 { |
|
72 if (TestStepResult()==EPass) |
|
73 { |
|
74 TInt test; |
|
75 if(!GetIntFromConfig(ConfigSection(),KTe_LbsApiSuiteInt,test) |
|
76 ) |
|
77 { |
|
78 // Leave if there's any error. |
|
79 User::Leave(KErrNotFound); |
|
80 } |
|
81 SetTestStepResult(EPass); |
|
82 StartL(test); |
|
83 } |
|
84 return TestStepResult(); |
|
85 } |
|
86 |
|
87 |
|
88 |
|
89 TVerdict CCriteriaClassesStep::doTestStepPostambleL() |
|
90 /** |
|
91 * @return - TVerdict code |
|
92 * Override of base class virtual |
|
93 */ |
|
94 { |
|
95 // process something post setting to the test step |
|
96 // uncomment the following line if you have common post setting to all the test steps in there |
|
97 // CTe_LbsApiSuiteStepBase::doTestStepPostambleL(); |
|
98 // uncomment the following line if you have post process or remove the following line if no post process |
|
99 // SetTestStepResult(EPass); // or EFail |
|
100 return TestStepResult(); |
|
101 } |
|
102 |
|
103 void CCriteriaClassesStep::StartL(TInt aIndex) |
|
104 { |
|
105 switch(aIndex) |
|
106 { |
|
107 case 0: |
|
108 TPositionSelectionOrder_ConstructionL(); |
|
109 break; |
|
110 case 1: |
|
111 TPositionSelectionOrder_SetL(); |
|
112 break; |
|
113 case 2: |
|
114 TPositionSelectionOrder_ClearL(); |
|
115 break; |
|
116 case 3: |
|
117 TPositionSelectionOrder_NumSelectionItemsL(); |
|
118 break; |
|
119 case 4: |
|
120 TPositionCriteria_ConstructionL(); |
|
121 break; |
|
122 case 5: |
|
123 TPositionCriteria_SetL(); |
|
124 break; |
|
125 case 6: |
|
126 TPositionCriteria_ResetAndClearL(); |
|
127 break; |
|
128 default: |
|
129 break; |
|
130 } |
|
131 } |
|
132 |
|
133 |
|
134 |
|
135 |
|
136 |
|
137 #define ARRAYLENGTH(aArray) (static_cast<TInt>((sizeof(aArray) / sizeof(aArray[0])))) |
|
138 |
|
139 // |
|
140 // Constant test values used in many tests |
|
141 // |
|
142 const TPositionSelectionOrder::TOrder KTestOrders[] = |
|
143 { |
|
144 TPositionSelectionOrder::EOrderVeryLow, |
|
145 TPositionSelectionOrder::EOrderLow, |
|
146 TPositionSelectionOrder::EOrderFairlyLow, |
|
147 TPositionSelectionOrder::EOrderMedium, |
|
148 TPositionSelectionOrder::EOrderFairlyHigh, |
|
149 TPositionSelectionOrder::EOrderHigh, |
|
150 TPositionSelectionOrder::EOrderVeryHigh |
|
151 }; |
|
152 |
|
153 const TPositionSelectionOrder::TField KTestFields[] = |
|
154 { |
|
155 TPositionSelectionOrder::EFieldTimeToFirstFix, |
|
156 TPositionSelectionOrder::EFieldTimeToNextFix, |
|
157 TPositionSelectionOrder::EFieldHorizontalAccuracy, |
|
158 TPositionSelectionOrder::EFieldVerticalAccuracy, |
|
159 TPositionSelectionOrder::EFieldCost, |
|
160 TPositionSelectionOrder::EFieldPower |
|
161 }; |
|
162 |
|
163 typedef TInt (TPositionSelectionOrder::*SetterFuncTYPE)(TPositionSelectionOrder::TOrder); |
|
164 |
|
165 // WARNING: The order of these must match the order of the KTestFields |
|
166 // array declared above. |
|
167 const SetterFuncTYPE KSetterFunctions[] = |
|
168 { |
|
169 &TPositionSelectionOrder::SetOrderTimeToFirstFix, |
|
170 &TPositionSelectionOrder::SetOrderTimeToNextFix, |
|
171 &TPositionSelectionOrder::SetOrderHorizontalAccuracy, |
|
172 &TPositionSelectionOrder::SetOrderVerticalAccuracy, |
|
173 &TPositionSelectionOrder::SetOrderCostIndicator, |
|
174 &TPositionSelectionOrder::SetOrderPowerConsumption |
|
175 }; |
|
176 |
|
177 // |
|
178 // Constants that reflect the API design |
|
179 // |
|
180 #define NUM_SELECTION_CRITERIA (TUint(ARRAYLENGTH(KSetterFunctions))) |
|
181 |
|
182 #define DEFAULT_CRITERIA_MANDATORY_CAPABILITIES (static_cast<TPositionModuleInfo::TCapabilities>(TPositionModuleInfo::ECapabilityHorizontal)) |
|
183 |
|
184 |
|
185 // |
|
186 // Utility function prototypes |
|
187 // |
|
188 |
|
189 TBool IsNewlyConstructed(const TPositionSelectionOrder& aSelOrder); |
|
190 TBool IsNewlyConstructed(const TPositionQuality& aPosQuality); |
|
191 TBool AreEqualL(const TPositionSelectionOrder& aLhs, const TPositionSelectionOrder& aRhs); |
|
192 TBool AreEqualL(const TPositionQuality& aLhs, const TPositionQuality& aRhs); |
|
193 |
|
194 // |
|
195 // |
|
196 // Position Criteria classes |
|
197 // |
|
198 // |
|
199 |
|
200 // 5.2.1. Construction |
|
201 void CCriteriaClassesStep::TPositionSelectionOrder_ConstructionL() |
|
202 { |
|
203 DECLARE_ERROR_LOGGING; |
|
204 StandardPrepareL(); |
|
205 |
|
206 TPositionSelectionOrder selOrder; |
|
207 CHECK( IsNewlyConstructed(selOrder)); |
|
208 |
|
209 StandardCleanup(); |
|
210 } |
|
211 |
|
212 // 5.2.2. Set/Get |
|
213 void CCriteriaClassesStep::TPositionSelectionOrder_SetL() |
|
214 { |
|
215 DECLARE_ERROR_LOGGING; |
|
216 StandardPrepareL(); |
|
217 |
|
218 __UHEAP_MARK; |
|
219 |
|
220 for (TInt i=0; i<ARRAYLENGTH(KTestOrders); i++) |
|
221 { |
|
222 for (TInt j=0; j<ARRAYLENGTH(KSetterFunctions); j++) |
|
223 { |
|
224 TPositionSelectionOrder selOrder; |
|
225 selOrder.ClearSelectionOrder(); |
|
226 |
|
227 // Set field priority |
|
228 SetterFuncTYPE setterFunction = KSetterFunctions[j]; |
|
229 CHECK_EQUAL_( KErrNone, (selOrder.*setterFunction)(KTestOrders[i])); |
|
230 |
|
231 // Get & check field priority |
|
232 TPositionSelectionOrder::TField field; |
|
233 TPositionSelectionOrder::TOrder order; |
|
234 |
|
235 CHECK_EQUAL_( KErrNone, selOrder.GetSelectionItem(j, field, order)); |
|
236 CHECK_EQUAL_( KTestFields[j], field); |
|
237 CHECK_EQUAL_( KTestOrders[i], order); |
|
238 } |
|
239 } |
|
240 |
|
241 __UHEAP_MARKEND; |
|
242 |
|
243 StandardCleanup(); |
|
244 } |
|
245 |
|
246 // 5.2.3. Clear & Reset |
|
247 void CCriteriaClassesStep::TPositionSelectionOrder_ClearL() |
|
248 { |
|
249 DECLARE_ERROR_LOGGING; |
|
250 StandardPrepareL(); |
|
251 |
|
252 TPositionSelectionOrder selOrder; |
|
253 TPositionSelectionOrder::TField field; |
|
254 TPositionSelectionOrder::TOrder order; |
|
255 |
|
256 selOrder.ClearSelectionOrder(); |
|
257 |
|
258 CHECK_EQUAL_( TUint(0), selOrder.NumSelectionItems()); |
|
259 |
|
260 selOrder.ResetSelectionOrder(); |
|
261 |
|
262 CHECK_EQUAL_( 2, selOrder.NumSelectionItems()); |
|
263 |
|
264 for (TInt i=0; i<ARRAYLENGTH(KTestFields); i++) |
|
265 { |
|
266 CHECK_EQUAL_( KErrNone, selOrder.GetSelectionItem(i, field, order)); |
|
267 if(i == TPositionSelectionOrder::EFieldHorizontalAccuracy) |
|
268 { |
|
269 CHECK_EQUAL_( TPositionSelectionOrder::EOrderHigh, order); |
|
270 } |
|
271 else if(i == TPositionSelectionOrder::EFieldCost) |
|
272 { |
|
273 CHECK_EQUAL_( TPositionSelectionOrder::EOrderMedium, order); |
|
274 } |
|
275 else |
|
276 { |
|
277 CHECK_EQUAL_(0, field); |
|
278 CHECK_EQUAL_( TPositionSelectionOrder::EOrderDontCare, order); |
|
279 } |
|
280 |
|
281 } |
|
282 |
|
283 StandardCleanup(); |
|
284 } |
|
285 |
|
286 // 5.2.5. NumSelectionItems |
|
287 void CCriteriaClassesStep::TPositionSelectionOrder_NumSelectionItemsL() |
|
288 { |
|
289 DECLARE_ERROR_LOGGING; |
|
290 StandardPrepareL(); |
|
291 |
|
292 TPositionSelectionOrder selOrder; |
|
293 selOrder.ClearSelectionOrder(); |
|
294 |
|
295 TInt i; |
|
296 for (i=0; i<ARRAYLENGTH(KSetterFunctions); i++) |
|
297 { |
|
298 SetterFuncTYPE setterFunction = KSetterFunctions[i]; |
|
299 CHECK_EQUAL_( KErrNone, (selOrder.*setterFunction)(KTestOrders[i])); |
|
300 CHECK_EQUAL_( TUint(i), selOrder.NumSelectionItems()); |
|
301 } |
|
302 |
|
303 for (i=0; i<ARRAYLENGTH(KSetterFunctions); i++) |
|
304 { |
|
305 SetterFuncTYPE setterFunction = KSetterFunctions[i]; |
|
306 CHECK_EQUAL_( KErrNone, (selOrder.*setterFunction)(KTestOrders[i])); |
|
307 CHECK_EQUAL_( (TUint(ARRAYLENGTH(KTestFields))-1), selOrder.NumSelectionItems()); |
|
308 } |
|
309 |
|
310 StandardCleanup(); |
|
311 } |
|
312 |
|
313 // |
|
314 // |
|
315 // TPositionCriteria |
|
316 // |
|
317 // |
|
318 |
|
319 // 5.1.1. Construction |
|
320 void CCriteriaClassesStep::TPositionCriteria_ConstructionL() |
|
321 { |
|
322 DECLARE_ERROR_LOGGING; |
|
323 StandardPrepareL(); |
|
324 |
|
325 // Blank Constructor |
|
326 TPositionCriteria blankCriteria; |
|
327 |
|
328 // Check the required caps are blank |
|
329 CHECK_EQUAL_( |
|
330 DEFAULT_CRITERIA_MANDATORY_CAPABILITIES, |
|
331 blankCriteria.RequiredCapabilities() |
|
332 ); |
|
333 |
|
334 // Check the TPositionSelectionOrder component is blank / newly constructed |
|
335 TPositionSelectionOrder selOrder; |
|
336 blankCriteria.GetSelectionOrder(selOrder); |
|
337 CHECK( IsNewlyConstructed(selOrder)); |
|
338 |
|
339 // Check the position quality is blank |
|
340 TPositionQuality posQuality; |
|
341 blankCriteria.GetRequiredQuality(posQuality); |
|
342 CHECK( IsNewlyConstructed(posQuality)); |
|
343 |
|
344 // Capabilities Constructor |
|
345 const TPositionModuleInfo::TCapabilities KCaps = |
|
346 TPositionModuleInfo::ECapabilityHorizontal | |
|
347 TPositionModuleInfo::ECapabilityVertical | |
|
348 TPositionModuleInfo::ECapabilityDirection | |
|
349 TPositionModuleInfo::ECapabilityCompass; |
|
350 |
|
351 TPositionCriteria criteria(KCaps); |
|
352 |
|
353 // Check the required caps are blank |
|
354 CHECK_EQUAL_( KCaps, criteria.RequiredCapabilities()); |
|
355 |
|
356 // Check the TPositionSelectionOrder component is blank / newly constructed |
|
357 TPositionSelectionOrder selOrder2; |
|
358 criteria.GetSelectionOrder(selOrder2); |
|
359 CHECK( IsNewlyConstructed(selOrder2)); |
|
360 |
|
361 // Check the position quality is blank |
|
362 TPositionQuality posQuality2; |
|
363 criteria.GetRequiredQuality(posQuality2); |
|
364 CHECK( IsNewlyConstructed(posQuality2)); |
|
365 |
|
366 StandardCleanup(); |
|
367 } |
|
368 |
|
369 // 5.1.2. Get/Set properties |
|
370 void CCriteriaClassesStep::TPositionCriteria_SetL() |
|
371 { |
|
372 DECLARE_ERROR_LOGGING; |
|
373 StandardPrepareL(); |
|
374 |
|
375 TPositionCriteria criteria; |
|
376 |
|
377 // selction order |
|
378 TPositionSelectionOrder order, order2; |
|
379 |
|
380 CHECK_EQUAL_(KErrNone, order.SetOrderTimeToFirstFix(TPositionSelectionOrder::EOrderLow)); |
|
381 CHECK_EQUAL_(KErrNone, order.SetOrderTimeToNextFix(TPositionSelectionOrder::EOrderFairlyHigh)); |
|
382 CHECK_EQUAL_(KErrNone, order.SetOrderVerticalAccuracy(TPositionSelectionOrder::EOrderFairlyLow)); |
|
383 CHECK_EQUAL_(KErrNone, order.SetOrderPowerConsumption(TPositionSelectionOrder::EOrderVeryHigh)); |
|
384 |
|
385 criteria.SetSelectionOrder(order); |
|
386 criteria.GetSelectionOrder(order2); |
|
387 CHECK( AreEqualL(order, order2)); |
|
388 |
|
389 // position quality |
|
390 TPositionQuality quality, quality2; |
|
391 |
|
392 quality.SetTimeToFirstFix(TTimeIntervalMicroSeconds (987)); |
|
393 quality.SetTimeToNextFix(TTimeIntervalMicroSeconds (654)); |
|
394 quality.SetHorizontalAccuracy(TReal32 (123.555)); |
|
395 quality.SetVerticalAccuracy(TReal32 (45.88)); |
|
396 quality.SetCostIndicator(TPositionQuality::ECostPossible); |
|
397 quality.SetPowerConsumption(TPositionQuality::EPowerZero); |
|
398 |
|
399 criteria.SetRequiredQuality(quality); |
|
400 criteria.GetRequiredQuality(quality2); |
|
401 CHECK( AreEqualL(quality, quality2)); |
|
402 |
|
403 // required capabilities |
|
404 TPositionModuleInfo::TCapabilities caps = 0; |
|
405 |
|
406 // i ranges over all the bits in a TPositionModuleInfo::TCapabilities |
|
407 for (TUint i=0; i<sizeof(TPositionModuleInfo::TCapabilities) * 8; i++) |
|
408 { |
|
409 caps |= (1 << i); |
|
410 criteria.AddRequiredCapabilities(1 << i); |
|
411 CHECK_EQUAL_( caps, criteria.RequiredCapabilities()); |
|
412 } |
|
413 |
|
414 criteria.ClearRequiredCapabilities(); |
|
415 CHECK_EQUAL_( TPositionModuleInfo::TCapabilities(0), criteria.RequiredCapabilities()); |
|
416 |
|
417 StandardCleanup(); |
|
418 } |
|
419 |
|
420 // 5.1.3. Reset and Clear |
|
421 void CCriteriaClassesStep::TPositionCriteria_ResetAndClearL() |
|
422 { |
|
423 DECLARE_ERROR_LOGGING; |
|
424 StandardPrepareL(); |
|
425 |
|
426 __UHEAP_MARK; |
|
427 |
|
428 // create it |
|
429 TPositionCriteria criteria( TPositionModuleInfo::ECapabilityHorizontal | |
|
430 TPositionModuleInfo::ECapabilityVertical | |
|
431 TPositionModuleInfo::ECapabilityDirection | |
|
432 TPositionModuleInfo::ECapabilityCompass); |
|
433 |
|
434 TPositionSelectionOrder selOrder; |
|
435 CHECK_EQUAL_(KErrNone, selOrder.SetOrderTimeToFirstFix(TPositionSelectionOrder::EOrderLow)); |
|
436 CHECK_EQUAL_(KErrNone, selOrder.SetOrderTimeToNextFix(TPositionSelectionOrder::EOrderFairlyHigh)); |
|
437 CHECK_EQUAL_(KErrNone, selOrder.SetOrderVerticalAccuracy(TPositionSelectionOrder::EOrderFairlyLow)); |
|
438 CHECK_EQUAL_(KErrNone, selOrder.SetOrderPowerConsumption(TPositionSelectionOrder::EOrderVeryHigh)); |
|
439 criteria.SetSelectionOrder(selOrder); |
|
440 |
|
441 TPositionQuality quality; |
|
442 quality.SetTimeToFirstFix(TTimeIntervalMicroSeconds (987)); |
|
443 quality.SetTimeToNextFix(TTimeIntervalMicroSeconds (654)); |
|
444 quality.SetHorizontalAccuracy(TReal32 (123.555)); |
|
445 quality.SetVerticalAccuracy(TReal32 (45.88)); |
|
446 quality.SetCostIndicator(TPositionQuality::ECostPossible); |
|
447 quality.SetPowerConsumption(TPositionQuality::EPowerZero); |
|
448 criteria.SetRequiredQuality(quality); |
|
449 |
|
450 // Do a reset |
|
451 criteria.ResetCriteria(); |
|
452 |
|
453 // Check the required caps are blank |
|
454 CHECK_EQUAL_( |
|
455 DEFAULT_CRITERIA_MANDATORY_CAPABILITIES, |
|
456 criteria.RequiredCapabilities()); |
|
457 |
|
458 // Check the TPositionSelectionOrder component is blank / newly constructed |
|
459 TPositionSelectionOrder selOrder2; |
|
460 criteria.GetSelectionOrder(selOrder2); |
|
461 // TODO Investigate |
|
462 //CHECK( IsNewlyConstructed(selOrder2)); |
|
463 |
|
464 // Check the position quality is blank |
|
465 TPositionQuality posQuality; |
|
466 criteria.GetRequiredQuality(posQuality); |
|
467 CHECK( IsNewlyConstructed(posQuality)); |
|
468 |
|
469 // Do a clear |
|
470 criteria.ClearCriteria(); |
|
471 |
|
472 // Should not be any selection items in the contains TPositionSelectionOrder |
|
473 criteria.GetSelectionOrder(selOrder); |
|
474 CHECK_EQUAL_( TUint(0), selOrder.NumSelectionItems()); |
|
475 |
|
476 __UHEAP_MARKEND; |
|
477 |
|
478 StandardCleanup(); |
|
479 } |
|
480 |
|
481 // |
|
482 // |
|
483 // Utility functions |
|
484 // |
|
485 // |
|
486 |
|
487 // Macro |
|
488 // Only supposed to be used by the following utility functions |
|
489 #define RETURN_IF_NOT_EQUAL(aLhs, aRhs) \ |
|
490 if ((aLhs) != (aRhs)) \ |
|
491 return EFalse; |
|
492 |
|
493 TBool IsNewlyConstructed(const TPositionSelectionOrder& aSelOrder) |
|
494 { |
|
495 RETURN_IF_NOT_EQUAL( NUM_SELECTION_CRITERIA, aSelOrder.NumSelectionItems()); |
|
496 |
|
497 for (TInt i=0; i<ARRAYLENGTH(KTestFields); i++) |
|
498 { |
|
499 TPositionSelectionOrder::TField field; |
|
500 TPositionSelectionOrder::TOrder order; |
|
501 RETURN_IF_NOT_EQUAL( KErrNone, aSelOrder.GetSelectionItem(i, field, order)); |
|
502 RETURN_IF_NOT_EQUAL( KTestFields[i], field); |
|
503 RETURN_IF_NOT_EQUAL( TPositionSelectionOrder::EOrderDefault, order); |
|
504 } |
|
505 return ETrue; |
|
506 } |
|
507 |
|
508 TBool IsNewlyConstructed(const TPositionQuality& aPosQuality) |
|
509 { |
|
510 RETURN_IF_NOT_EQUAL( TTimeIntervalMicroSeconds(0), aPosQuality.TimeToFirstFix()); |
|
511 RETURN_IF_NOT_EQUAL( TTimeIntervalMicroSeconds(0), aPosQuality.TimeToNextFix()); |
|
512 RETURN_IF_NOT_EQUAL( TPositionQuality::ECostUnknown, aPosQuality.CostIndicator()); |
|
513 RETURN_IF_NOT_EQUAL( TPositionQuality::EPowerUnknown, aPosQuality.PowerConsumption()); |
|
514 if (!Math::IsNaN(aPosQuality.HorizontalAccuracy())) return EFalse; |
|
515 if (!Math::IsNaN(aPosQuality.VerticalAccuracy())) return EFalse; |
|
516 return ETrue; |
|
517 } |
|
518 |
|
519 TBool AreEqualL(const TPositionSelectionOrder& aLhs, const TPositionSelectionOrder& aRhs) |
|
520 /** |
|
521 * If this function leaves, it would fail the test |
|
522 */ |
|
523 { |
|
524 RETURN_IF_NOT_EQUAL( aLhs.NumSelectionItems(), aRhs.NumSelectionItems()); |
|
525 TUint num = aLhs.NumSelectionItems(); |
|
526 for (TUint i=0; i<num; i++) |
|
527 { |
|
528 TPositionSelectionOrder::TField field1; |
|
529 TPositionSelectionOrder::TOrder order1; |
|
530 User::LeaveIfError(aLhs.GetSelectionItem(0, field1, order1)); |
|
531 |
|
532 TUint j; |
|
533 for (j=0; j<num; j++) |
|
534 { |
|
535 TPositionSelectionOrder::TField field2; |
|
536 TPositionSelectionOrder::TOrder order2; |
|
537 User::LeaveIfError(aRhs.GetSelectionItem(0, field2, order2)); |
|
538 if (field1 == field2 && order1 == order2) |
|
539 { |
|
540 break; |
|
541 } |
|
542 } |
|
543 |
|
544 if (j == num) |
|
545 { |
|
546 return EFalse; |
|
547 } |
|
548 } |
|
549 return ETrue; |
|
550 } |
|
551 TBool AreEqualL(const TPositionQuality& aLhs, const TPositionQuality& aRhs) |
|
552 /** |
|
553 * If this function leaves, it would fail the test |
|
554 */ |
|
555 { |
|
556 RETURN_IF_NOT_EQUAL( aLhs.TimeToFirstFix(), aRhs.TimeToFirstFix()); |
|
557 RETURN_IF_NOT_EQUAL( aLhs.TimeToNextFix(), aRhs.TimeToNextFix()); |
|
558 RETURN_IF_NOT_EQUAL( aLhs.HorizontalAccuracy(), aRhs.HorizontalAccuracy()); |
|
559 RETURN_IF_NOT_EQUAL( aLhs.VerticalAccuracy(), aRhs.VerticalAccuracy()); |
|
560 RETURN_IF_NOT_EQUAL( aLhs.CostIndicator(), aRhs.CostIndicator()); |
|
561 RETURN_IF_NOT_EQUAL( aLhs.PowerConsumption(), aRhs.PowerConsumption()); |
|
562 return ETrue; |
|
563 } |