1 /* |
|
2 * Copyright (c) 2005-2009 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 the License "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 * |
|
16 */ |
|
17 |
|
18 |
|
19 #include <s32mem.h> |
|
20 #include "tauthdbstep.h" |
|
21 #include <f32file.h> |
|
22 |
|
23 using namespace AuthServer; |
|
24 |
|
25 const TIdentityId KIdentity1Id = 'I1ID'; |
|
26 const TIdentityId KIdentity2Id = 'I2ID'; |
|
27 const TIdentityId KIdentity3Id = 'I3ID'; |
|
28 _LIT(KIdentity1Desc, "identity-1-desc"); |
|
29 _LIT(KIdentity1DescB, "identity-1-descB"); |
|
30 _LIT(KIdentity2Desc, "identity-2-desc"); |
|
31 _LIT(KIdentity3Desc, "identity-3-desc"); |
|
32 |
|
33 const TPluginId KPlugin1Id = 'PID1'; |
|
34 const TPluginId KPlugin2Id = 'PID2'; |
|
35 const TPluginId KPlugin3Id = 'PID3'; |
|
36 const TPluginId KPlugin4Id = 'PID4'; |
|
37 const TPluginId KPluginAId = 'PIDA'; |
|
38 const TPluginId KPluginBId = 'PIDB'; |
|
39 |
|
40 |
|
41 CTStepPersist2::CTStepPersist2() |
|
42 { |
|
43 SetTestStepName(KTStepCreateTestDb); |
|
44 } |
|
45 |
|
46 |
|
47 TVerdict CTStepPersist2::doTestStepL() |
|
48 { |
|
49 __UHEAP_MARK; |
|
50 |
|
51 RemoveExistingDbL(); |
|
52 |
|
53 TestOpenCloseL(); |
|
54 TestIdentitiesL(); |
|
55 TestPrefsL(); |
|
56 TestTrainedPluginsL(); |
|
57 TestTrainingStatusL(); |
|
58 TestRepairL(); |
|
59 TestCompressL(); |
|
60 |
|
61 __UHEAP_MARKEND; |
|
62 return EPass; |
|
63 } |
|
64 |
|
65 |
|
66 void CTStepPersist2::TestOpenCloseL() |
|
67 /** |
|
68 Test simply opening and closing a database, |
|
69 without using any other operations. |
|
70 */ |
|
71 { |
|
72 CAuthDb2* db = CAuthDb2::NewL(iFs); |
|
73 delete db; |
|
74 } |
|
75 |
|
76 |
|
77 void CTStepPersist2::TestIdentitiesL() |
|
78 { |
|
79 TInt r; |
|
80 |
|
81 __UHEAP_MARK; |
|
82 RemoveExistingDbL(); |
|
83 CAuthDb2* db = CAuthDb2::NewLC(iFs); |
|
84 |
|
85 RArray<TIdentityId> ids; |
|
86 |
|
87 // get id list before any ids defined |
|
88 ids.AppendL('SYMB'); // garbage; ensure removed |
|
89 db->IdentitiesL(ids); |
|
90 TESTL(ids.Count() == 0); |
|
91 |
|
92 // add an identity |
|
93 db->AddIdentityL(KIdentity1Id, KIdentity1Desc); |
|
94 db->IdentitiesL(ids); |
|
95 TESTL(ids.Count() == 1); |
|
96 TESTL(ids[0] == KIdentity1Id); |
|
97 |
|
98 // retrieve the identity's description |
|
99 TestDescriptionL(db, KIdentity1Id, KIdentity1Desc); |
|
100 |
|
101 // change the identity's description |
|
102 db->SetDescriptionL(KIdentity1Id, KIdentity1DescB); |
|
103 TestDescriptionL(db, KIdentity1Id, KIdentity1DescB); |
|
104 |
|
105 // change the identity's description to a string which is |
|
106 // too long; ensure fails. |
|
107 TBuf<KMaxDescLen + 1> dbuf; |
|
108 dbuf.Fill('a', KMaxDescLen - 1); // limit - 1 |
|
109 db->SetDescriptionL(KIdentity1Id, dbuf); |
|
110 TestDescriptionL(db, KIdentity1Id, dbuf); |
|
111 |
|
112 dbuf.Fill('a', KMaxDescLen); // limit |
|
113 db->SetDescriptionL(KIdentity1Id, dbuf); |
|
114 TestDescriptionL(db, KIdentity1Id, dbuf); |
|
115 |
|
116 db->SetDescriptionL(KIdentity1Id, KIdentity1DescB); |
|
117 TestDescriptionL(db, KIdentity1Id, KIdentity1DescB); |
|
118 dbuf.Fill('a', KMaxDescLen + 1); // limit + 1 |
|
119 TRAP(r, db->SetDescriptionL(KIdentity1Id, dbuf)); |
|
120 TESTL(r == KErrAuthServDescTooLong); |
|
121 TestDescriptionL(db, KIdentity1Id, KIdentity1DescB); // keep old desc |
|
122 |
|
123 // add a second identity |
|
124 db->AddIdentityL(KIdentity2Id, KIdentity2Desc); |
|
125 db->IdentitiesL(ids); |
|
126 TESTL(ids.Count() == 2); |
|
127 TESTL( (ids[0] == KIdentity1Id && ids[1] == KIdentity2Id) |
|
128 || (ids[0] == KIdentity2Id && ids[1] == KIdentity1Id) ); |
|
129 TestDescriptionL(db, KIdentity1Id, KIdentity1DescB); |
|
130 TestDescriptionL(db, KIdentity2Id, KIdentity2Desc); |
|
131 |
|
132 // add an identity which already exists |
|
133 TRAP(r, db->AddIdentityL(KIdentity2Id, KIdentity2Desc)); |
|
134 TESTL(r == KErrAuthServIdentityAlreadyExists); |
|
135 |
|
136 // retrieve description for an unregistered identity |
|
137 TRAP(r, db->DescriptionL(KIdentity3Id)); |
|
138 TESTL(r == KErrAuthServIdentityNotFound); |
|
139 |
|
140 // set description for an unregistered identity |
|
141 TRAP(r, db->SetDescriptionL(KIdentity3Id, KIdentity3Desc)); |
|
142 TESTL(r == KErrAuthServIdentityNotFound); |
|
143 |
|
144 // remove an unregistered identity |
|
145 TRAP(r, db->RemoveIdentityL(KIdentity3Id)); |
|
146 TESTL(r == KErrAuthServIdentityNotFound); |
|
147 |
|
148 // remove an identity |
|
149 db->RemoveIdentityL(KIdentity1Id); |
|
150 db->IdentitiesL(ids); |
|
151 TESTL(ids.Count() == 1); |
|
152 TESTL(ids[0] == KIdentity2Id); |
|
153 TestDescriptionL(db, KIdentity2Id, KIdentity2Desc); |
|
154 |
|
155 // remove the last identity |
|
156 db->RemoveIdentityL(KIdentity2Id); |
|
157 db->IdentitiesL(ids); |
|
158 TESTL(ids.Count() == 0); |
|
159 |
|
160 // create an identity with a description to a string which is |
|
161 // too long; ensure fails. |
|
162 dbuf.Fill('a', KMaxDescLen - 1); // limit - 1 |
|
163 db->AddIdentityL(KIdentity3Id, dbuf); |
|
164 TestDescriptionL(db, KIdentity3Id, dbuf); |
|
165 db->RemoveIdentityL(KIdentity3Id); |
|
166 |
|
167 dbuf.Fill('a', KMaxDescLen); // limit |
|
168 db->AddIdentityL(KIdentity3Id, dbuf); |
|
169 TestDescriptionL(db, KIdentity3Id, dbuf); |
|
170 db->RemoveIdentityL(KIdentity3Id); |
|
171 |
|
172 dbuf.Fill('a', KMaxDescLen + 1); // limit + 1 |
|
173 TRAP(r, db->AddIdentityL(KIdentity3Id, dbuf)); |
|
174 TESTL(r == KErrAuthServDescTooLong); |
|
175 db->IdentitiesL(ids); // no identity created |
|
176 TESTL(ids.Count() == 0); |
|
177 |
|
178 CleanupStack::PopAndDestroy(db); |
|
179 __UHEAP_MARKEND; |
|
180 } |
|
181 |
|
182 void CTStepPersist2::TestDescriptionL( |
|
183 CAuthDb2* aDb, TIdentityId aIdentityId, const TDesC& aExpDesc) |
|
184 /** |
|
185 Helper function for TestIdentitiesL. Ensures the |
|
186 supplied identity has the supplied description. |
|
187 |
|
188 @param aDb Database which contains the identity. |
|
189 @param aIdentity Identity whose description should be |
|
190 retrieved. |
|
191 @param aDesc Expected description. |
|
192 */ |
|
193 { |
|
194 HBufC* desc = aDb->DescriptionL(aIdentityId); |
|
195 CleanupStack::PushL(desc); |
|
196 TESTL(*desc == aExpDesc); |
|
197 CleanupStack::PopAndDestroy(desc); |
|
198 } |
|
199 |
|
200 |
|
201 void CTStepPersist2::TestPrefsL() |
|
202 /** |
|
203 Tests adding, modifying, and removing |
|
204 preferences from the database. |
|
205 */ |
|
206 { |
|
207 TPluginId prefId; |
|
208 __UHEAP_MARK; |
|
209 |
|
210 RemoveExistingDbL(); |
|
211 CAuthDb2* db = CAuthDb2::NewLC(iFs); |
|
212 |
|
213 // get a preferred plugin for a type with no preferred plugin |
|
214 prefId = db->PreferredPluginL(EAuthBiometric); |
|
215 TESTL(prefId == KUnknownPluginId); |
|
216 |
|
217 // set a type's preferred plugin |
|
218 db->SetPreferredPluginL(EAuthBiometric, KPlugin1Id); |
|
219 prefId = db->PreferredPluginL(EAuthBiometric); |
|
220 TESTL(prefId == KPlugin1Id); |
|
221 |
|
222 // change a type's preferred plugin |
|
223 db->SetPreferredPluginL(EAuthBiometric, KPlugin2Id); |
|
224 prefId = db->PreferredPluginL(EAuthBiometric); |
|
225 TESTL(prefId == KPlugin2Id); |
|
226 |
|
227 // clear a type's preferred plugin |
|
228 db->ClearPreferredPluginL(EAuthBiometric); |
|
229 prefId = db->PreferredPluginL(EAuthBiometric); |
|
230 TESTL(prefId == KUnknownPluginId); |
|
231 |
|
232 // set preferred plugin for more than one type |
|
233 db->SetPreferredPluginL(EAuthBiometric, KPlugin3Id); |
|
234 db->SetPreferredPluginL(EAuthKnowledge, KPlugin4Id); |
|
235 prefId = db->PreferredPluginL(EAuthBiometric); |
|
236 TESTL(prefId == KPlugin3Id); |
|
237 prefId = db->PreferredPluginL(EAuthKnowledge); |
|
238 TESTL(prefId == KPlugin4Id); |
|
239 |
|
240 CleanupStack::PopAndDestroy(db); |
|
241 |
|
242 __UHEAP_MARKEND; |
|
243 } |
|
244 |
|
245 |
|
246 void CTStepPersist2::TestTrainedPluginsL() |
|
247 /** |
|
248 Test adding and removing trained plugins. |
|
249 */ |
|
250 { |
|
251 __UHEAP_MARK; |
|
252 |
|
253 TInt r; |
|
254 RemoveExistingDbL(); |
|
255 CAuthDb2* db = CAuthDb2::NewLC(iFs); |
|
256 |
|
257 const CTransientKeyInfo& tkiA = *iId1Keys[0]; |
|
258 const CTransientKeyInfo& tkiB = *iId1Keys[1]; |
|
259 const CTransientKeyInfo& tkiC = *iId1Keys[2]; |
|
260 |
|
261 // set key info for an unregistered identity |
|
262 TRAP(r, db->SetTrainedPluginL(KIdentity1Id, KPluginAId, tkiA)); |
|
263 TESTL(r == KErrAuthServIdentityNotFound); |
|
264 |
|
265 // set key info for a registered identity |
|
266 db->AddIdentityL(KIdentity1Id, KIdentity1Desc); |
|
267 db->SetTrainedPluginL(KIdentity1Id, KPluginAId, tkiA); |
|
268 |
|
269 // get key info for a trained identity |
|
270 TestKeyPresentL(db, KIdentity1Id, KPluginAId, tkiA); |
|
271 |
|
272 // change key info for a trained identity |
|
273 db->SetTrainedPluginL(KIdentity1Id, KPluginAId, tkiB); |
|
274 TestKeyPresentL(db, KIdentity1Id, KPluginAId, tkiB); |
|
275 |
|
276 // ---- bad KeyInfoL args ---- |
|
277 |
|
278 // get key info for registered identity but untrained plugin |
|
279 TRAP(r, db->KeyInfoL(KIdentity1Id, KPluginBId)) |
|
280 TESTL(r == KErrAuthServTrainingNotFound); |
|
281 |
|
282 // get key info for unregistered identity but trained plugin |
|
283 TRAP(r, db->KeyInfoL(KIdentity3Id, KPluginAId)) |
|
284 TESTL(r == KErrAuthServTrainingNotFound); |
|
285 |
|
286 // get key info for unregistered identity and untrained plugin |
|
287 TRAP(r, db->KeyInfoL(KIdentity3Id, KPluginBId)); |
|
288 TESTL(r == KErrAuthServTrainingNotFound); |
|
289 |
|
290 // ---- bad RemoveTrainedPluginL args ---- |
|
291 |
|
292 // clear key info for registered identity but untrained plugin |
|
293 TRAP(r, db->KeyInfoL(KIdentity1Id, KPluginBId)) |
|
294 TESTL(r == KErrAuthServTrainingNotFound); |
|
295 |
|
296 // clear key info for unregistered identity but trained plugin |
|
297 TRAP(r, db->RemoveTrainedPluginL(KIdentity3Id, KPluginAId)) |
|
298 TESTL(r == KErrAuthServTrainingNotFound); |
|
299 |
|
300 // clear key info for unregistered identity and untrained plugin |
|
301 TRAP(r, db->RemoveTrainedPluginL(KIdentity3Id, KPluginBId)); |
|
302 TESTL(r == KErrAuthServTrainingNotFound); |
|
303 |
|
304 // ----- |
|
305 |
|
306 // clear a present trained plugin |
|
307 db->RemoveTrainedPluginL(KIdentity1Id, KPluginAId); |
|
308 TRAP(r, db->KeyInfoL(KIdentity3Id, KPluginAId)) |
|
309 TESTL(r == KErrAuthServTrainingNotFound); |
|
310 |
|
311 // register multiple trained plugins for a single identity |
|
312 db->SetTrainedPluginL(KIdentity1Id, KPluginAId, tkiA); |
|
313 db->SetTrainedPluginL(KIdentity1Id, KPluginBId, tkiB); |
|
314 TestKeyPresentL(db, KIdentity1Id, KPluginAId, tkiA); |
|
315 TestKeyPresentL(db, KIdentity1Id, KPluginAId, tkiB); |
|
316 |
|
317 // train a single plugin for multiple identities |
|
318 db->AddIdentityL(KIdentity2Id, KIdentity2Desc); |
|
319 db->SetTrainedPluginL(KIdentity2Id, KPluginAId, tkiC); |
|
320 TestKeyPresentL(db, KIdentity1Id, KPluginAId, tkiA); |
|
321 TestKeyPresentL(db, KIdentity1Id, KPluginBId, tkiB); |
|
322 TestKeyPresentL(db, KIdentity2Id, KPluginAId, tkiC); |
|
323 |
|
324 // ---- atomic identity and key addition ---- |
|
325 |
|
326 // add identity with trained plugin |
|
327 db->AddIdentityWithTrainedPluginL(KIdentity3Id, KIdentity3Desc, tkiA); |
|
328 TestKeyPresentL(db, KIdentity3Id, tkiA.PluginId(), tkiA); |
|
329 |
|
330 // fail to add identity with trained plugin - id already exists |
|
331 TRAP(r, db->AddIdentityWithTrainedPluginL(KIdentity3Id, KIdentity3Desc, tkiA)); |
|
332 TESTL(r == KErrAuthServIdentityAlreadyExists); |
|
333 |
|
334 CleanupStack::PopAndDestroy(db); |
|
335 |
|
336 __UHEAP_MARKEND; |
|
337 } |
|
338 |
|
339 |
|
340 void CTStepPersist2::TestKeyPresentL( |
|
341 CAuthDb2* aAuthDb, TIdentityId aIdentityId, TPluginId aPluginId, |
|
342 const CTransientKeyInfo& aTarget) |
|
343 /** |
|
344 Helper function for TestTrainedPluginsL. |
|
345 |
|
346 Test the described transient key exists in the database, |
|
347 and that is is equal to the supplied key. Leaves if not |
|
348 the case. |
|
349 |
|
350 @param aAuthDb Authorisation database to retrieve |
|
351 transient key info from. |
|
352 @param aIdentityId Identity which should be trained for |
|
353 the supplied plugin. |
|
354 @param aPluginId Plugin for which the supplied identity |
|
355 should be trained. |
|
356 @param aTarget The retrieved transient key info should |
|
357 be equal to this. |
|
358 */ |
|
359 { |
|
360 CTransientKeyInfo* tkiActual = aAuthDb->KeyInfoL(aIdentityId, aPluginId); |
|
361 CleanupStack::PushL(tkiActual); |
|
362 |
|
363 // ensure key infos have same externalized size |
|
364 TSizeStream ssTarget; |
|
365 RWriteStream wsTarget(&ssTarget); |
|
366 aTarget.ExternalizeL(wsTarget); |
|
367 TInt targetSize = ssTarget.Size(); |
|
368 |
|
369 TSizeStream ssActual; |
|
370 RWriteStream wsActual(&ssActual); |
|
371 tkiActual->ExternalizeL(wsActual); |
|
372 TESTL(targetSize == ssActual.Size()); |
|
373 |
|
374 HBufC8* targetBuf = HBufC8::NewLC(targetSize); |
|
375 TPtr8 targetBufDes = targetBuf->Des(); |
|
376 RDesWriteStream dwsTarget(targetBufDes); |
|
377 aTarget.ExternalizeL(dwsTarget); |
|
378 |
|
379 HBufC8* actualBuf = HBufC8::NewLC(targetSize); |
|
380 TPtr8 actualBufDes = actualBuf->Des(); |
|
381 RDesWriteStream dwsActual(actualBufDes); |
|
382 tkiActual->ExternalizeL(dwsActual); |
|
383 |
|
384 TESTL(targetBufDes == actualBufDes); |
|
385 |
|
386 CleanupStack::PopAndDestroy(3, tkiActual); |
|
387 } |
|
388 |
|
389 |
|
390 void CTStepPersist2::TestTrainingStatusL() |
|
391 /** |
|
392 Test the plugins' training statuses accurately |
|
393 reflect the identities which are registered |
|
394 with them. |
|
395 */ |
|
396 { |
|
397 __UHEAP_MARK; |
|
398 |
|
399 RemoveExistingDbL(); |
|
400 |
|
401 CAuthDb2* db = CAuthDb2::NewLC(iFs); |
|
402 |
|
403 // if there are no users then a plugin should be marked |
|
404 // as untrained, even though its training count is equal |
|
405 // to the number of registered identities. |
|
406 TESTL(db->PluginStatusL(KPluginAId) == EAuthUntrained); |
|
407 |
|
408 // untrained when no users trained |
|
409 db->AddIdentityL(KIdentity1Id, KIdentity1Desc); |
|
410 TESTL(db->PluginStatusL(KPluginAId) == EAuthUntrained); |
|
411 db->AddIdentityL(KIdentity2Id, KIdentity2Desc); |
|
412 TESTL(db->PluginStatusL(KPluginAId) == EAuthUntrained); |
|
413 |
|
414 // trained when some, but not all, users trained |
|
415 const CTransientKeyInfo& tkiA = *iId1Keys[0]; |
|
416 db->SetTrainedPluginL(KIdentity1Id, KPluginAId, tkiA); |
|
417 TESTL(db->PluginStatusL(KPluginAId) == EAuthTrained); |
|
418 |
|
419 // fully trained when all users trained |
|
420 db->SetTrainedPluginL(KIdentity2Id, KPluginAId, tkiA); |
|
421 TESTL(db->PluginStatusL(KPluginAId) == EAuthFullyTrained); |
|
422 |
|
423 // back to trained when identity untrained |
|
424 db->RemoveTrainedPluginL(KIdentity1Id, KPluginAId); |
|
425 TESTL(db->PluginStatusL(KPluginAId) == EAuthTrained); |
|
426 |
|
427 // back to untrained when last training removed |
|
428 db->RemoveTrainedPluginL(KIdentity2Id, KPluginAId); |
|
429 TESTL(db->PluginStatusL(KPluginAId) == EAuthUntrained); |
|
430 |
|
431 // restored to trained when identity trained |
|
432 db->SetTrainedPluginL(KIdentity1Id, KPluginAId, tkiA); |
|
433 TESTL(db->PluginStatusL(KPluginAId) == EAuthTrained); |
|
434 |
|
435 // restored to fully trained when last identity trained |
|
436 db->SetTrainedPluginL(KIdentity2Id, KPluginAId, tkiA); |
|
437 TESTL(db->PluginStatusL(KPluginAId) == EAuthFullyTrained); |
|
438 |
|
439 // back to trained when new identity added |
|
440 db->AddIdentityL(KIdentity3Id, KIdentity3Desc); |
|
441 TESTL(db->PluginStatusL(KPluginAId) == EAuthTrained); |
|
442 |
|
443 // upgraded to fully trained when untrained identity removed |
|
444 db->RemoveIdentityL(KIdentity3Id); |
|
445 TESTL(db->PluginStatusL(KPluginAId) == EAuthFullyTrained); |
|
446 |
|
447 // kept at fully trained when trained identity removed |
|
448 db->RemoveIdentityL(KIdentity2Id); |
|
449 TESTL(db->PluginStatusL(KPluginAId) == EAuthFullyTrained); |
|
450 |
|
451 // drop to untrained when last identity removed |
|
452 db->RemoveIdentityL(KIdentity1Id); |
|
453 TESTL(db->PluginStatusL(KPluginAId) == EAuthUntrained); |
|
454 |
|
455 CleanupStack::PopAndDestroy(db); |
|
456 |
|
457 __UHEAP_MARKEND; |
|
458 } |
|
459 |
|
460 |
|
461 static void IdToTestDesc(TIdentityId aId, TDes& aDesc) |
|
462 /** |
|
463 Helper function for TestRepairL generates a description |
|
464 from the supplied identity. |
|
465 |
|
466 @param aId Identity Id. |
|
467 @param aDesc Out paramater is populated with |
|
468 description text. |
|
469 */ |
|
470 { |
|
471 _LIT(KDescFmt, "desc_%08x"); |
|
472 aDesc.Format(KDescFmt, aId); |
|
473 } |
|
474 |
|
475 |
|
476 void CTStepPersist2::TestRepairL() |
|
477 /** |
|
478 Test CAuthDb repairs the database if possible. |
|
479 */ |
|
480 { |
|
481 RemoveExistingDbL(); |
|
482 |
|
483 CAuthDb2* db = CAuthDb2::NewLC(iFs); |
|
484 |
|
485 // create a set of identities |
|
486 const TInt KTestIdCount = 8; |
|
487 for (TInt i = 1; i <= KTestIdCount; ++i) |
|
488 { |
|
489 TBuf<13> buf; |
|
490 IdToTestDesc(i, buf); |
|
491 db->AddIdentityL(i, buf); |
|
492 } |
|
493 CleanupStack::PopAndDestroy(db); |
|
494 |
|
495 // damage the database by inserting a new entry but then |
|
496 // rolling it back. |
|
497 RDbNamedDatabase ndb; |
|
498 TFileName dbName(KDbName); |
|
499 dbName[0] = RFs::GetSystemDriveChar(); |
|
500 |
|
501 User::LeaveIfError(ndb.Open(iFs, dbName)); |
|
502 CleanupClosePushL(ndb); |
|
503 |
|
504 User::LeaveIfError(ndb.Begin()); |
|
505 |
|
506 RDbTable table; |
|
507 CleanupClosePushL(table); |
|
508 User::LeaveIfError(table.Open(ndb, KIdentitiesTableName)); |
|
509 |
|
510 table.InsertL(); |
|
511 table.SetColL(KIdentitiesIdentityIdCol, KTestIdCount+1); |
|
512 table.SetColL(KIdentitiesDescCol, _L("descb")); |
|
513 table.PutL(); |
|
514 table.Close(); |
|
515 ndb.Rollback(); |
|
516 TESTL(ndb.IsDamaged()); |
|
517 |
|
518 CleanupStack::PopAndDestroy(2, &ndb); // table ndb |
|
519 |
|
520 // ensure db contains the same identities when it |
|
521 // is reopened. |
|
522 db = CAuthDb2::NewLC(iFs); |
|
523 |
|
524 RArray<TIdentityId> ids; |
|
525 db->IdentitiesL(ids); |
|
526 TInt idCount = ids.Count(); |
|
527 ids.Reset(); |
|
528 TESTL(idCount == KTestIdCount); |
|
529 |
|
530 for (TInt index = 1; index <= KTestIdCount; ++index) |
|
531 { |
|
532 TBuf<13> bufExp; |
|
533 IdToTestDesc(index, bufExp); |
|
534 TBuf<KMaxDescLen> actDesc; |
|
535 HBufC* descAct = db->DescriptionL(index); |
|
536 CleanupStack::PushL(descAct); |
|
537 TESTL(bufExp == *descAct); |
|
538 CleanupStack::PopAndDestroy(descAct); |
|
539 } |
|
540 CleanupStack::PopAndDestroy(db); |
|
541 } |
|
542 |
|
543 |
|
544 void CTStepPersist2::TestCompressL() |
|
545 /** |
|
546 Creates and deletes identities to create unused |
|
547 space in database file, and tests compressed. |
|
548 */ |
|
549 { |
|
550 RemoveExistingDbL(); |
|
551 CAuthDb2* db = CAuthDb2::NewLC(iFs); |
|
552 |
|
553 const TInt KIdentityCount = 32; |
|
554 for (TInt i = 0; i < KIdentityCount; ++i) |
|
555 { |
|
556 _LIT(KCompDesc, "tc-test"); |
|
557 db->AddIdentityL(i, KCompDesc); |
|
558 db->RemoveIdentityL(i); |
|
559 } |
|
560 CleanupStack::PopAndDestroy(db); |
|
561 |
|
562 TInt szPreComp = DbFileSizeL(); |
|
563 |
|
564 db = CAuthDb2::NewLC(iFs); |
|
565 db->CompactIfRequired(); |
|
566 CleanupStack::PopAndDestroy(db); |
|
567 |
|
568 TInt szPostComp = DbFileSizeL(); |
|
569 |
|
570 TESTL(szPreComp > szPostComp); |
|
571 } |
|
572 |
|
573 |
|
574 TInt CTStepPersist2::DbFileSizeL() |
|
575 /** |
|
576 Helper function for TestCompressL returns |
|
577 the size of the database file in bytes. |
|
578 */ |
|
579 { |
|
580 RFile f; |
|
581 TFileName dbName(KDbName); |
|
582 dbName[0] = RFs::GetSystemDriveChar(); |
|
583 |
|
584 User::LeaveIfError(f.Open(iFs, dbName, EFileRead | EFileStream)); |
|
585 CleanupClosePushL(f); |
|
586 |
|
587 TInt sz; |
|
588 User::LeaveIfError(f.Size(sz)); |
|
589 CleanupStack::PopAndDestroy(&f); |
|
590 |
|
591 return sz; |
|
592 } |
|
593 |
|
594 |
|
595 |
|