|
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 // e32test\demandpaging\t_tbus_datapaging.cpp |
|
15 // Functional tests for data paging. |
|
16 // 002 ??? |
|
17 // 003 ??? |
|
18 // |
|
19 |
|
20 //! @SYMTestCaseID KBASE-T_TBUS_DATAPAGING |
|
21 //! @SYMTestType UT |
|
22 //! @SYMPREQ ??? |
|
23 //! @SYMTestCaseDesc Data Paging functional tests with TBusLocalDrive. |
|
24 //! @SYMTestActions 001 ??? |
|
25 //! @SYMTestExpectedResults All tests should pass. |
|
26 //! @SYMTestPriority High |
|
27 //! @SYMTestStatus Implementation on-going |
|
28 |
|
29 #define __E32TEST_EXTENSION__ |
|
30 #include <e32test.h> |
|
31 #include <dptest.h> |
|
32 #include <e32hal.h> |
|
33 #include <u32exec.h> |
|
34 #include <e32svr.h> |
|
35 #include <e32panic.h> |
|
36 #include "u32std.h" |
|
37 |
|
38 #include <f32file.h> |
|
39 #include <f32dbg.h> |
|
40 #include <f32fsys.h> |
|
41 |
|
42 #include "t_dpcmn.h" |
|
43 #include "../secure/d_sldd.h" |
|
44 #include "../mmu/mmudetect.h" |
|
45 |
|
46 const TInt KMaxLengthOfStoreMapping = 16 + sizeof(TInt32) + KMaxMediaPassword; |
|
47 const TInt KMaxPersistentStore(TPasswordStore::EMaxPasswordLength+KMaxLengthOfStoreMapping); |
|
48 typedef TBuf8<KMaxPersistentStore> TPersistentStore; |
|
49 |
|
50 RChunk gMyChunk; |
|
51 TUint gOffset = 0; |
|
52 TUint8* gData = NULL; |
|
53 const TUint8 KClearValue = 0xed; |
|
54 const TUint KChunkSizeInPages = 64; // 64 * 4096 = 256K |
|
55 const TInt KTestBufLen=256; |
|
56 |
|
57 |
|
58 #define __DECLARE_VAR_IN_CHUNK(type, varRef) \ |
|
59 type varRef = *(type*) (gData+gOffset); \ |
|
60 gOffset += Max(gPageSize, sizeof(type)); \ |
|
61 test(gOffset <= gPageSize * KChunkSizeInPages); |
|
62 |
|
63 #define __DECLARE_AND_INIT_VAR_IN_CHUNK(type, var) \ |
|
64 type &var = *(type*) (gData+gOffset); \ |
|
65 var = type(); \ |
|
66 gOffset += Max(gPageSize, sizeof(type)); \ |
|
67 test(gOffset <= gPageSize * KChunkSizeInPages); |
|
68 |
|
69 |
|
70 #define __DECLARE_ARRAY_IN_CHUNK(type, var, size) \ |
|
71 type *var = (type*) (gData+gOffset); \ |
|
72 gOffset += Max(gPageSize, (sizeof(type) * size)); \ |
|
73 test(gOffset <= gPageSize * KChunkSizeInPages); |
|
74 |
|
75 #define __FLUSH_AND_CALL_API_METHOD(return, function) \ |
|
76 DPTest::FlushCache(); \ |
|
77 return = function; |
|
78 |
|
79 |
|
80 LOCAL_D RFs TheFs; |
|
81 TInt gFsDriveNumber = -1; |
|
82 |
|
83 RTest test(_L("T_TBUS_DATAPAGING")); |
|
84 _LIT(KChunkName, "t_datapaging chunk"); |
|
85 |
|
86 const TUint KDriveAttMask = KDriveAttLocal | KDriveAttRom | KDriveAttRemote; |
|
87 const TUint KMediaAttMask = KMediaAttVariableSize | KMediaAttDualDensity | KMediaAttLockable | KMediaAttLocked | KMediaAttHasPassword | KMediaAttReadWhileWrite; |
|
88 |
|
89 void CreatePagedChunk(TInt aSizeInPages, TInt aWipeByte = -1) |
|
90 { |
|
91 test_Equal(0,gMyChunk.Handle()); |
|
92 |
|
93 TChunkCreateInfo createInfo; |
|
94 TInt size = aSizeInPages * gPageSize; |
|
95 createInfo.SetNormal(size, size); |
|
96 createInfo.SetPaging(TChunkCreateInfo::EPaged); |
|
97 createInfo.SetOwner(EOwnerProcess); |
|
98 createInfo.SetGlobal(KChunkName); |
|
99 if (aWipeByte != -1) |
|
100 createInfo.SetClearByte(aWipeByte); |
|
101 test_KErrNone(gMyChunk.Create(createInfo)); |
|
102 test(gMyChunk.IsPaged()); // this is only ever called if data paging is supported |
|
103 |
|
104 gData = gMyChunk.Base(); |
|
105 } |
|
106 |
|
107 TInt TestDriveConnectAndCaps(TBusLocalDrive &aDrive, TInt &aLocalDriveNumber) |
|
108 { |
|
109 |
|
110 test.Next(_L("Test Drive Connect And Caps")); |
|
111 |
|
112 __DECLARE_VAR_IN_CHUNK(TInt, &r); |
|
113 |
|
114 test.Printf(_L("changeFlag...\n")); |
|
115 __DECLARE_VAR_IN_CHUNK(TBool, &changeFlag); |
|
116 changeFlag = EFalse; |
|
117 |
|
118 test.Printf(_L("call aDrive.Connect()...\n")); |
|
119 __FLUSH_AND_CALL_API_METHOD(r, aDrive.Connect(aLocalDriveNumber,changeFlag)); |
|
120 |
|
121 test.Printf(_L("r:%d\n"),r); |
|
122 test_Equal(KErrNone, r); |
|
123 |
|
124 test.Printf(_L("call aDrive.Caps()...\n")); |
|
125 __DECLARE_VAR_IN_CHUNK(TLocalDriveCapsV5, &driveCaps); |
|
126 |
|
127 TPckg<TLocalDriveCapsV5> capsPckg(driveCaps); |
|
128 __FLUSH_AND_CALL_API_METHOD(r, aDrive.Caps(capsPckg)); |
|
129 |
|
130 test_Equal(KErrNone, r); |
|
131 test.Printf(_L("r:%d\n"),r); |
|
132 test.Printf(_L("driveCaps.iDriveAtt :0x%08x\n"), driveCaps.iDriveAtt); |
|
133 test.Printf(_L("driveCaps.iSize :%ld\n"), driveCaps.iSize); |
|
134 test.Printf(_L("driveCaps.iSerialNumLength :%d\n"), driveCaps.iSerialNumLength); |
|
135 |
|
136 return I64LOW(driveCaps.iSize); |
|
137 } |
|
138 |
|
139 void TestDriveSizeRelatedMethods(TBusLocalDrive &aDrive, TInt aNewSize, TInt aOldSize) |
|
140 { |
|
141 TInt r; |
|
142 |
|
143 test.Next(_L("Test Drive Size Related Methods")); |
|
144 test.Printf(_L("newDriveSize...\n")); |
|
145 __DECLARE_VAR_IN_CHUNK(TInt, &newDriveSize); |
|
146 newDriveSize = aNewSize; |
|
147 |
|
148 test.Printf(_L("call aDrive.Enlarge()...\n")); |
|
149 __FLUSH_AND_CALL_API_METHOD(r, aDrive.Enlarge(newDriveSize)); |
|
150 test.Printf(_L("r:%d\n"),r); |
|
151 test((KErrNone == r) || (KErrNotSupported == r) || (KErrNotReady == r)); |
|
152 if(r != KErrNone ) |
|
153 { |
|
154 test.Printf(_L("errInfo...\n")); |
|
155 __DECLARE_ARRAY_IN_CHUNK(TUint8, errInfo, KTestBufLen); |
|
156 |
|
157 TPtr8 pErrInfoBuff(errInfo, KTestBufLen); |
|
158 |
|
159 __FLUSH_AND_CALL_API_METHOD(r, aDrive.GetLastErrorInfo(pErrInfoBuff)); |
|
160 test.Printf(_L("r:%d\n"),r); |
|
161 test((KErrNone == r) || (KErrNotSupported == r)); |
|
162 } |
|
163 |
|
164 |
|
165 test.Printf(_L("call aDrive.ReduceSize()...\n")); |
|
166 __FLUSH_AND_CALL_API_METHOD(r, aDrive.ReduceSize(0, aOldSize)); |
|
167 test((KErrNone == r) || (KErrNotSupported == r) || (KErrNotReady == r)); |
|
168 |
|
169 } |
|
170 |
|
171 void TestWriteReadRelatedMethods(TBusLocalDrive &aDrive) |
|
172 { |
|
173 |
|
174 test.Next(_L("Test Write & Read Related Methods")); |
|
175 |
|
176 __DECLARE_VAR_IN_CHUNK(TInt, &r); |
|
177 |
|
178 test.Printf(_L("msgHandle...\n")); |
|
179 __DECLARE_VAR_IN_CHUNK(TInt, &msgHandle); |
|
180 msgHandle = KLocalMessageHandle; |
|
181 |
|
182 |
|
183 __DECLARE_VAR_IN_CHUNK(TUint, &i); |
|
184 test.Printf(_L("wrBuf...\n")); |
|
185 TBuf8<KTestBufLen> wrBuf(KTestBufLen); |
|
186 for (i=0 ; i<(TUint)KTestBufLen ; i++) |
|
187 wrBuf[i]=(TUint8)i; |
|
188 |
|
189 |
|
190 test.Printf(_L("wrBuf2...\n")); |
|
191 __DECLARE_ARRAY_IN_CHUNK(TUint8, wrBuf2, KTestBufLen); |
|
192 |
|
193 test.Printf(_L("fill wrBuf2...\n")); |
|
194 for (i=0 ; i<(TUint)KTestBufLen ; i++) |
|
195 wrBuf2[i]=(TUint8)i; |
|
196 |
|
197 TPtr8 pWrBuf2(wrBuf2, KTestBufLen, KTestBufLen); |
|
198 |
|
199 test.Printf(_L("rdBuf...\n")); |
|
200 TBuf8<KTestBufLen> rdBuf(KTestBufLen); |
|
201 |
|
202 |
|
203 test.Printf(_L("rdBuf2...\n")); |
|
204 __DECLARE_ARRAY_IN_CHUNK(TUint8, rdBuf2, KTestBufLen); |
|
205 |
|
206 TPtr8 pRdBuf2(rdBuf2, KTestBufLen); |
|
207 |
|
208 test.Printf(_L("call aDrive.Write()...\n")); |
|
209 rdBuf.Fill(0,KTestBufLen); |
|
210 __FLUSH_AND_CALL_API_METHOD(r, aDrive.Write(0,KTestBufLen,&wrBuf,msgHandle,0)); |
|
211 test_Equal(KErrNone, r); |
|
212 |
|
213 |
|
214 test.Printf(_L("call aDrive.Read()...\n")); |
|
215 __FLUSH_AND_CALL_API_METHOD(r, aDrive.Read(0,KTestBufLen,&rdBuf,msgHandle,0)); |
|
216 test_Equal(KErrNone, r); |
|
217 |
|
218 for (i=0 ; i<(TUint)KTestBufLen ; i++) |
|
219 test_Equal(wrBuf[i], rdBuf[i]); |
|
220 |
|
221 test.Printf(_L("call aDrive.Write()...\n")); |
|
222 pRdBuf2.Fill(0,KTestBufLen); |
|
223 __FLUSH_AND_CALL_API_METHOD(r, aDrive.Write(0,pWrBuf2)); |
|
224 test_Equal(KErrNone, r); |
|
225 |
|
226 |
|
227 test.Printf(_L("call aDrive.Read()...\n")); |
|
228 __FLUSH_AND_CALL_API_METHOD(r, aDrive.Read(0,KTestBufLen, pRdBuf2)); |
|
229 test_Equal(KErrNone, r); |
|
230 |
|
231 for (i=0 ; i<(TUint)KTestBufLen ; i++) |
|
232 test_Equal(wrBuf2[i], rdBuf2[i]); |
|
233 |
|
234 } |
|
235 |
|
236 void TestPasswordRelatedMethods(TBusLocalDrive &aDrive) |
|
237 { |
|
238 TInt r; |
|
239 |
|
240 test.Next(_L("Test Password Related Methods")); |
|
241 //__DECLARE_VAR_IN_CHUNK(TPersistentStore, &wStore); |
|
242 |
|
243 TPersistentStore* pstoreAB; |
|
244 test((pstoreAB = new TPersistentStore) != 0); |
|
245 TPersistentStore& wStore = *pstoreAB; |
|
246 |
|
247 //__DECLARE_AND_INIT_VAR_IN_CHUNK(TPersistentStore, wStore); |
|
248 |
|
249 // Password related API methods call |
|
250 test.Printf(_L("call aDrive.WritePasswordData() to clear passwords...\n")); |
|
251 __DECLARE_VAR_IN_CHUNK(TInt, &passwordStoreLength); |
|
252 |
|
253 TBuf8<1> nulSt; |
|
254 __FLUSH_AND_CALL_API_METHOD(r, aDrive.WritePasswordData(nulSt)); |
|
255 test( r == KErrNone);// empty |
|
256 |
|
257 test.Printf(_L("call aDrive.PasswordStoreLengthInBytes()...\n")); |
|
258 __FLUSH_AND_CALL_API_METHOD(passwordStoreLength, aDrive.PasswordStoreLengthInBytes()); |
|
259 |
|
260 test.Printf(_L("passwordStoreLength:%d\n"), passwordStoreLength); |
|
261 test_Equal(0, passwordStoreLength); |
|
262 |
|
263 |
|
264 test.Printf(_L("call aDrive.ErasePassword()...\n")); |
|
265 __FLUSH_AND_CALL_API_METHOD(r, aDrive.ErasePassword()); |
|
266 test.Printf(_L("r:%d\n"),r); |
|
267 |
|
268 |
|
269 test.Printf(_L("wStore.Size():%d\n"),wStore.Size()); |
|
270 __FLUSH_AND_CALL_API_METHOD(r, aDrive.WritePasswordData(wStore)); |
|
271 |
|
272 test.Printf(_L("r:%d\n"),r); |
|
273 test((KErrNone == r)); // || (KErrCorrupt == r)); // TO-DO Why Corrupt??? |
|
274 |
|
275 __FLUSH_AND_CALL_API_METHOD(passwordStoreLength, aDrive.PasswordStoreLengthInBytes()); |
|
276 |
|
277 test.Printf(_L("passwordStoreLength:%d\n"), passwordStoreLength); |
|
278 test((r == KErrNone ? (wStore.Size() == passwordStoreLength) : (0 == passwordStoreLength) )); |
|
279 |
|
280 |
|
281 |
|
282 test.Printf(_L("Set and store a password...\n")); |
|
283 TDes8 &st = wStore; |
|
284 TMediaPassword a((const TUint8*) "CID0ccccccccccc#"); |
|
285 TUint8 passLen[sizeof(TInt32)]; |
|
286 passLen[0] = 0; |
|
287 passLen[1] = 0; |
|
288 passLen[2] = 0; |
|
289 passLen[3] = 16; |
|
290 |
|
291 //test.Printf(_L("Password3:'%S'\n"), &a); |
|
292 |
|
293 st.Append(a); |
|
294 st.Append(passLen, sizeof(TInt32)); |
|
295 st.Append(a); |
|
296 |
|
297 test.Printf(_L("wStore.Size():%d\n"),wStore.Size()); |
|
298 __FLUSH_AND_CALL_API_METHOD(r, aDrive.WritePasswordData(wStore)); |
|
299 |
|
300 test.Printf(_L("r:%d\n"),r); |
|
301 test((KErrNone == r)); |
|
302 |
|
303 __FLUSH_AND_CALL_API_METHOD(passwordStoreLength, aDrive.PasswordStoreLengthInBytes()); |
|
304 |
|
305 test.Printf(_L("passwordStoreLength:%d\n"), passwordStoreLength); |
|
306 test((r == KErrNone ? (wStore.Size() == passwordStoreLength) : (0 == passwordStoreLength) )); |
|
307 |
|
308 test.Printf(_L("call aDrive.ErasePassword()...\n")); |
|
309 __FLUSH_AND_CALL_API_METHOD(r, aDrive.ErasePassword()); |
|
310 test.Printf(_L("r:%d\n"),r); |
|
311 |
|
312 test.Printf(_L("call aDrive.WritePasswordData() to set password again...\n")); |
|
313 test.Printf(_L("wStore.Size():%d\n"),wStore.Size()); |
|
314 __FLUSH_AND_CALL_API_METHOD(r, aDrive.WritePasswordData(wStore)); |
|
315 |
|
316 test.Printf(_L("r:%d\n"),r); |
|
317 test((KErrNone == r)); |
|
318 |
|
319 __FLUSH_AND_CALL_API_METHOD(passwordStoreLength, aDrive.PasswordStoreLengthInBytes()); |
|
320 |
|
321 test.Printf(_L("passwordStoreLength:%d\n"), passwordStoreLength); |
|
322 test((r == KErrNone ? (wStore.Size() == passwordStoreLength) : (0 == passwordStoreLength) )); |
|
323 |
|
324 |
|
325 // Finally erase password |
|
326 test.Printf(_L("call aDrive.WritePasswordData() to erase password...\n")); |
|
327 wStore.Zero(); // empty password store |
|
328 __FLUSH_AND_CALL_API_METHOD(r, aDrive.WritePasswordData(wStore)) |
|
329 test( r == KErrNone);// Clear |
|
330 |
|
331 __FLUSH_AND_CALL_API_METHOD(passwordStoreLength, aDrive.PasswordStoreLengthInBytes()); |
|
332 |
|
333 test.Printf(_L("passwordStoreLength:%d\n"), passwordStoreLength); |
|
334 test((r == KErrNone ? (wStore.Size() == passwordStoreLength) : (0 == passwordStoreLength) )); |
|
335 |
|
336 |
|
337 |
|
338 // Test SetPassword |
|
339 TMediaPassword nul(nulSt); |
|
340 |
|
341 test.Printf(_L("call aDrive.SetPassword()...\n")); |
|
342 __FLUSH_AND_CALL_API_METHOD(r, aDrive.SetPassword(nul, a, EFalse)); |
|
343 test.Printf(_L("r:%d\n"),r); |
|
344 test_Equal(KErrNone, r); |
|
345 |
|
346 // Erase Password |
|
347 test.Printf(_L("call aDrive.ErasePassword()...\n")); |
|
348 __FLUSH_AND_CALL_API_METHOD(r, aDrive.ErasePassword()); |
|
349 test.Printf(_L("r:%d\n"),r); |
|
350 |
|
351 |
|
352 test.Printf(_L("call aDrive.SetPassword()...\n")); |
|
353 __FLUSH_AND_CALL_API_METHOD(r, aDrive.SetPassword(nul, a, EFalse)); |
|
354 test.Printf(_L("r:%d\n"),r); |
|
355 test_Equal(KErrNone, r); |
|
356 |
|
357 // Erase Clear |
|
358 test.Printf(_L("call aDrive.Clear()...\n")); |
|
359 __FLUSH_AND_CALL_API_METHOD(r, aDrive.Clear(a)); |
|
360 test.Printf(_L("r:%d\n"),r); |
|
361 |
|
362 |
|
363 test.Printf(_L("call aDrive.SetPassword() to clear again...\n")); |
|
364 __FLUSH_AND_CALL_API_METHOD(r, aDrive.SetPassword(a, nul, EFalse)); |
|
365 test.Printf(_L("r:%d\n"),r); |
|
366 test_Equal(KErrAccessDenied, r); |
|
367 |
|
368 |
|
369 // Finally erase password |
|
370 test.Printf(_L("call aDrive.WritePasswordData() to erase password...\n")); |
|
371 wStore.Zero(); // empty password store |
|
372 __FLUSH_AND_CALL_API_METHOD(r, aDrive.WritePasswordData(wStore)) |
|
373 test( r == KErrNone);// Clear |
|
374 |
|
375 __FLUSH_AND_CALL_API_METHOD(passwordStoreLength, aDrive.PasswordStoreLengthInBytes()); |
|
376 |
|
377 test.Printf(_L("passwordStoreLength:%d\n"), passwordStoreLength); |
|
378 test((r == KErrNone ? (wStore.Size() == passwordStoreLength) : (0 == passwordStoreLength) )); |
|
379 |
|
380 } |
|
381 |
|
382 void TestFormatRelatedMethods(TBusLocalDrive &aDrive, TInt aSize ) |
|
383 { |
|
384 test.Next(_L("Test Format Related Methods")); |
|
385 |
|
386 test.Printf(_L("call aDrive.Format(TFormatInfo)...\n")); |
|
387 __DECLARE_AND_INIT_VAR_IN_CHUNK(TFormatInfo, fi); |
|
388 __DECLARE_VAR_IN_CHUNK(TInt, &ret); |
|
389 __DECLARE_VAR_IN_CHUNK(TInt, &attempt); |
|
390 |
|
391 __FLUSH_AND_CALL_API_METHOD(ret, aDrive.Format(fi)); |
|
392 test.Printf(_L("ret:%d\n"),ret); |
|
393 while(ret!=KErrEof) |
|
394 { |
|
395 if( ret == KErrNotReady ) |
|
396 { |
|
397 attempt = 100; |
|
398 while( (ret= aDrive.Format(fi)) == KErrNotReady && --attempt) |
|
399 { |
|
400 test.Printf(_L("attempt:%d\n"),attempt); |
|
401 User::After(1000000); |
|
402 } |
|
403 test(attempt); |
|
404 } |
|
405 else |
|
406 { |
|
407 test(ret==KErrNone); |
|
408 ret= aDrive.Format(fi); |
|
409 } |
|
410 } |
|
411 |
|
412 |
|
413 test.Printf(_L("call aDrive.Format(pos, length)...\n")); |
|
414 User::After(1000000); |
|
415 |
|
416 __DECLARE_VAR_IN_CHUNK(TInt64, &pos); |
|
417 pos = 0; |
|
418 __DECLARE_VAR_IN_CHUNK(TInt, &length); |
|
419 length = aSize; |
|
420 |
|
421 attempt = 100; |
|
422 __FLUSH_AND_CALL_API_METHOD(ret, aDrive.Format(pos, length)); |
|
423 while( ret == KErrNotReady && --attempt) |
|
424 { |
|
425 User::After(1000000); |
|
426 ret= aDrive.Format(pos, length); |
|
427 } |
|
428 test(attempt); |
|
429 test_Equal(KErrNone, ret); |
|
430 |
|
431 test.Printf(_L("End of TestFormatRelatedMethods)...\n")); |
|
432 } |
|
433 |
|
434 void RestoreDriveState(void) |
|
435 { |
|
436 TBuf<3> bfDrv; |
|
437 |
|
438 const TText KDrvLtr = 'A' + gFsDriveNumber; |
|
439 |
|
440 bfDrv.Append(KDrvLtr); |
|
441 _LIT(KBP, ":\\"); |
|
442 bfDrv.Append(KBP); |
|
443 |
|
444 |
|
445 TheFs.Connect(); |
|
446 RFormat fmt; |
|
447 TInt count; |
|
448 |
|
449 test(fmt.Open(TheFs, bfDrv, EHighDensity, count) == KErrNone); |
|
450 while (count > 0) |
|
451 { |
|
452 test.Printf(_L("\rfmt:%d "), count); |
|
453 test(fmt.Next(count) == KErrNone); |
|
454 } |
|
455 test.Printf(_L("\n")); |
|
456 fmt.Close(); |
|
457 |
|
458 TheFs.Close(); |
|
459 } |
|
460 |
|
461 |
|
462 TInt FindDataPagingDrive() |
|
463 /** |
|
464 Find the drive containing a swap partition. |
|
465 |
|
466 @return Local drive identifier. |
|
467 */ |
|
468 { |
|
469 TInt drive = KErrNotFound; |
|
470 |
|
471 test.Printf(_L("Searching for data paging drive:\n")); |
|
472 |
|
473 for(TInt i = 0; i < KMaxLocalDrives && drive < 0; ++i) |
|
474 { |
|
475 RLocalDrive d; |
|
476 TBool change = EFalse; |
|
477 |
|
478 if(d.Connect(i, change) == KErrNone) |
|
479 { |
|
480 TLocalDriveCapsV4 dc; |
|
481 TPckg<TLocalDriveCapsV4> capsPack(dc); |
|
482 |
|
483 if(d.Caps(capsPack) == KErrNone) |
|
484 { |
|
485 if ((dc.iMediaAtt & KMediaAttPageable) && |
|
486 (dc.iPartitionType == KPartitionTypePagedData)) |
|
487 { |
|
488 test.Printf(_L("Found swap partition on local drive %d\n"), i); |
|
489 drive = i; |
|
490 |
|
491 TPageDeviceInfo pageDeviceInfo; |
|
492 |
|
493 TPtr8 pageDeviceInfoBuf((TUint8*) &pageDeviceInfo, sizeof(pageDeviceInfo)); |
|
494 pageDeviceInfoBuf.FillZ(); |
|
495 |
|
496 TInt r = d.QueryDevice(RLocalDrive::EQueryPageDeviceInfo, pageDeviceInfoBuf); |
|
497 |
|
498 test.Printf(_L("EQueryPageDeviceInfo on local drive %d returned %d\n"), i, r); |
|
499 } |
|
500 } |
|
501 d.Close(); |
|
502 } |
|
503 } |
|
504 return drive; |
|
505 } |
|
506 |
|
507 TDes& GetSerialNumber(TLocalDriveCapsV5& aCaps) |
|
508 { |
|
509 static TBuf16<80> serialNumBuf; |
|
510 |
|
511 serialNumBuf.SetLength(0); |
|
512 |
|
513 for (TUint n=0; n<aCaps.iSerialNumLength; n+=16) |
|
514 { |
|
515 for (TUint m=n; m<n+16; m++) |
|
516 { |
|
517 TBuf16<3> hexBuf; |
|
518 hexBuf.Format(_L("%02X "), aCaps.iSerialNum[m]); |
|
519 serialNumBuf.Append(hexBuf); |
|
520 } |
|
521 } |
|
522 |
|
523 return serialNumBuf; |
|
524 } |
|
525 |
|
526 TDes& GetSerialNumber(TMediaSerialNumber& aSerialNum) |
|
527 { |
|
528 static TBuf16<80> serialNumBuf; |
|
529 |
|
530 serialNumBuf.SetLength(0); |
|
531 |
|
532 TInt len = aSerialNum.Length(); |
|
533 for (TInt n=0; n<len; n+=16) |
|
534 { |
|
535 for (TInt m=n; m<n+16; m++) |
|
536 { |
|
537 TBuf16<3> hexBuf; |
|
538 hexBuf.Format(_L("%02X "), aSerialNum[m]); |
|
539 serialNumBuf.Append(hexBuf); |
|
540 } |
|
541 } |
|
542 |
|
543 return serialNumBuf; |
|
544 } |
|
545 |
|
546 TPtrC GetMediaType(TMediaType aType) |
|
547 { |
|
548 switch(aType) |
|
549 { |
|
550 case EMediaNotPresent: return _L("NotPresent"); |
|
551 case EMediaUnknown: return _L("Unknown"); |
|
552 case EMediaFloppy: return _L("Floppy"); |
|
553 case EMediaHardDisk: return _L("HardDisk"); |
|
554 case EMediaCdRom: return _L("CdRom"); |
|
555 case EMediaRam: return _L("Ram"); |
|
556 case EMediaFlash: return _L("Flash"); |
|
557 case EMediaRom: return _L("Rom"); |
|
558 case EMediaRemote: return _L("Remote"); |
|
559 case EMediaNANDFlash: return _L("NANDFlash"); |
|
560 case EMediaRotatingMedia : return _L("RotatingMedia "); |
|
561 default:return _L("Unrecognised"); |
|
562 } |
|
563 } |
|
564 |
|
565 TPtrC GetFileSystemId(TUint aFileSystemId) |
|
566 { |
|
567 switch(aFileSystemId) |
|
568 { |
|
569 case KDriveFileSysFAT: return _L("FAT"); |
|
570 case KDriveFileSysROM: return _L("ROM"); |
|
571 case KDriveFileSysLFFS: return _L("LFFS"); |
|
572 case KDriveFileSysROFS: return _L("ROFS"); |
|
573 case KDriveFileNone: return _L("None"); |
|
574 default:return _L("Unrecognised"); |
|
575 } |
|
576 } |
|
577 |
|
578 |
|
579 |
|
580 // Find a drive which contains the swap partition; if this succeeds, find and return the FAT drive on the same media. |
|
581 // This isn't fool-proof as it works by comparing media types/drive attributes/media attributes/serial numbers |
|
582 TInt FindFatDriveOnDataPagingMedia() |
|
583 { |
|
584 TInt dataPagingDrive = FindDataPagingDrive(); |
|
585 if (dataPagingDrive == KErrNotFound) |
|
586 return KErrNotFound; |
|
587 |
|
588 TInt fatDriveNumber = KErrNotFound; |
|
589 |
|
590 test.Printf(_L("Finding Fat drive on datapaging media...\n")); |
|
591 |
|
592 RLocalDrive dpDrive; |
|
593 TBool change = EFalse; |
|
594 |
|
595 TInt r = dpDrive.Connect(dataPagingDrive, change); |
|
596 test(r == KErrNone); |
|
597 TLocalDriveCapsV5 dpDriveCaps; |
|
598 TPckg<TLocalDriveCapsV5> capsPack(dpDriveCaps); |
|
599 r = dpDrive.Caps(capsPack); |
|
600 test(r == KErrNone); |
|
601 TPtrC8 dpDriveSerialNum(dpDriveCaps.iSerialNum, dpDriveCaps.iSerialNumLength); |
|
602 dpDrive.Close(); |
|
603 |
|
604 TPtrC mediaType = GetMediaType(dpDriveCaps.iType); |
|
605 TPtrC fileSystemId = GetFileSystemId(dpDriveCaps.iFileSystemId); |
|
606 test.Printf(_L("Swap Drive %2d Type %S DriveAtt 0x%x MediaAtt 0x%x FileSysId %S SerialNum %S\n"), |
|
607 dataPagingDrive, &mediaType, dpDriveCaps.iDriveAtt, dpDriveCaps.iMediaAtt, &fileSystemId, &GetSerialNumber(dpDriveCaps)); |
|
608 |
|
609 // swap partition should be hidden |
|
610 test (dpDriveCaps.iDriveAtt & KDriveAttHidden); |
|
611 |
|
612 // search for a FAT drive on the same media by searching for a drive which has |
|
613 // 'similar' drive & media attributes as the the swap drive |
|
614 |
|
615 dpDriveCaps.iDriveAtt&= KDriveAttMask; |
|
616 dpDriveCaps.iMediaAtt&= KMediaAttMask; |
|
617 |
|
618 for (TInt i = 0; i < KMaxLocalDrives /*&& fatDriveNumber == KErrNotFound*/; ++i) |
|
619 { |
|
620 RLocalDrive d; |
|
621 TBool change = EFalse; |
|
622 |
|
623 if(d.Connect(i, change) == KErrNone) |
|
624 { |
|
625 TLocalDriveCapsV5 caps; |
|
626 TPckg<TLocalDriveCapsV5> capsPack(caps); |
|
627 |
|
628 r = d.Caps(capsPack); |
|
629 if (r != KErrNone) |
|
630 continue; |
|
631 |
|
632 TPtrC8 localSerialNum(caps.iSerialNum, caps.iSerialNumLength); |
|
633 TPtrC mediaType = GetMediaType(caps.iType); |
|
634 TPtrC fileSystemId = GetFileSystemId(caps.iFileSystemId); |
|
635 test.Printf(_L("Drive %2d Type %S DriveAtt 0x%x MediaAtt 0x%x FileSysId %S SerialNum %S\n"), |
|
636 i, &mediaType, caps.iDriveAtt, caps.iMediaAtt, &fileSystemId, &GetSerialNumber(caps)); |
|
637 |
|
638 // Turn off bits which may be different |
|
639 caps.iDriveAtt&= KDriveAttMask; |
|
640 caps.iMediaAtt&= KMediaAttMask; |
|
641 |
|
642 if ((caps.iType == dpDriveCaps.iType) && |
|
643 (caps.iDriveAtt == dpDriveCaps.iDriveAtt) && |
|
644 (caps.iMediaAtt == dpDriveCaps.iMediaAtt) && |
|
645 (localSerialNum.Compare(dpDriveSerialNum) == 0) && |
|
646 (caps.iFileSystemId == KDriveFileSysFAT)) |
|
647 { |
|
648 if (fatDriveNumber == KErrNotFound) |
|
649 fatDriveNumber = i; |
|
650 } |
|
651 d.Close(); |
|
652 } |
|
653 } |
|
654 |
|
655 |
|
656 return fatDriveNumber; |
|
657 } |
|
658 |
|
659 |
|
660 // Find and return the File Server drive number (0-25) corresponing to the passed local drive number |
|
661 // This isn't fool-proof as it works by comparing media types/drive attributes/media attributes/serial numbers |
|
662 TInt FindFsDriveNumber(TInt aLocalDriveNumber) |
|
663 { |
|
664 TInt fsDriveNumber = KErrNotFound; |
|
665 |
|
666 RLocalDrive dpDrive; |
|
667 TBool change = EFalse; |
|
668 |
|
669 TInt r = dpDrive.Connect(aLocalDriveNumber, change); |
|
670 test(r == KErrNone); |
|
671 TLocalDriveCapsV5 dpDriveCaps; |
|
672 TPckg<TLocalDriveCapsV5> capsPack(dpDriveCaps); |
|
673 r = dpDrive.Caps(capsPack); |
|
674 test(r == KErrNone); |
|
675 TPtrC8 dpDriveSerialNum(dpDriveCaps.iSerialNum, dpDriveCaps.iSerialNumLength); |
|
676 dpDrive.Close(); |
|
677 |
|
678 dpDriveCaps.iDriveAtt&= KDriveAttMask; |
|
679 dpDriveCaps.iMediaAtt&= KMediaAttMask; |
|
680 |
|
681 RFs fs; |
|
682 r = fs.Connect(); |
|
683 test(r == KErrNone); |
|
684 |
|
685 TDriveInfo di; |
|
686 |
|
687 for (TInt n=0; n<KMaxDrives /* && fsDriveNumber == KErrNotFound*/; n++) |
|
688 { |
|
689 r = fs.Drive(di, n); |
|
690 |
|
691 TMediaSerialNumber serialNum; |
|
692 fs.GetMediaSerialNumber(serialNum, n); |
|
693 |
|
694 TFSName fsName; |
|
695 fs.FileSystemName(fsName, n); |
|
696 |
|
697 if (r != KErrNone ) |
|
698 continue; |
|
699 |
|
700 TPtrC mediaType = GetMediaType(di.iType); |
|
701 test.Printf(_L("Drive %C Type %S DriveAtt 0x%x MediaAtt 0x%x FileSysId %S SerialNum %S\n"), |
|
702 'A' + n, &mediaType, di.iDriveAtt, di.iMediaAtt, &fsName, &GetSerialNumber(serialNum)); |
|
703 |
|
704 di.iDriveAtt&= KDriveAttMask; |
|
705 di.iMediaAtt&= KMediaAttMask; |
|
706 |
|
707 if ((di.iType == dpDriveCaps.iType) && |
|
708 (di.iDriveAtt == dpDriveCaps.iDriveAtt) && |
|
709 (di.iMediaAtt == dpDriveCaps.iMediaAtt) && |
|
710 (serialNum.Compare(dpDriveSerialNum) == 0)) |
|
711 { |
|
712 if (fsDriveNumber == KErrNotFound) |
|
713 fsDriveNumber = n; |
|
714 } |
|
715 } |
|
716 |
|
717 fs.Close(); |
|
718 |
|
719 return fsDriveNumber; |
|
720 } |
|
721 |
|
722 TInt E32Main() |
|
723 { |
|
724 |
|
725 // To use in command line |
|
726 TBool callPasswordRelated = EFalse; |
|
727 |
|
728 TBuf<256> cmdline; |
|
729 User::CommandLine(cmdline); |
|
730 TLex lex(cmdline); |
|
731 |
|
732 FOREVER |
|
733 { |
|
734 TPtrC token=lex.NextToken(); |
|
735 if(token.Length() != 0) |
|
736 { |
|
737 if (token == _L("-p")) |
|
738 { |
|
739 callPasswordRelated = ETrue; |
|
740 } |
|
741 else |
|
742 test.Printf(_L("Unknown argument '%S' was ignored.\n"), &token); |
|
743 } |
|
744 else |
|
745 break; |
|
746 |
|
747 } |
|
748 |
|
749 test.Title(); |
|
750 TInt r; |
|
751 |
|
752 test.Start(_L("Verify the global and this process's data paging attributes")); |
|
753 test_KErrNone(GetGlobalPolicies()); |
|
754 |
|
755 if (IsDataPagingSupported()) |
|
756 { |
|
757 test.Printf(_L("Data paging supported\n")); |
|
758 } |
|
759 else |
|
760 {// The system doesn't support data paging so this process shouldn't be |
|
761 // data paged. |
|
762 test.Printf(_L("Data paging not supported\n")); |
|
763 test_Equal(EFalse, gProcessPaged); |
|
764 test.End(); |
|
765 return 0; |
|
766 } |
|
767 |
|
768 r = UserHal::PageSizeInBytes(gPageSize); |
|
769 test_KErrNone(r); |
|
770 |
|
771 TInt fatDriveNumber = FindFatDriveOnDataPagingMedia(); |
|
772 if (fatDriveNumber == KErrNotFound) |
|
773 { |
|
774 test.Printf(_L("Could not find FAT partition on data paging media\n")); |
|
775 test(0); |
|
776 } |
|
777 gFsDriveNumber = FindFsDriveNumber(fatDriveNumber); |
|
778 if (gFsDriveNumber == KErrNotFound) |
|
779 { |
|
780 test.Printf(_L("Could not File Server drive\n")); |
|
781 test(0); |
|
782 } |
|
783 |
|
784 test.Printf(_L("Found FAT drive on %C: (local drive #%d) on data paging media\n"), 'A'+gFsDriveNumber, fatDriveNumber); |
|
785 |
|
786 // User::SetDebugMask(0x10000000); //KMMU2 |
|
787 // User::SetDebugMask(0x40000000, 1); //KPAGING |
|
788 |
|
789 test.Next(_L("Create a paged chunk")); |
|
790 CreatePagedChunk(KChunkSizeInPages, KClearValue); |
|
791 |
|
792 test.Next(_L("Chunk created, declare variables")); |
|
793 |
|
794 __DECLARE_VAR_IN_CHUNK(TBusLocalDrive, &drive) |
|
795 TInt driveSize = TestDriveConnectAndCaps(drive, fatDriveNumber); |
|
796 |
|
797 TestDriveSizeRelatedMethods(drive, 0x00001000, driveSize); |
|
798 |
|
799 TestWriteReadRelatedMethods(drive); |
|
800 |
|
801 TestFormatRelatedMethods(drive, driveSize); |
|
802 |
|
803 if(callPasswordRelated) |
|
804 { |
|
805 TestPasswordRelatedMethods(drive); |
|
806 } |
|
807 |
|
808 //Disconnect drive |
|
809 test.Next(_L("call aDrive.Disconnect()...")); |
|
810 DPTest::FlushCache(); |
|
811 drive.Disconnect(); |
|
812 |
|
813 gMyChunk.Close(); |
|
814 |
|
815 RestoreDriveState(); |
|
816 |
|
817 test.End(); |
|
818 |
|
819 User::SetDebugMask(0x00000000); // No debug info |
|
820 User::SetDebugMask(0x00000000, 1); //No KPAGING |
|
821 return 0; |
|
822 } |