|
1 // Copyright (c) 1996-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 // f32test\fat32\t_compat32.cpp |
|
15 // |
|
16 // |
|
17 |
|
18 #define __E32TEST_EXTENSION__ |
|
19 |
|
20 #include <f32file.h> |
|
21 #include <e32test.h> |
|
22 #include <f32dbg.h> |
|
23 #include "t_server.h" |
|
24 |
|
25 #include "fat_utils.h" |
|
26 using namespace Fat_Test_Utils; |
|
27 |
|
28 RTest test(_L("T_COMPAT32")); |
|
29 |
|
30 static RRawDisk TheDisk; |
|
31 static TFatBootSector gBootSector; |
|
32 |
|
33 |
|
34 static void QuickFormat() |
|
35 { |
|
36 FormatFatDrive(TheFs, CurrentDrive(), ETrue); |
|
37 } |
|
38 |
|
39 static void ReadBootSector(TFatBootSector& aBootSector) |
|
40 { |
|
41 |
|
42 TInt nRes = ReadBootSector(TheFs, CurrentDrive(), KBootSectorNum<<KDefaultSectorLog2, aBootSector); |
|
43 test(nRes == KErrNone); |
|
44 |
|
45 if(!aBootSector.IsValid()) |
|
46 { |
|
47 test.Printf(_L("Wrong bootsector! Dump:\n")); |
|
48 aBootSector.PrintDebugInfo(); |
|
49 test(0); |
|
50 } |
|
51 } |
|
52 |
|
53 |
|
54 static void GetBootInfo() |
|
55 { |
|
56 QuickFormat(); |
|
57 ReadBootSector(gBootSector); |
|
58 } |
|
59 |
|
60 enum TNameCase |
|
61 { |
|
62 EUpper, // Test directory entries with 8.3 uppercase (no VFAT entries expected) |
|
63 ELower, // Test directory entries with 8.3 lowercase ( VFAT entries expected) |
|
64 EMixed // Test directory entries with 8.3 mixed ( VFAT entries expected) |
|
65 }; |
|
66 |
|
67 |
|
68 /** |
|
69 Fiddles with root directory entries. |
|
70 Creates a file, if it has 1 VFAT and 1 DOS dir. entries, places an illegal lower case |
|
71 symbol to the DOS entry, fixing VFAT name checksums |
|
72 */ |
|
73 static void DoFiddleWithFileNames(TNameCase aCase) |
|
74 { |
|
75 TFileName fileName = _L("\\WORD"); |
|
76 TBool expectVfatEntry = EFalse; |
|
77 |
|
78 switch(aCase) |
|
79 { |
|
80 case EUpper: |
|
81 break; |
|
82 |
|
83 case ELower: |
|
84 fileName = _L("\\word"); |
|
85 expectVfatEntry = ETrue; |
|
86 break; |
|
87 |
|
88 case EMixed: |
|
89 fileName = _L("\\WoRd"); |
|
90 expectVfatEntry = ETrue; |
|
91 break; |
|
92 |
|
93 default: |
|
94 test(0); |
|
95 break; |
|
96 } |
|
97 |
|
98 RFile file; |
|
99 TInt r=file.Create(TheFs,fileName,EFileRead); |
|
100 test(r==KErrNone); |
|
101 file.Close(); |
|
102 // Assume this file is the first entry in the root directory |
|
103 |
|
104 |
|
105 r=TheDisk.Open(TheFs,CurrentDrive()); |
|
106 test(r==KErrNone); |
|
107 |
|
108 //-- read 1st dir. entry it can be FAT or VFat , depending on the filename |
|
109 const TInt posEntry1=gBootSector.RootDirStartSector() << KDefaultSectorLog2; //-- dir entry1 position |
|
110 |
|
111 TFatDirEntry fatEntry1; |
|
112 TPtr8 ptrEntry1((TUint8*)&fatEntry1,sizeof(TFatDirEntry)); |
|
113 |
|
114 test(TheDisk.Read(posEntry1, ptrEntry1)==KErrNone); |
|
115 |
|
116 if(!fatEntry1.IsVFatEntry()) |
|
117 {//-- we expected FAT entry, everything is OK |
|
118 test(!expectVfatEntry); |
|
119 } |
|
120 else |
|
121 {//-- we have 2 FAT entries, 1st is VFat, 2nd is DOS. |
|
122 //-- put lower case letters into DOS entry( not compliant with FAT specs), correct VFat entries checksums, |
|
123 //-- in this case the system shall correctly deal with the file, using long names. |
|
124 |
|
125 test(expectVfatEntry); |
|
126 test(fatEntry1.iData[0] == 0x41); //-- must have only 2 entries |
|
127 |
|
128 //-- read DOS entry now |
|
129 TFatDirEntry fatEntry2; |
|
130 TPtr8 ptrEntry2((TUint8*)&fatEntry2,sizeof(TFatDirEntry)); |
|
131 const TInt posEntry2 = posEntry1 + sizeof(TFatDirEntry); //-- dir entry2 position |
|
132 |
|
133 test(TheDisk.Read(posEntry2, ptrEntry2)==KErrNone); |
|
134 |
|
135 //-- ensure that the name and checksum are correct |
|
136 test(fatEntry1.iData[13] == CalculateShortNameCheckSum(fatEntry2.Name())); |
|
137 test(fatEntry2.Name()==_L8("WORD ")); |
|
138 |
|
139 //-- put lower case symbol to the DOS entry and fix the checksum |
|
140 _LIT8(KBadDosName, "Word "); |
|
141 fatEntry2.SetName(KBadDosName); |
|
142 fatEntry1.iData[13] = CalculateShortNameCheckSum(fatEntry2.Name()); |
|
143 |
|
144 //-- write data to the disk |
|
145 test(TheDisk.Write(posEntry1, ptrEntry1)==KErrNone); |
|
146 test(TheDisk.Write(posEntry2, ptrEntry2)==KErrNone); |
|
147 |
|
148 } |
|
149 |
|
150 TheDisk.Close(); |
|
151 |
|
152 } |
|
153 |
|
154 // |
|
155 // Replace a 8.3 filename with upper and lower case letters which is, actually out of FAT specs. |
|
156 // I.e. VFAT entries are valid, but DOS entry has a lower case symbol, which is wrong. |
|
157 // |
|
158 LOCAL_C void Test1(TNameCase aCase) |
|
159 { |
|
160 test.Next(_L("Replace a file with a wrong DOS entry")); |
|
161 QuickFormat(); |
|
162 |
|
163 //-- N.B. This shall be the before any dir. entries creation in the root directory |
|
164 //-- because it directly accesses the directory's 1st file |
|
165 DoFiddleWithFileNames(aCase); |
|
166 |
|
167 RFile file; |
|
168 TInt r; |
|
169 |
|
170 r=file.Replace(TheFs,_L("\\FILE.TMP"),EFileRead); |
|
171 test(r==KErrNone); |
|
172 r=file.Write(_L8("Hello World")); |
|
173 file.Close(); |
|
174 |
|
175 r=TheFs.Replace(_L("\\File.tmp"),_L("\\Word")); |
|
176 test(r==KErrNone); |
|
177 |
|
178 CDir* entryCount; |
|
179 r=TheFs.GetDir(_L("\\*.*"),KEntryAttMaskSupported,ESortNone,entryCount); |
|
180 test(r==KErrNone); |
|
181 TInt count=entryCount->Count(); |
|
182 |
|
183 test(count==1); |
|
184 delete entryCount; |
|
185 } |
|
186 |
|
187 |
|
188 // |
|
189 // Renaming a 8.3 filename with upper and lower case letters which is, actually out of FAT specs. |
|
190 // I.e. VFAT entries are valid, but DOS entry has a lower case symbol, which is wrong. |
|
191 // |
|
192 LOCAL_C void Test2(TNameCase aCase) |
|
193 { |
|
194 test.Next(_L("Rename a file with a wrong DOS entry")); |
|
195 QuickFormat(); |
|
196 RFile file; |
|
197 TInt r; |
|
198 |
|
199 //-- N.B. This shall be the before any dir. entries creation in the root dir |
|
200 //-- because it directly accesses the directory's 1st file |
|
201 DoFiddleWithFileNames(aCase); |
|
202 |
|
203 r=file.Create(TheFs,_L("\\TEST"),EFileRead); |
|
204 test(r==KErrNone); |
|
205 file.Close(); |
|
206 |
|
207 r=TheFs.Rename(_L("\\TEST"),_L("\\Word")); |
|
208 test(r==KErrAlreadyExists); |
|
209 r=TheFs.Delete(_L("\\TEST")); |
|
210 test(r==KErrNone); |
|
211 |
|
212 CDir* entryCount; |
|
213 r=TheFs.GetDir(_L("\\*.*"),KEntryAttMaskSupported,ESortNone,entryCount); |
|
214 test(r==KErrNone); |
|
215 TInt count=entryCount->Count(); |
|
216 test(count==1); |
|
217 delete entryCount; |
|
218 } |
|
219 |
|
220 |
|
221 //--------------------------------------------- |
|
222 //! @SYMTestCaseID PBASE-T_COMPAT32-0686 |
|
223 //! @SYMTestType CT |
|
224 //! @SYMREQ DEF115314 |
|
225 //! @SYMTestCaseDesc Test character '`' (0x60) is recognized as a legal char for short file names. |
|
226 //! @SYMTestActions Creates a file named "\x60\x60\x60.TXT", checks only DOS entry is created for |
|
227 //! it and its short name equals "```.TXT" instead of "___.TXT" |
|
228 //! @SYMTestExpectedResults The operation completes with error code KErrNone; |
|
229 //! @SYMTestPriority High |
|
230 //! @SYMTestStatus Implemented |
|
231 //--------------------------------------------- |
|
232 void TestDEF115314() |
|
233 { |
|
234 test.Next(_L("Test DEF115314: TTG:<`(0x60) code cannot be used as valid Short File Name>")); |
|
235 QuickFormat(); |
|
236 RFile file; |
|
237 TInt r; |
|
238 |
|
239 TFileName fn; |
|
240 fn.Format(_L("%c:\\\x60\x60\x60.TXT"), (TUint8)gDriveToTest); |
|
241 |
|
242 r = TheFs.Delete(fn); |
|
243 test(r==KErrNone || r==KErrNotFound); |
|
244 |
|
245 r = file.Create(TheFs, fn, EFileRead); |
|
246 test(r==KErrNone); |
|
247 file.Close(); |
|
248 |
|
249 r=TheDisk.Open(TheFs,CurrentDrive()); |
|
250 test(r==KErrNone); |
|
251 |
|
252 //-- read 1st dir. it should be DOS Entry |
|
253 const TInt posEntry1=gBootSector.RootDirStartSector() << KDefaultSectorLog2; //-- dir entry1 position |
|
254 TFatDirEntry fatEntry1; |
|
255 TPtr8 ptrEntry1((TUint8*)&fatEntry1,sizeof(TFatDirEntry)); |
|
256 test(TheDisk.Read(posEntry1, ptrEntry1)==KErrNone); |
|
257 TheDisk.Close(); |
|
258 test(!fatEntry1.IsVFatEntry()); |
|
259 |
|
260 // tests short name |
|
261 TFileName sn; |
|
262 r = TheFs.GetShortName(fn, sn); |
|
263 test(r==KErrNone); |
|
264 test(sn.Compare(_L("```.TXT"))==0); |
|
265 |
|
266 r = TheFs.Delete(fn); |
|
267 test(r==KErrNone); |
|
268 } |
|
269 |
|
270 #if defined(_DEBUG) || defined(_DEBUG_RELEASE) |
|
271 _LIT(KTestLocale, "t_tlocl_cp932.dll"); |
|
272 _LIT(KTestUnicodeFileName, "\\\x65B0\x6587\x4EF6"); |
|
273 #endif //_DEBUG || _DEBUG_RELEASE |
|
274 |
|
275 //--------------------------------------------- |
|
276 //! @SYMTestCaseID PBASE-T_COMPAT32-0685 |
|
277 //! @SYMTestType CT |
|
278 //! @SYMREQ DEF113633 |
|
279 //! @SYMTestCaseDesc Test FAT volume creates VFat entries for short unicode named files |
|
280 //! @SYMTestActions Enables FatUtilityFunctions. Loads cp932 codepage dll. Create a file |
|
281 //! named as "\x65B0\x6587\x4EF6", checks both a VFat entry and a DOS |
|
282 //! entry have been created for the file. |
|
283 //! @SYMTestExpectedResults The operation completes with error code KErrNone; |
|
284 //! @SYMTestPriority High |
|
285 //! @SYMTestStatus Implemented |
|
286 //--------------------------------------------- |
|
287 void TestDEF113633() |
|
288 { |
|
289 test.Next(_L("Test DEF113633 - FAT should create VFat entries for unicode character contained file names")); |
|
290 #if defined(_DEBUG) || defined(_DEBUG_RELEASE) |
|
291 QuickFormat(); |
|
292 RFile file; |
|
293 TInt r; |
|
294 TInt drvNum; |
|
295 |
|
296 r = TheFs.CharToDrive(gDriveToTest,drvNum); |
|
297 test(r==KErrNone); |
|
298 |
|
299 // turn on FatUtilityFunctions |
|
300 r = TheFs.ControlIo(drvNum, KControlIoEnableFatUtilityFunctions); |
|
301 test(r==KErrNone); |
|
302 |
|
303 // load cp932 codepage dll |
|
304 r = UserSvr::ChangeLocale(KTestLocale); |
|
305 test(r==KErrNone); |
|
306 |
|
307 // create file "\x65B0\x6587\x4EF6", check DOS entry & VFat entry |
|
308 r = file.Create(TheFs, KTestUnicodeFileName, EFileRead); |
|
309 test(r==KErrNone); |
|
310 file.Close(); |
|
311 |
|
312 r=TheDisk.Open(TheFs,CurrentDrive()); |
|
313 test(r==KErrNone); |
|
314 |
|
315 //-- read 1st dir. it should be VFat |
|
316 // const TInt posEntry1=gRootDirStart; //-- dir entry1 position |
|
317 const TInt posEntry1=gBootSector.RootDirStartSector() << KDefaultSectorLog2; //-- dir entry1 position |
|
318 TFatDirEntry fatEntry1; |
|
319 TPtr8 ptrEntry1((TUint8*)&fatEntry1,sizeof(TFatDirEntry)); |
|
320 |
|
321 test(TheDisk.Read(posEntry1, ptrEntry1)==KErrNone); |
|
322 |
|
323 test(fatEntry1.IsVFatEntry()); |
|
324 |
|
325 test(fatEntry1.iData[0] == 0x41); //-- must have only 2 entries |
|
326 |
|
327 //-- read DOS entry now |
|
328 TFatDirEntry fatEntry2; |
|
329 TPtr8 ptrEntry2((TUint8*)&fatEntry2,sizeof(TFatDirEntry)); |
|
330 const TInt posEntry2 = posEntry1 + sizeof(TFatDirEntry); //-- dir entry2 position |
|
331 |
|
332 test(TheDisk.Read(posEntry2, ptrEntry2)==KErrNone); |
|
333 |
|
334 //-- ensure that the name and checksum are correct |
|
335 test(!fatEntry2.IsVFatEntry()); |
|
336 test(fatEntry1.iData[13] == CalculateShortNameCheckSum(fatEntry2.Name())); |
|
337 |
|
338 // delete file |
|
339 TheDisk.Close(); |
|
340 r = TheFs.Delete(KTestUnicodeFileName); |
|
341 test(r==KErrNone); |
|
342 |
|
343 // turn off FatUtilityFunctions |
|
344 r = TheFs.ControlIo(drvNum, KControlIoDisableFatUtilityFunctions); |
|
345 test(r==KErrNone); |
|
346 |
|
347 #else |
|
348 test.Printf(_L("Test only runs on DEBUG builds, see test logs of debug builds for details.")); |
|
349 #endif // _DEBUG) || _DEBUG_RELEASE |
|
350 } |
|
351 |
|
352 |
|
353 |
|
354 |
|
355 //--------------------------------------------- |
|
356 // If the parent directory of a directory is the root directory, |
|
357 // the '..' entry should point to start cluster 0 in any case |
|
358 //--------------------------------------------- |
|
359 void TestPDEF116912() |
|
360 { |
|
361 test.Next(_L("Test PDEF116912 - Check that '..' parent cluster address is 0 after renaming\n")); |
|
362 |
|
363 TInt drvNum; |
|
364 test(KErrNone == TheFs.CharToDrive(gDriveToTest, drvNum)); |
|
365 |
|
366 if(!Is_Fat32(TheFs, drvNum)) |
|
367 { |
|
368 _LIT(KMessage, "Test only applicable to FAT32 file systems. Skipping.\n"); |
|
369 test.Printf(KMessage); |
|
370 return; |
|
371 } |
|
372 |
|
373 QuickFormat(); |
|
374 |
|
375 _LIT(KDirA, "\\dirA\\"); |
|
376 _LIT(KDirB, "\\dirB\\"); |
|
377 |
|
378 test(KErrNone == TheFs.MkDir(KDirA)); |
|
379 test(KErrNone == TheFs.Rename(KDirA, KDirB)); |
|
380 |
|
381 test(gBootSector.IsValid()); |
|
382 TInt mediaPosition = gBootSector.RootDirStartSector() * gBootSector.BytesPerSector(); |
|
383 |
|
384 TFatDirEntry dirEntry; |
|
385 TPtr8 ptrEntry((TUint8*) &dirEntry,sizeof(TFatDirEntry)); |
|
386 |
|
387 _LIT8(KDirBMatchPattern, "DIRB *"); |
|
388 _LIT8(KDotDotMatchPattern, ".. *"); |
|
389 |
|
390 const TInt KMaxEntriesToSearch = (gBootSector.SectorsPerCluster() * gBootSector.BytesPerSector()) / KSizeOfFatDirEntry; |
|
391 test(KErrNone == TheDisk.Open(TheFs, drvNum)); |
|
392 |
|
393 for(TInt c = 0; c < KMaxEntriesToSearch; c++) |
|
394 { |
|
395 test(KErrNone == TheDisk.Read(mediaPosition, ptrEntry)); |
|
396 |
|
397 if(KErrNotFound == ptrEntry.Match(KDirBMatchPattern)) |
|
398 { |
|
399 // keep scanning |
|
400 mediaPosition += sizeof(TFatDirEntry); |
|
401 } |
|
402 else |
|
403 { |
|
404 // found, locate '..' entry |
|
405 test(dirEntry.StartCluster() >= KFatFirstSearchCluser); |
|
406 mediaPosition = gBootSector.FirstDataSector(); |
|
407 mediaPosition += (dirEntry.StartCluster() - KFatFirstSearchCluser) * gBootSector.SectorsPerCluster(); |
|
408 mediaPosition *= gBootSector.BytesPerSector(); |
|
409 mediaPosition += KSizeOfFatDirEntry; // '..' is always the 2nd entry |
|
410 |
|
411 test(KErrNone == TheDisk.Read(mediaPosition, ptrEntry)); |
|
412 |
|
413 test(KErrNotFound != ptrEntry.Match(KDotDotMatchPattern)); |
|
414 test(dirEntry.StartCluster() == 0); |
|
415 |
|
416 TheDisk.Close(); |
|
417 return; |
|
418 } |
|
419 } |
|
420 |
|
421 // dirB entry not found - test failed |
|
422 TheDisk.Close(); |
|
423 test(0); |
|
424 } |
|
425 |
|
426 //--------------------------------------------- |
|
427 /** |
|
428 Test replacing files by theis short names |
|
429 */ |
|
430 void TestReplaceByShortName() |
|
431 { |
|
432 test.Next(_L("Test replacing files using short names\n")); |
|
433 QuickFormat(); |
|
434 |
|
435 _LIT(KLongName1, "abcdefghi.txt"); |
|
436 _LIT(KShortName1, "ABCDEF~1.TXT"); |
|
437 const TInt KFile1Sz = 100; |
|
438 |
|
439 _LIT(KLongName2, "abcdefghij.txt"); |
|
440 _LIT(KShortName2, "ABCDEF~2.TXT"); |
|
441 const TInt KFile2Sz = 200; |
|
442 |
|
443 |
|
444 TInt nRes; |
|
445 TFileName fn; |
|
446 TEntry entry; |
|
447 |
|
448 TheFs.SetSessionPath(_L("\\")); |
|
449 |
|
450 nRes = CreateCheckableStuffedFile(TheFs, KLongName1, KFile1Sz); |
|
451 test_KErrNone(nRes); |
|
452 |
|
453 nRes = TheFs.GetShortName(KLongName1, fn); |
|
454 test(nRes == KErrNone && fn == KShortName1); //-- just check short name generation |
|
455 |
|
456 nRes =CreateCheckableStuffedFile(TheFs, KLongName2, KFile2Sz); |
|
457 test_KErrNone(nRes); |
|
458 |
|
459 nRes = TheFs.GetShortName(KLongName2, fn); |
|
460 test(nRes == KErrNone && fn == KShortName2); //-- just check short name generation |
|
461 |
|
462 //-- try to replace the file with itself using its short name alias |
|
463 //-- nothing shall happen and the file must remain the same |
|
464 nRes = TheFs.Replace(KLongName1, KShortName1); |
|
465 test(nRes == KErrNone); |
|
466 |
|
467 nRes = TheFs.Entry(KLongName1, entry); |
|
468 test(nRes == KErrNone); |
|
469 test(entry.iSize == KFile1Sz); |
|
470 |
|
471 nRes = TheFs.Entry(KShortName1, entry); |
|
472 test(nRes == KErrNone); |
|
473 test(entry.iSize == KFile1Sz); |
|
474 |
|
475 |
|
476 nRes = TheFs.Replace(KShortName1, KLongName1); |
|
477 test(nRes == KErrNone); |
|
478 |
|
479 nRes = TheFs.Entry(KLongName1, entry); |
|
480 test(nRes == KErrNone); |
|
481 test(entry.iSize == KFile1Sz); |
|
482 |
|
483 nRes = TheFs.Entry(KShortName1, entry); |
|
484 test(nRes == KErrNone); |
|
485 test(entry.iSize == KFile1Sz); |
|
486 |
|
487 nRes = VerifyCheckableFile(TheFs, KLongName1); |
|
488 test(nRes == KErrNone); |
|
489 |
|
490 nRes = VerifyCheckableFile(TheFs, KShortName1); |
|
491 test(nRes == KErrNone); |
|
492 |
|
493 |
|
494 //-- replace "abcdefghi.txt" by "ABCDEF~2.TXT" which is the alias for "abcdefghij.txt" |
|
495 //-- expected: contents and all attributes of the "abcdefghij.txt" is replaced with "abcdefghi.txt" |
|
496 //-- "abcdefghi.txt" entries gets deleted. |
|
497 |
|
498 nRes = TheFs.Replace(KLongName1, KShortName2); |
|
499 test(nRes == KErrNone); |
|
500 |
|
501 //User::After(5*K1Sec); |
|
502 /* |
|
503 nRes = VerifyCheckableFile(TheFs, KLongName2); |
|
504 test(nRes == KErrNone); |
|
505 |
|
506 nRes = VerifyCheckableFile(TheFs, KShortName2); |
|
507 test(nRes == KErrNone); |
|
508 */ |
|
509 |
|
510 |
|
511 nRes = TheFs.Entry(KLongName2, entry); |
|
512 test(nRes == KErrNone); |
|
513 test(entry.iSize == KFile1Sz); |
|
514 |
|
515 nRes = TheFs.Entry(KShortName2, entry); |
|
516 test(nRes == KErrNone); |
|
517 test(entry.iSize == KFile1Sz && entry.iName == KLongName2); |
|
518 |
|
519 |
|
520 } |
|
521 |
|
522 |
|
523 GLDEF_C void CallTestsL() |
|
524 // |
|
525 // Call tests that may leave |
|
526 // |
|
527 { |
|
528 |
|
529 TInt drvNum; |
|
530 TInt r=TheFs.CharToDrive(gDriveToTest,drvNum); |
|
531 test(r==KErrNone); |
|
532 |
|
533 if (!Is_Fat(TheFs,drvNum)) |
|
534 { |
|
535 test.Printf(_L("CallTestsL: Skipped: Requires FAT filesystem to run.\n")); |
|
536 return; |
|
537 } |
|
538 |
|
539 |
|
540 //-- set up console output |
|
541 SetConsole(test.Console()); |
|
542 |
|
543 //-- print drive information |
|
544 PrintDrvInfo(TheFs, drvNum); |
|
545 |
|
546 GetBootInfo(); |
|
547 |
|
548 Test1(EUpper); // Test directory entries with 8.3 uppercase (no VFAT entries expected) |
|
549 Test1(ELower); // Test directory entries with 8.3 lowercase ( VFAT entries expected) |
|
550 Test1(EMixed); // Test directory entries with 8.3 mixed ( VFAT entries expected) |
|
551 |
|
552 Test2(EUpper); // Test directory entries with 8.3 uppercase (no VFAT entries expected) |
|
553 Test2(ELower); // Test directory entries with 8.3 lowercase ( VFAT entries expected) |
|
554 Test2(EMixed); // Test directory entries with 8.3 mixed ( VFAT entries expected) |
|
555 |
|
556 TestDEF115314(); |
|
557 TestDEF113633(); |
|
558 TestPDEF116912(); |
|
559 |
|
560 TestReplaceByShortName(); |
|
561 |
|
562 } |
|
563 |
|
564 |
|
565 |