|
1 // Copyright (c) 2008-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 the License "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 // Hardware Configuration Respoitory Test Application |
|
15 // |
|
16 |
|
17 #define __E32TEST_EXTENSION__ |
|
18 #include <e32test.h> |
|
19 #include "d_hcrsim.h" |
|
20 #include "d_hcrsim_testdata.h" |
|
21 |
|
22 RTest test(_L("T_HCR")); |
|
23 RHcrSimTestChannel HcrSimTest; |
|
24 |
|
25 void HcrSimGetSettings(SSettingC* aRepository, TUint aNumberOfSettings) |
|
26 { |
|
27 test.Next(_L("GetSettings")); |
|
28 TInt r; |
|
29 SSettingC* setting; |
|
30 for (setting = aRepository; setting < aRepository + aNumberOfSettings; setting++) |
|
31 { |
|
32 TSettingId id(setting->iName.iId.iCat, setting->iName.iId.iKey); |
|
33 test.Printf(_L("(0x%08x, 0x%08x)\n"), id.iCat, id.iKey); |
|
34 switch (setting->iName.iType) |
|
35 { |
|
36 case ETypeInt32: |
|
37 { |
|
38 TInt32 val; |
|
39 r = HcrSimTest.GetInt(id, val); |
|
40 test_KErrNone(r); |
|
41 test_Equal(setting->iValue.iLit.iInt32, val); |
|
42 break; |
|
43 } |
|
44 case ETypeInt16: |
|
45 { |
|
46 TInt16 val; |
|
47 r = HcrSimTest.GetInt(id, val); |
|
48 test_KErrNone(r); |
|
49 test_Equal(setting->iValue.iLit.iInt16, val); |
|
50 break; |
|
51 } |
|
52 case ETypeInt8: |
|
53 { |
|
54 TInt8 val; |
|
55 r = HcrSimTest.GetInt(id, val); |
|
56 test_KErrNone(r); |
|
57 test_Equal(setting->iValue.iLit.iInt8, val); |
|
58 break; |
|
59 } |
|
60 case ETypeBool: |
|
61 { |
|
62 TBool val; |
|
63 r = HcrSimTest.GetBool(id, val); |
|
64 test_KErrNone(r); |
|
65 test_Equal(setting->iValue.iLit.iBool, val); |
|
66 break; |
|
67 } |
|
68 case ETypeUInt32: |
|
69 { |
|
70 TUint32 val; |
|
71 r = HcrSimTest.GetUInt(id, val); |
|
72 test_KErrNone(r); |
|
73 test_Equal(setting->iValue.iLit.iUInt32, val); |
|
74 break; |
|
75 } |
|
76 case ETypeUInt16: |
|
77 { |
|
78 TUint16 val; |
|
79 r = HcrSimTest.GetUInt(id, val); |
|
80 test_KErrNone(r); |
|
81 test_Equal(setting->iValue.iLit.iUInt16, val); |
|
82 break; |
|
83 } |
|
84 case ETypeUInt8: |
|
85 { |
|
86 TUint8 val; |
|
87 r = HcrSimTest.GetUInt(id, val); |
|
88 test_KErrNone(r); |
|
89 test_Equal(setting->iValue.iLit.iUInt8, val); |
|
90 break; |
|
91 } |
|
92 case ETypeLinAddr: |
|
93 { |
|
94 TLinAddr val; |
|
95 r = HcrSimTest.GetLinAddr(id, val); |
|
96 test_KErrNone(r); |
|
97 test_Equal(setting->iValue.iLit.iAddress, val); |
|
98 break; |
|
99 } |
|
100 case ETypeBinData: |
|
101 { |
|
102 TBuf8<KMaxSettingLength> dval; |
|
103 TUint8* pval; |
|
104 pval = (TUint8*) User::Alloc(setting->iName.iLen); |
|
105 test_NotNull(pval); |
|
106 // |
|
107 r = HcrSimTest.GetData(id, dval); |
|
108 test_KErrNone(r); |
|
109 // |
|
110 TUint16 actuallength; |
|
111 r = HcrSimTest.GetData(id, setting->iName.iLen, pval, actuallength); |
|
112 test_KErrNone(r); |
|
113 // |
|
114 test_Equal(0, Mem::Compare( |
|
115 setting->iValue.iPtr.iData, setting->iName.iLen, |
|
116 pval, actuallength)); |
|
117 test_Equal(0, Mem::Compare( |
|
118 setting->iValue.iPtr.iData, setting->iName.iLen, |
|
119 dval.Ptr(), dval.Length())); |
|
120 User::Free(pval); |
|
121 break; |
|
122 } |
|
123 case ETypeText8: |
|
124 { |
|
125 TBuf8<KMaxSettingLength> dval; |
|
126 TText8* pval; |
|
127 pval = (TText8*) User::Alloc(setting->iName.iLen); |
|
128 test_NotNull(pval); |
|
129 // |
|
130 r = HcrSimTest.GetString(id, dval); |
|
131 test_KErrNone(r); |
|
132 // |
|
133 TUint16 actuallength; |
|
134 r = HcrSimTest.GetString(id, setting->iName.iLen, pval, actuallength); |
|
135 test_KErrNone(r); |
|
136 // |
|
137 test_Equal(0, Mem::Compare( |
|
138 setting->iValue.iPtr.iString8, setting->iName.iLen, |
|
139 pval, actuallength)); |
|
140 test_Equal(0, Mem::Compare( |
|
141 setting->iValue.iPtr.iString8, setting->iName.iLen, |
|
142 dval.Ptr(), dval.Length())); |
|
143 User::Free(pval); |
|
144 break; |
|
145 } |
|
146 case ETypeArrayInt32: |
|
147 { |
|
148 TInt32* pval; |
|
149 pval = (TInt32*) User::Alloc(setting->iName.iLen); |
|
150 test_NotNull(pval); |
|
151 // |
|
152 TUint16 actuallength; |
|
153 r = HcrSimTest.GetArray(id, setting->iName.iLen, pval, actuallength); |
|
154 test_KErrNone(r); |
|
155 // |
|
156 test_Equal(setting->iName.iLen, actuallength); |
|
157 TInt32* pexpected = setting->iValue.iPtr.iArrayInt32; |
|
158 TUint i; |
|
159 for (i = 0; i < setting->iName.iLen / sizeof(TInt32); i++) |
|
160 { |
|
161 test_Equal(*(pexpected + i), *(pval + i)); |
|
162 } |
|
163 User::Free(pval); |
|
164 break; |
|
165 } |
|
166 case ETypeArrayUInt32: |
|
167 { |
|
168 TUint32* pval; |
|
169 pval = (TUint32*) User::Alloc(setting->iName.iLen); |
|
170 test_NotNull(pval); |
|
171 // |
|
172 TUint16 actuallength; |
|
173 r = HcrSimTest.GetArray(id, setting->iName.iLen, pval, actuallength); |
|
174 test_KErrNone(r); |
|
175 // |
|
176 test_Equal(setting->iName.iLen, actuallength); |
|
177 TUint32* pexpected = setting->iValue.iPtr.iArrayUInt32; |
|
178 TUint i; |
|
179 for (i = 0; i < setting->iName.iLen / sizeof(TUint32); i++) |
|
180 { |
|
181 test_Equal(*(pexpected + i), *(pval + i)); |
|
182 } |
|
183 User::Free(pval); |
|
184 break; |
|
185 } |
|
186 case ETypeInt64: |
|
187 { |
|
188 TInt64 val; |
|
189 r = HcrSimTest.GetInt(id, val); |
|
190 test_KErrNone(r); |
|
191 test_Equal(*setting->iValue.iPtr.iInt64, val); |
|
192 break; |
|
193 } |
|
194 case ETypeUInt64: |
|
195 { |
|
196 TUint64 val; |
|
197 r = HcrSimTest.GetUInt(id, val); |
|
198 test_KErrNone(r); |
|
199 test_Equal(*setting->iValue.iPtr.iUInt64, val); |
|
200 break; |
|
201 } |
|
202 default: |
|
203 test(EFalse); |
|
204 } |
|
205 } |
|
206 } |
|
207 |
|
208 void HcrSimGetSettingsNegative(SSettingC* aRepository, TUint aNumberOfSettings) |
|
209 { |
|
210 test.Next(_L("GetSettingsNegative")); |
|
211 TInt r; |
|
212 SSettingC* setting; |
|
213 for (setting = aRepository; setting < aRepository + aNumberOfSettings; setting++) |
|
214 { |
|
215 TSettingId id(setting->iName.iId.iCat, setting->iName.iId.iKey); |
|
216 test.Printf(_L("(0x%08x, 0x%08x)\n"), id.iCat, id.iKey); |
|
217 if (setting->iName.iType != ETypeInt32) |
|
218 { |
|
219 TInt32 val; |
|
220 r = HcrSimTest.GetInt(id, val); |
|
221 test_Equal(KErrArgument, r); |
|
222 } |
|
223 if (setting->iName.iType != ETypeInt16) |
|
224 { |
|
225 TInt16 val; |
|
226 r = HcrSimTest.GetInt(id, val); |
|
227 test_Equal(KErrArgument, r); |
|
228 } |
|
229 if (setting->iName.iType != ETypeInt8) |
|
230 { |
|
231 TInt8 val; |
|
232 r = HcrSimTest.GetInt(id, val); |
|
233 test_Equal(KErrArgument, r); |
|
234 } |
|
235 if (setting->iName.iType != ETypeBool) |
|
236 { |
|
237 TBool val; |
|
238 r = HcrSimTest.GetBool(id, val); |
|
239 test_Equal(KErrArgument, r); |
|
240 } |
|
241 if (setting->iName.iType != ETypeUInt32) |
|
242 { |
|
243 TUint32 val; |
|
244 r = HcrSimTest.GetUInt(id, val); |
|
245 test_Equal(KErrArgument, r); |
|
246 } |
|
247 if (setting->iName.iType != ETypeUInt16) |
|
248 { |
|
249 TUint16 val; |
|
250 r = HcrSimTest.GetUInt(id, val); |
|
251 test_Equal(KErrArgument, r); |
|
252 } |
|
253 if (setting->iName.iType != ETypeUInt8) |
|
254 { |
|
255 TUint8 val; |
|
256 r = HcrSimTest.GetUInt(id, val); |
|
257 test_Equal(KErrArgument, r); |
|
258 } |
|
259 if (setting->iName.iType != ETypeLinAddr) |
|
260 { |
|
261 TLinAddr val; |
|
262 r = HcrSimTest.GetLinAddr(id, val); |
|
263 test_Equal(KErrArgument, r); |
|
264 } |
|
265 if (setting->iName.iType != ETypeBinData) |
|
266 { |
|
267 TBuf8<KMaxSettingLength> dval; |
|
268 TUint8* pval; |
|
269 pval = (TUint8*) User::Alloc(setting->iName.iLen); |
|
270 test_NotNull(pval); |
|
271 // |
|
272 r = HcrSimTest.GetData(id, dval); |
|
273 test_Equal(KErrArgument, r); |
|
274 // |
|
275 TUint16 actuallength; |
|
276 r = HcrSimTest.GetData(id, setting->iName.iLen, pval, actuallength); |
|
277 test_Equal(KErrArgument, r); |
|
278 // |
|
279 User::Free(pval); |
|
280 } |
|
281 if (setting->iName.iType != ETypeText8) |
|
282 { |
|
283 TBuf8<KMaxSettingLength> dval; |
|
284 TText8* pval; |
|
285 pval = (TText8*) User::Alloc(setting->iName.iLen); |
|
286 test_NotNull(pval); |
|
287 // |
|
288 r = HcrSimTest.GetString(id, dval); |
|
289 test_Equal(KErrArgument, r); |
|
290 // |
|
291 TUint16 actuallength; |
|
292 r = HcrSimTest.GetString(id, setting->iName.iLen, pval, actuallength); |
|
293 test_Equal(KErrArgument, r); |
|
294 // |
|
295 User::Free(pval); |
|
296 } |
|
297 if (setting->iName.iType != ETypeArrayInt32) |
|
298 { |
|
299 TInt32* pval; |
|
300 pval = (TInt32*) User::Alloc(setting->iName.iLen); |
|
301 test_NotNull(pval); |
|
302 // |
|
303 TUint16 actuallength; |
|
304 r = HcrSimTest.GetArray(id, setting->iName.iLen, pval, actuallength); |
|
305 test_Equal(KErrArgument, r); |
|
306 // |
|
307 User::Free(pval); |
|
308 } |
|
309 if (setting->iName.iType != ETypeArrayUInt32) |
|
310 { |
|
311 TUint32* pval; |
|
312 pval = (TUint32*) User::Alloc(setting->iName.iLen); |
|
313 test_NotNull(pval); |
|
314 // |
|
315 TUint16 actuallength; |
|
316 r = HcrSimTest.GetArray(id, setting->iName.iLen, pval, actuallength); |
|
317 test_Equal(KErrArgument, r); |
|
318 // |
|
319 User::Free(pval); |
|
320 } |
|
321 if (setting->iName.iType != ETypeInt64) |
|
322 { |
|
323 TInt64 val; |
|
324 r = HcrSimTest.GetInt(id, val); |
|
325 test_Equal(KErrArgument, r); |
|
326 } |
|
327 if (setting->iName.iType != ETypeUInt64) |
|
328 { |
|
329 TUint64 val; |
|
330 r = HcrSimTest.GetUInt(id, val); |
|
331 test_Equal(KErrArgument, r); |
|
332 } |
|
333 } |
|
334 } |
|
335 |
|
336 void HcrSimGetSettingsNotFound(const TUint32 aInvalidCategory, const TUint32 aInvalidSettingId) |
|
337 { |
|
338 test.Next(_L("GetSettingsNotFound")); |
|
339 TSettingId id(aInvalidCategory, aInvalidSettingId); |
|
340 TInt r; |
|
341 { |
|
342 TInt32 val; |
|
343 r = HcrSimTest.GetInt(id, val); |
|
344 test_Equal(KErrNotFound, r); |
|
345 } |
|
346 { |
|
347 TInt16 val; |
|
348 r = HcrSimTest.GetInt(id, val); |
|
349 test_Equal(KErrNotFound, r); |
|
350 } |
|
351 { |
|
352 TInt8 val; |
|
353 r = HcrSimTest.GetInt(id, val); |
|
354 test_Equal(KErrNotFound, r); |
|
355 } |
|
356 { |
|
357 TBool val; |
|
358 r = HcrSimTest.GetBool(id, val); |
|
359 test_Equal(KErrNotFound, r); |
|
360 } |
|
361 { |
|
362 TUint32 val; |
|
363 r = HcrSimTest.GetUInt(id, val); |
|
364 test_Equal(KErrNotFound, r); |
|
365 } |
|
366 { |
|
367 TUint16 val; |
|
368 r = HcrSimTest.GetUInt(id, val); |
|
369 test_Equal(KErrNotFound, r); |
|
370 } |
|
371 { |
|
372 TUint8 val; |
|
373 r = HcrSimTest.GetUInt(id, val); |
|
374 test_Equal(KErrNotFound, r); |
|
375 } |
|
376 { |
|
377 TLinAddr val; |
|
378 r = HcrSimTest.GetLinAddr(id, val); |
|
379 test_Equal(KErrNotFound, r); |
|
380 } |
|
381 { |
|
382 TBuf8<KMaxSettingLength> dval; |
|
383 TUint8* pval; |
|
384 pval = (TUint8*) User::Alloc(KMaxSettingLength); |
|
385 test_NotNull(pval); |
|
386 // |
|
387 r = HcrSimTest.GetData(id, dval); |
|
388 test_Equal(KErrNotFound, r); |
|
389 // |
|
390 TUint16 actuallength; |
|
391 r = HcrSimTest.GetData(id, KMaxSettingLength, pval, actuallength); |
|
392 test_Equal(KErrNotFound, r); |
|
393 // |
|
394 User::Free(pval); |
|
395 } |
|
396 { |
|
397 TBuf8<KMaxSettingLength> dval; |
|
398 TText8* pval; |
|
399 pval = (TText8*) User::Alloc(KMaxSettingLength); |
|
400 test_NotNull(pval); |
|
401 // |
|
402 r = HcrSimTest.GetString(id, dval); |
|
403 test_Equal(KErrNotFound, r); |
|
404 // |
|
405 TUint16 actuallength; |
|
406 r = HcrSimTest.GetString(id, KMaxSettingLength, pval, actuallength); |
|
407 test_Equal(KErrNotFound, r); |
|
408 // |
|
409 User::Free(pval); |
|
410 } |
|
411 { |
|
412 TInt32* pval; |
|
413 pval = (TInt32*) User::Alloc(KMaxSettingLength); |
|
414 test_NotNull(pval); |
|
415 // |
|
416 TUint16 actuallength; |
|
417 r = HcrSimTest.GetArray(id, KMaxSettingLength, pval, actuallength); |
|
418 test_Equal(KErrNotFound, r); |
|
419 // |
|
420 User::Free(pval); |
|
421 } |
|
422 { |
|
423 TUint32* pval; |
|
424 pval = (TUint32*) User::Alloc(KMaxSettingLength); |
|
425 test_NotNull(pval); |
|
426 // |
|
427 TUint16 actuallength; |
|
428 r = HcrSimTest.GetArray(id, KMaxSettingLength, pval, actuallength); |
|
429 test_Equal(KErrNotFound, r); |
|
430 // |
|
431 User::Free(pval); |
|
432 } |
|
433 { |
|
434 TInt64 val; |
|
435 r = HcrSimTest.GetInt(id, val); |
|
436 test_Equal(KErrNotFound, r); |
|
437 } |
|
438 { |
|
439 TUint64 val; |
|
440 r = HcrSimTest.GetUInt(id, val); |
|
441 test_Equal(KErrNotFound, r); |
|
442 } |
|
443 } |
|
444 |
|
445 void HcrSimGetSettingsNotReady() |
|
446 { |
|
447 test.Next(_L("GetSettingsNotReady")); |
|
448 TSettingId id(1, 1); |
|
449 TInt r; |
|
450 { |
|
451 TInt32 val; |
|
452 r = HcrSimTest.GetInt(id, val); |
|
453 test_Equal(KErrNotReady, r); |
|
454 } |
|
455 { |
|
456 TInt16 val; |
|
457 r = HcrSimTest.GetInt(id, val); |
|
458 test_Equal(KErrNotReady, r); |
|
459 } |
|
460 { |
|
461 TInt8 val; |
|
462 r = HcrSimTest.GetInt(id, val); |
|
463 test_Equal(KErrNotReady, r); |
|
464 } |
|
465 { |
|
466 TBool val; |
|
467 r = HcrSimTest.GetBool(id, val); |
|
468 test_Equal(KErrNotReady, r); |
|
469 } |
|
470 { |
|
471 TUint32 val; |
|
472 r = HcrSimTest.GetUInt(id, val); |
|
473 test_Equal(KErrNotReady, r); |
|
474 } |
|
475 { |
|
476 TUint16 val; |
|
477 r = HcrSimTest.GetUInt(id, val); |
|
478 test_Equal(KErrNotReady, r); |
|
479 } |
|
480 { |
|
481 TUint8 val; |
|
482 r = HcrSimTest.GetUInt(id, val); |
|
483 test_Equal(KErrNotReady, r); |
|
484 } |
|
485 { |
|
486 TLinAddr val; |
|
487 r = HcrSimTest.GetLinAddr(id, val); |
|
488 test_Equal(KErrNotReady, r); |
|
489 } |
|
490 { |
|
491 TBuf8<KMaxSettingLength> dval; |
|
492 TUint8* pval; |
|
493 pval = (TUint8*) User::Alloc(KMaxSettingLength); |
|
494 test_NotNull(pval); |
|
495 // |
|
496 r = HcrSimTest.GetData(id, dval); |
|
497 test_Equal(KErrNotReady, r); |
|
498 // |
|
499 TUint16 actuallength; |
|
500 r = HcrSimTest.GetData(id, KMaxSettingLength, pval, actuallength); |
|
501 test_Equal(KErrNotReady, r); |
|
502 // |
|
503 User::Free(pval); |
|
504 } |
|
505 { |
|
506 TBuf8<KMaxSettingLength> dval; |
|
507 TText8* pval; |
|
508 pval = (TText8*) User::Alloc(KMaxSettingLength); |
|
509 test_NotNull(pval); |
|
510 // |
|
511 r = HcrSimTest.GetString(id, dval); |
|
512 test_Equal(KErrNotReady, r); |
|
513 // |
|
514 TUint16 actuallength; |
|
515 r = HcrSimTest.GetString(id, KMaxSettingLength, pval, actuallength); |
|
516 test_Equal(KErrNotReady, r); |
|
517 // |
|
518 User::Free(pval); |
|
519 } |
|
520 { |
|
521 TInt32* pval; |
|
522 pval = (TInt32*) User::Alloc(KMaxSettingLength); |
|
523 test_NotNull(pval); |
|
524 // |
|
525 TUint16 actuallength; |
|
526 r = HcrSimTest.GetArray(id, KMaxSettingLength, pval, actuallength); |
|
527 test_Equal(KErrNotReady, r); |
|
528 // |
|
529 User::Free(pval); |
|
530 } |
|
531 { |
|
532 TUint32* pval; |
|
533 pval = (TUint32*) User::Alloc(KMaxSettingLength); |
|
534 test_NotNull(pval); |
|
535 // |
|
536 TUint16 actuallength; |
|
537 r = HcrSimTest.GetArray(id, KMaxSettingLength, pval, actuallength); |
|
538 test_Equal(KErrNotReady, r); |
|
539 // |
|
540 User::Free(pval); |
|
541 } |
|
542 { |
|
543 TInt64 val; |
|
544 r = HcrSimTest.GetInt(id, val); |
|
545 test_Equal(KErrNotReady, r); |
|
546 } |
|
547 { |
|
548 TUint64 val; |
|
549 r = HcrSimTest.GetUInt(id, val); |
|
550 test_Equal(KErrNotReady, r); |
|
551 } |
|
552 } |
|
553 |
|
554 void HcrSimSettingProperties(SSettingC* aRepository, TUint aNumberOfSettings) |
|
555 { |
|
556 test.Next(_L("SettingProperties")); |
|
557 TInt r; |
|
558 SSettingC* setting; |
|
559 for (setting = aRepository; setting < aRepository + aNumberOfSettings; setting++) |
|
560 { |
|
561 TSettingId id(setting->iName.iId.iCat, setting->iName.iId.iKey); |
|
562 test.Printf(_L("(0x%08x, 0x%08x)\n"), id.iCat, id.iKey); |
|
563 TSettingType type = ETypeUndefined; |
|
564 TUint16 size = KMaxSettingLength + 1; |
|
565 r = HcrSimTest.GetTypeAndSize(id, type, size); |
|
566 test_KErrNone(r); |
|
567 switch (setting->iName.iType) |
|
568 { |
|
569 case ETypeInt32: |
|
570 case ETypeInt16: |
|
571 case ETypeInt8: |
|
572 case ETypeBool: |
|
573 case ETypeUInt32: |
|
574 case ETypeUInt16: |
|
575 case ETypeUInt8: |
|
576 case ETypeLinAddr: |
|
577 test_Equal(setting->iName.iType, type); |
|
578 test_Equal(0, size); |
|
579 break; |
|
580 // Fall-through |
|
581 case ETypeBinData: |
|
582 case ETypeText8: |
|
583 case ETypeArrayInt32: |
|
584 case ETypeArrayUInt32: |
|
585 case ETypeInt64: |
|
586 case ETypeUInt64: |
|
587 test_Equal(setting->iName.iType, type); |
|
588 test_Equal(setting->iName.iLen, size); |
|
589 break; |
|
590 default: |
|
591 test(EFalse); |
|
592 } |
|
593 test.Printf(_L(".")); |
|
594 } |
|
595 test.Printf(_L("\n")); |
|
596 } |
|
597 |
|
598 void HcrSimMultipleGet(SSettingC* aRepository, TUint aNumberOfSettings) |
|
599 { |
|
600 test.Next(_L("MultipleGet")); |
|
601 TInt r; |
|
602 |
|
603 test.Start(_L("Multiple Get on individual settings")); |
|
604 SSettingC* setting; |
|
605 for (setting = aRepository; setting < aRepository + aNumberOfSettings; setting++) |
|
606 { |
|
607 if (setting->iName.iType < 0x00010000) |
|
608 { |
|
609 SSettingId id; |
|
610 id.iCat = setting->iName.iId.iCat; |
|
611 id.iKey = setting->iName.iId.iKey; |
|
612 test.Printf(_L("(0x%08x, 0x%08x)\n"), id.iCat, id.iKey); |
|
613 TInt i; |
|
614 // Try all permutations of optional values |
|
615 for (i = 0; i < (2 ^ 2); i++) |
|
616 { |
|
617 test.Printf(_L("-Permutation %02x\n"), i); |
|
618 TInt32 val; |
|
619 TSettingType type; |
|
620 TInt err; |
|
621 r = HcrSimTest.GetWordSettings(1, &id, &val, |
|
622 // Optional values |
|
623 (i & 0x1 ? &type : NULL), |
|
624 (i & 0x10 ? &err : NULL)); |
|
625 test_KErrNone(r); |
|
626 test_Equal(setting->iValue.iLit.iInt32, val); |
|
627 if (i & 0x1) |
|
628 { |
|
629 test_Equal(setting->iName.iType, type); |
|
630 } |
|
631 if (i & 0x10) |
|
632 { |
|
633 test_KErrNone(err); |
|
634 } |
|
635 } |
|
636 } |
|
637 } |
|
638 |
|
639 test.Start(_L("Multiple Get on all settings")); |
|
640 TUint nosettings = 0; |
|
641 for (setting = aRepository; setting < aRepository + aNumberOfSettings; setting++) |
|
642 { |
|
643 if (setting->iName.iType < 0x00010000) |
|
644 { |
|
645 nosettings++; |
|
646 } |
|
647 test_Compare(0, <, nosettings); |
|
648 } |
|
649 SSettingId* ids; |
|
650 TInt32* vals; |
|
651 TSettingType* types; |
|
652 TInt* errs; |
|
653 ids = (SSettingId*) User::Alloc(sizeof(SSettingId) * nosettings); |
|
654 test_NotNull(ids); |
|
655 vals = (TInt32*) User::Alloc(sizeof(TInt32) * nosettings); |
|
656 test_NotNull(vals); |
|
657 types = (TSettingType*) User::Alloc(sizeof(TSettingType) * nosettings); |
|
658 test_NotNull(types); |
|
659 errs = (TInt*) User::Alloc(sizeof(TInt) * nosettings); |
|
660 test_NotNull(errs); |
|
661 TUint n = 0; |
|
662 for (setting = aRepository; setting < aRepository + aNumberOfSettings; setting++) |
|
663 { |
|
664 if (setting->iName.iType < 0x00010000) |
|
665 { |
|
666 ids[n].iCat = setting->iName.iId.iCat; |
|
667 ids[n].iKey = setting->iName.iId.iKey; |
|
668 n++; |
|
669 } |
|
670 } |
|
671 test_Equal(nosettings, n); |
|
672 // Try all permutations of optional values |
|
673 TInt i; |
|
674 for (i = 0; i < (2 ^ 2); i++) |
|
675 { |
|
676 r = HcrSimTest.GetWordSettings(nosettings, ids, vals, |
|
677 // Optional values |
|
678 (i & 0x1 ? types : NULL), |
|
679 (i & 0x10 ? errs : NULL)); |
|
680 test_KErrNone(r); |
|
681 |
|
682 // Check values |
|
683 n = 0; |
|
684 for (setting = aRepository; setting < aRepository + aNumberOfSettings; setting++) |
|
685 { |
|
686 if (setting->iName.iType < 0x00010000) |
|
687 { |
|
688 test_Equal(setting->iValue.iLit.iInt32, vals[n]); |
|
689 if (i & 0x1) |
|
690 { |
|
691 test_Equal(setting->iName.iType, types[n]); |
|
692 } |
|
693 if (i & 0x10) |
|
694 { |
|
695 test_KErrNone(errs[n]); |
|
696 } |
|
697 n++; |
|
698 } |
|
699 } |
|
700 test_Equal(nosettings, n); |
|
701 } |
|
702 User::Free(ids); |
|
703 User::Free(vals); |
|
704 User::Free(types); |
|
705 User::Free(errs); |
|
706 test.End(); |
|
707 } |
|
708 |
|
709 void HcrSimTests() |
|
710 { |
|
711 test.Next(_L("HCR Simulator tests")); |
|
712 test.Start(_L("Load Device Driver")); |
|
713 TInt r; |
|
714 r = User::LoadLogicalDevice(KTestHcrSim); |
|
715 if (r == KErrAlreadyExists) |
|
716 { |
|
717 test.Printf(_L("Unload Device Driver and load it again\n")); |
|
718 r = User::FreeLogicalDevice(KTestHcrSim); |
|
719 test_KErrNone(r); |
|
720 r = User::LoadLogicalDevice(KTestHcrSim); |
|
721 test_KErrNone(r); |
|
722 } |
|
723 else |
|
724 { |
|
725 test_KErrNone(r); |
|
726 } |
|
727 |
|
728 test.Next(_L("Open test channel")); |
|
729 r = HcrSimTest.Open(); |
|
730 test_KErrNone(r); |
|
731 HcrSimGetSettingsNotReady(); |
|
732 |
|
733 test.Next(_L("Initialise HCR")); |
|
734 r = HcrSimTest.InitExtension(); |
|
735 test_KErrNone(r); |
|
736 |
|
737 test.Next(_L("Compiled")); |
|
738 test.Start(_L("Initialisation")); |
|
739 #ifndef __WINS__ |
|
740 _LIT8(KTestFileRepos, "filerepos.dat"); |
|
741 _LIT8(KTestNandRepos, "nandrepos.dat"); |
|
742 _LIT8(KTestCorrupt1, "corrupt1.dat"); |
|
743 _LIT8(KTestCorrupt2, "corrupt2.dat"); |
|
744 _LIT8(KTestEmpty, "empty.dat"); |
|
745 _LIT8(KTestClearRepos, ""); |
|
746 |
|
747 r = HcrSimTest.SwitchRepository(KTestClearRepos, HCRInternal::ECoreRepos); |
|
748 test_KErrNone(r); |
|
749 r = HcrSimTest.SwitchRepository(KTestClearRepos, HCRInternal::EOverrideRepos); |
|
750 test_KErrNone(r); |
|
751 #endif // __WINS__ |
|
752 HcrSimGetSettings(SettingsList, sizeof(SettingsList) / sizeof(SSettingC)); |
|
753 HcrSimGetSettingsNegative(SettingsList, sizeof(SettingsList) / sizeof(SSettingC)); |
|
754 HcrSimGetSettingsNotFound(KTestInvalidCategory, KTestInvalidSettingId); |
|
755 HcrSimGetSettingsNotFound(KTestInvalidCategory, 1); |
|
756 HcrSimGetSettingsNotFound(1, KTestInvalidSettingId); |
|
757 //HcrSimSettingProperties(SettingsList, sizeof(SettingsList) / sizeof(SSettingC)); |
|
758 //HcrSimMultipleGet(SettingsList, sizeof(SettingsList) / sizeof(SSettingC)); |
|
759 test.End(); |
|
760 |
|
761 #ifndef __WINS__ |
|
762 test.Next(_L("Compiled+File")); |
|
763 test.Start(_L("Initialisation")); |
|
764 r = HcrSimTest.SwitchRepository(KTestFileRepos, HCRInternal::ECoreRepos); |
|
765 test_KErrNone(r); |
|
766 r = HcrSimTest.CheckIntegrity(); |
|
767 test_KErrNone(r); |
|
768 HcrSimGetSettings(SettingsList2, sizeof(SettingsList2) / sizeof(SSettingC)); |
|
769 HcrSimGetSettingsNegative(SettingsList2, sizeof(SettingsList2) / sizeof(SSettingC)); |
|
770 HcrSimGetSettingsNotFound(KTestInvalidCategory, KTestInvalidSettingId); |
|
771 HcrSimGetSettingsNotFound(KTestInvalidCategory, 1); |
|
772 HcrSimGetSettingsNotFound(1, KTestInvalidSettingId); |
|
773 test.End(); |
|
774 |
|
775 test.Next(_L("Compiled+File+Nand")); |
|
776 test.Start(_L("Initialisation")); |
|
777 r = HcrSimTest.SwitchRepository(KTestNandRepos, HCRInternal::EOverrideRepos); |
|
778 test_KErrNone(r); |
|
779 r = HcrSimTest.CheckIntegrity(); |
|
780 test_KErrNone(r); |
|
781 HcrSimGetSettings(SettingsList3, sizeof(SettingsList3) / sizeof(SSettingC)); |
|
782 HcrSimGetSettingsNegative(SettingsList3, sizeof(SettingsList3) / sizeof(SSettingC)); |
|
783 HcrSimGetSettingsNotFound(KTestInvalidCategory, KTestInvalidSettingId); |
|
784 HcrSimGetSettingsNotFound(KTestInvalidCategory, 1); |
|
785 HcrSimGetSettingsNotFound(1, KTestInvalidSettingId); |
|
786 test.End(); |
|
787 |
|
788 test.Next(_L("Compiled+Nand")); |
|
789 test.Start(_L("Initialisation")); |
|
790 r = HcrSimTest.SwitchRepository(KTestClearRepos, HCRInternal::ECoreRepos); |
|
791 test_KErrNone(r); |
|
792 r = HcrSimTest.CheckIntegrity(); |
|
793 test_KErrNone(r); |
|
794 HcrSimGetSettings(SettingsList4, sizeof(SettingsList4) / sizeof(SSettingC)); |
|
795 HcrSimGetSettingsNegative(SettingsList4, sizeof(SettingsList4) / sizeof(SSettingC)); |
|
796 HcrSimGetSettingsNotFound(KTestInvalidCategory, KTestInvalidSettingId); |
|
797 HcrSimGetSettingsNotFound(KTestInvalidCategory, 1); |
|
798 HcrSimGetSettingsNotFound(1, KTestInvalidSettingId); |
|
799 test.End(); |
|
800 |
|
801 test.Next(_L("Compiled+Empty+Nand")); |
|
802 test.Start(_L("Initialisation")); |
|
803 r = HcrSimTest.SwitchRepository(KTestEmpty, HCRInternal::ECoreRepos); |
|
804 test_KErrNone(r); |
|
805 r = HcrSimTest.CheckIntegrity(); |
|
806 test_KErrNone(r); |
|
807 HcrSimGetSettings(SettingsList4, sizeof(SettingsList4) / sizeof(SSettingC)); |
|
808 HcrSimGetSettingsNegative(SettingsList4, sizeof(SettingsList4) / sizeof(SSettingC)); |
|
809 HcrSimGetSettingsNotFound(KTestInvalidCategory, KTestInvalidSettingId); |
|
810 HcrSimGetSettingsNotFound(KTestInvalidCategory, 1); |
|
811 HcrSimGetSettingsNotFound(1, KTestInvalidSettingId); |
|
812 test.End(); |
|
813 #endif // __WINS__ |
|
814 |
|
815 // Reload device driver without a compiled repository this time |
|
816 test.Next(_L("Reload Device Driver")); |
|
817 HcrSimTest.Close(); |
|
818 r = User::FreeLogicalDevice(KTestHcrSim); |
|
819 test_KErrNone(r); |
|
820 r = User::LoadLogicalDevice(KTestHcrSim); |
|
821 test_KErrNone(r); |
|
822 r = HcrSimTest.Open(); |
|
823 test_KErrNone(r); |
|
824 r = HcrSimTest.InitExtension(ETestNullRepository); // *** The NULL Repository *** |
|
825 #ifdef __WINS__ |
|
826 test_Equal(KErrArgument, r); |
|
827 #else |
|
828 test_KErrNone(r); |
|
829 |
|
830 test.Next(_L("NULL+File")); |
|
831 test.Start(_L("Initialisation")); |
|
832 r = HcrSimTest.SwitchRepository(KTestClearRepos, HCRInternal::EOverrideRepos); |
|
833 test_KErrNone(r); |
|
834 r = HcrSimTest.CheckIntegrity(); |
|
835 test_KErrNone(r); |
|
836 HcrSimGetSettings(SettingsList7, sizeof(SettingsList7) / sizeof(SSettingC)); |
|
837 HcrSimGetSettingsNegative(SettingsList7, sizeof(SettingsList7) / sizeof(SSettingC)); |
|
838 HcrSimGetSettingsNotFound(KTestInvalidCategory, KTestInvalidSettingId); |
|
839 HcrSimGetSettingsNotFound(KTestInvalidCategory, 1); |
|
840 HcrSimGetSettingsNotFound(1, KTestInvalidSettingId); |
|
841 test.End(); |
|
842 |
|
843 test.Next(_L("NULL+File+Nand")); |
|
844 test.Start(_L("Initialisation")); |
|
845 r = HcrSimTest.SwitchRepository(KTestNandRepos, HCRInternal::EOverrideRepos); |
|
846 test_KErrNone(r); |
|
847 r = HcrSimTest.CheckIntegrity(); |
|
848 test_KErrNone(r); |
|
849 HcrSimGetSettings(SettingsList6, sizeof(SettingsList6) / sizeof(SSettingC)); |
|
850 HcrSimGetSettingsNegative(SettingsList6, sizeof(SettingsList6) / sizeof(SSettingC)); |
|
851 HcrSimGetSettingsNotFound(KTestInvalidCategory, KTestInvalidSettingId); |
|
852 HcrSimGetSettingsNotFound(KTestInvalidCategory, 1); |
|
853 HcrSimGetSettingsNotFound(1, KTestInvalidSettingId); |
|
854 test.End(); |
|
855 |
|
856 test.Next(_L("NULL+Nand")); |
|
857 test.Start(_L("Initialisation")); |
|
858 r = HcrSimTest.SwitchRepository(KTestClearRepos, HCRInternal::ECoreRepos); |
|
859 test_KErrNone(r); |
|
860 r = HcrSimTest.CheckIntegrity(); |
|
861 test_KErrNone(r); |
|
862 HcrSimGetSettings(SettingsList5, sizeof(SettingsList5) / sizeof(SSettingC)); |
|
863 HcrSimGetSettingsNegative(SettingsList5, sizeof(SettingsList5) / sizeof(SSettingC)); |
|
864 HcrSimGetSettingsNotFound(KTestInvalidCategory, KTestInvalidSettingId); |
|
865 HcrSimGetSettingsNotFound(KTestInvalidCategory, 1); |
|
866 HcrSimGetSettingsNotFound(1, KTestInvalidSettingId); |
|
867 test.End(); |
|
868 #endif // __WINS__ |
|
869 |
|
870 test.Next(_L("Reload Device Driver")); |
|
871 HcrSimTest.Close(); |
|
872 r = User::FreeLogicalDevice(KTestHcrSim); |
|
873 test_KErrNone(r); |
|
874 r = User::LoadLogicalDevice(KTestHcrSim); |
|
875 test_KErrNone(r); |
|
876 r = HcrSimTest.Open(); |
|
877 test_KErrNone(r); |
|
878 r = HcrSimTest.InitExtension(ETestEmptyRepository); // *** The Empty Repository *** |
|
879 test_KErrNone(r); |
|
880 |
|
881 #ifndef __WINS__ |
|
882 test.Next(_L("Empty+Nand")); |
|
883 test.Start(_L("Initialisation")); |
|
884 r = HcrSimTest.SwitchRepository(KTestClearRepos, HCRInternal::ECoreRepos); |
|
885 test_KErrNone(r); |
|
886 r = HcrSimTest.SwitchRepository(KTestClearRepos, HCRInternal::EOverrideRepos); |
|
887 test_KErrNone(r); |
|
888 r = HcrSimTest.SwitchRepository(KTestNandRepos, HCRInternal::EOverrideRepos); |
|
889 test_KErrNone(r); |
|
890 r = HcrSimTest.CheckIntegrity(); |
|
891 test_KErrNone(r); |
|
892 HcrSimGetSettings(SettingsList5, sizeof(SettingsList5) / sizeof(SSettingC)); |
|
893 HcrSimGetSettingsNegative(SettingsList5, sizeof(SettingsList5) / sizeof(SSettingC)); |
|
894 HcrSimGetSettingsNotFound(KTestInvalidCategory, KTestInvalidSettingId); |
|
895 HcrSimGetSettingsNotFound(KTestInvalidCategory, 1); |
|
896 HcrSimGetSettingsNotFound(1, KTestInvalidSettingId); |
|
897 test.End(); |
|
898 |
|
899 test.Next(_L("Empty+File+Nand")); |
|
900 test.Start(_L("Initialisation")); |
|
901 r = HcrSimTest.SwitchRepository(KTestFileRepos, HCRInternal::ECoreRepos); |
|
902 test_KErrNone(r); |
|
903 r = HcrSimTest.CheckIntegrity(); |
|
904 test_KErrNone(r); |
|
905 HcrSimGetSettings(SettingsList6, sizeof(SettingsList6) / sizeof(SSettingC)); |
|
906 HcrSimGetSettingsNegative(SettingsList6, sizeof(SettingsList6) / sizeof(SSettingC)); |
|
907 HcrSimGetSettingsNotFound(KTestInvalidCategory, KTestInvalidSettingId); |
|
908 HcrSimGetSettingsNotFound(KTestInvalidCategory, 1); |
|
909 HcrSimGetSettingsNotFound(1, KTestInvalidSettingId); |
|
910 test.End(); |
|
911 |
|
912 test.Next(_L("Empty+File")); |
|
913 test.Start(_L("Initialisation")); |
|
914 r = HcrSimTest.SwitchRepository(KTestClearRepos, HCRInternal::EOverrideRepos); |
|
915 test_KErrNone(r); |
|
916 r = HcrSimTest.CheckIntegrity(); |
|
917 test_KErrNone(r); |
|
918 HcrSimGetSettings(SettingsList7, sizeof(SettingsList7) / sizeof(SSettingC)); |
|
919 HcrSimGetSettingsNegative(SettingsList7, sizeof(SettingsList7) / sizeof(SSettingC)); |
|
920 HcrSimGetSettingsNotFound(KTestInvalidCategory, KTestInvalidSettingId); |
|
921 HcrSimGetSettingsNotFound(KTestInvalidCategory, 1); |
|
922 HcrSimGetSettingsNotFound(1, KTestInvalidSettingId); |
|
923 test.End(); |
|
924 |
|
925 test.Next(_L("No Repository (Empty)")); |
|
926 test.Start(_L("Initialisation")); |
|
927 r = HcrSimTest.SwitchRepository(KTestClearRepos, HCRInternal::ECoreRepos); |
|
928 test_KErrNone(r); |
|
929 r = HcrSimTest.CheckIntegrity(); |
|
930 test_KErrNone(r); |
|
931 HcrSimGetSettingsNotFound(KTestInvalidCategory, KTestInvalidSettingId); |
|
932 HcrSimGetSettingsNotFound(KTestInvalidCategory, 1); |
|
933 HcrSimGetSettingsNotFound(1, KTestInvalidSettingId); |
|
934 test.End(); |
|
935 |
|
936 test.Next(_L("All Repositories Empty")); |
|
937 test.Start(_L("Initialisation")); |
|
938 r = HcrSimTest.SwitchRepository(KTestEmpty, HCRInternal::ECoreRepos); |
|
939 test_KErrNone(r); |
|
940 r = HcrSimTest.SwitchRepository(KTestEmpty, HCRInternal::EOverrideRepos); |
|
941 test_KErrNone(r); |
|
942 r = HcrSimTest.CheckIntegrity(); |
|
943 test_KErrNone(r); |
|
944 HcrSimGetSettingsNotFound(KTestInvalidCategory, KTestInvalidSettingId); |
|
945 HcrSimGetSettingsNotFound(KTestInvalidCategory, 1); |
|
946 HcrSimGetSettingsNotFound(1, KTestInvalidSettingId); |
|
947 test.End(); |
|
948 #endif // __WINS__ |
|
949 |
|
950 test.Next(_L("Reload Device Driver")); |
|
951 HcrSimTest.Close(); |
|
952 r = User::FreeLogicalDevice(KTestHcrSim); |
|
953 test_KErrNone(r); |
|
954 r = User::LoadLogicalDevice(KTestHcrSim); |
|
955 test_KErrNone(r); |
|
956 r = HcrSimTest.Open(); |
|
957 test_KErrNone(r); |
|
958 r = HcrSimTest.InitExtension(ETestIgnoreCoreImgRepository); // *** Ignore Core Image Repository *** |
|
959 test_KErrNone(r); |
|
960 |
|
961 #ifndef __WINS__ |
|
962 test.Next(_L("Compiled+File(Ignored)+Nand")); // Should be same as Compiled+Nand |
|
963 test.Start(_L("Initialisation")); |
|
964 r = HcrSimTest.SwitchRepository(KTestNandRepos, HCRInternal::EOverrideRepos); |
|
965 test_KErrNone(r); |
|
966 r = HcrSimTest.CheckIntegrity(); |
|
967 test_KErrNone(r); |
|
968 HcrSimGetSettings(SettingsList4, sizeof(SettingsList4) / sizeof(SSettingC)); |
|
969 HcrSimGetSettingsNegative(SettingsList4, sizeof(SettingsList4) / sizeof(SSettingC)); |
|
970 HcrSimGetSettingsNotFound(KTestInvalidCategory, KTestInvalidSettingId); |
|
971 HcrSimGetSettingsNotFound(KTestInvalidCategory, 1); |
|
972 HcrSimGetSettingsNotFound(1, KTestInvalidSettingId); |
|
973 test.End(); |
|
974 #endif // __WINS__ |
|
975 |
|
976 test.Next(_L("Reload Device Driver (Corrupt1)")); |
|
977 HcrSimTest.Close(); |
|
978 r = User::FreeLogicalDevice(KTestHcrSim); |
|
979 test_KErrNone(r); |
|
980 r = User::LoadLogicalDevice(KTestHcrSim); |
|
981 test_KErrNone(r); |
|
982 r = HcrSimTest.Open(); |
|
983 test_KErrNone(r); |
|
984 r = HcrSimTest.InitExtension(ETestCorruptRepository1); // *** Repository not ordered *** |
|
985 #ifdef _DEBUG |
|
986 test_Equal(KErrCorrupt, r); |
|
987 #else |
|
988 test_KErrNone(r); |
|
989 #endif // _DEBUG |
|
990 |
|
991 test.Next(_L("Reload Device Driver (Corrupt2)")); |
|
992 HcrSimTest.Close(); |
|
993 r = User::FreeLogicalDevice(KTestHcrSim); |
|
994 test_KErrNone(r); |
|
995 r = User::LoadLogicalDevice(KTestHcrSim); |
|
996 test_KErrNone(r); |
|
997 r = HcrSimTest.Open(); |
|
998 test_KErrNone(r); |
|
999 r = HcrSimTest.InitExtension(ETestCorruptRepository2); // *** Repository with duplicates *** |
|
1000 #ifdef _DEBUG |
|
1001 test_Equal(KErrAlreadyExists, r); |
|
1002 #else |
|
1003 test_KErrNone(r); |
|
1004 #endif // _DEBUG |
|
1005 |
|
1006 #ifndef __WINS__ |
|
1007 test.Next(_L("Reload Device Driver (Default)")); |
|
1008 HcrSimTest.Close(); |
|
1009 r = User::FreeLogicalDevice(KTestHcrSim); |
|
1010 test_KErrNone(r); |
|
1011 r = User::LoadLogicalDevice(KTestHcrSim); |
|
1012 test_KErrNone(r); |
|
1013 r = HcrSimTest.Open(); |
|
1014 test_KErrNone(r); |
|
1015 r = HcrSimTest.InitExtension(); // *** Default Repository *** |
|
1016 test_KErrNone(r); |
|
1017 |
|
1018 test.Next(_L("Compiled+Corrupt1+Nand")); |
|
1019 test.Start(_L("Initialisation")); |
|
1020 r = HcrSimTest.SwitchRepository(KTestCorrupt1, HCRInternal::ECoreRepos); |
|
1021 test_KErrNone(r); |
|
1022 r = HcrSimTest.SwitchRepository(KTestNandRepos, HCRInternal::EOverrideRepos); |
|
1023 test_KErrNone(r); |
|
1024 r = HcrSimTest.CheckIntegrity(); |
|
1025 test_Equal(KErrCorrupt, r); |
|
1026 test.End(); |
|
1027 |
|
1028 test.Next(_L("Compiled+Corrupt2+Nand")); |
|
1029 test.Start(_L("Initialisation")); |
|
1030 r = HcrSimTest.SwitchRepository(KTestCorrupt2, HCRInternal::ECoreRepos); |
|
1031 test_KErrNone(r); |
|
1032 r = HcrSimTest.CheckIntegrity(); |
|
1033 test_Equal(KErrAlreadyExists, r); |
|
1034 test.End(); |
|
1035 |
|
1036 test.Next(_L("Compiled+File+Corrupt1")); |
|
1037 test.Start(_L("Initialisation")); |
|
1038 r = HcrSimTest.SwitchRepository(KTestFileRepos, HCRInternal::ECoreRepos); |
|
1039 test_KErrNone(r); |
|
1040 r = HcrSimTest.SwitchRepository(KTestCorrupt1, HCRInternal::EOverrideRepos); |
|
1041 test_KErrNone(r); |
|
1042 r = HcrSimTest.CheckIntegrity(); |
|
1043 test_Equal(KErrCorrupt, r); |
|
1044 test.End(); |
|
1045 |
|
1046 test.Next(_L("Compiled+File+Corrupt2")); |
|
1047 test.Start(_L("Initialisation")); |
|
1048 r = HcrSimTest.SwitchRepository(KTestCorrupt2, HCRInternal::EOverrideRepos); |
|
1049 test_KErrNone(r); |
|
1050 r = HcrSimTest.CheckIntegrity(); |
|
1051 test_Equal(KErrAlreadyExists, r); |
|
1052 test.End(); |
|
1053 #endif // __WINS__ |
|
1054 |
|
1055 test.Next(_L("Close test channel and unload device driver")); |
|
1056 HcrSimTest.Close(); |
|
1057 r = User::FreeLogicalDevice(KTestHcrSim); |
|
1058 test_KErrNone(r); |
|
1059 test.End(); |
|
1060 } |
|
1061 |
|
1062 GLDEF_C TInt E32Main() |
|
1063 { |
|
1064 __UHEAP_MARK; |
|
1065 |
|
1066 test.Title(); |
|
1067 test.Start(_L("HCR Test Suite")); |
|
1068 HcrSimTests(); |
|
1069 test.End(); |
|
1070 test.Close(); |
|
1071 |
|
1072 __UHEAP_MARKEND; |
|
1073 return KErrNone; |
|
1074 } |