Symaptic: os/kernelhwsrv/kerneltest/f32test/server/t

     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\server\t_fsys.cpp

    15 //

    16 //

    18 #define __E32TEST_EXTENSION__

    20 #include <f32file.h>

    21 #include <f32file_private.h>

    22 #include <e32test.h>

    23 #include "t_server.h"

    24 #include "fat_utils.h"

    25 #include "filesystem_fat.h"

    27 using namespace Fat_Test_Utils;

    29 RTest test(_L("T_FSYS"));

    31 static void TestFileSystemNames()

    32     {

    33     test.Next(_L("Read file system names for all drives"));

    34     TFullName name;

    35     TInt r;

    36     for(TInt i=EDriveA;i<KMaxDrives;++i)

    37         {

    38         r=TheFs.FileSystemName(name,i);

    39         test(r==KErrNone || r==KErrNotFound);

    40         TChar c;

    41         r=RFs::DriveToChar(i,c);

    42         test(r==KErrNone);

    43         if(name.Length())

    44             test.Printf(_L("File System Name on drive %c is %S\n"),(char)c,&name);

    45         else

    46             test.Printf(_L("No file system on drive %c\n"),(char)c);

    47         }

    48     }

    50 static void CheckDismount(TDesC& aFs,TInt aDrive)

    51     {

    53     if (aDrive==EDriveC) // ??? Can't test on C: - see below

    54         return;

    55     TInt r;

    56     TFullName oldSess, newSess;

    57     r=TheFs.SessionPath(oldSess);

    58     test(r==KErrNone);

    59     TChar c;

    60     r=TheFs.DriveToChar(aDrive,c);

    61     test(r==KErrNone);

    62     newSess.Append(c);

    63     newSess.Append(':');

    64     newSess.Append('\\');

    66     TBuf<128> b;

    67     TDriveInfo di;

    68     r=TheFs.Drive(di,aDrive);

    69     test(r==KErrNone);

    70     b.Format(_L("Test dismounting of test file system on %c: (DrvAtt:%x MedAtt:%x)"),(TUint)c,di.iDriveAtt,di.iMediaAtt);

    71     test.Next(b);

    73     // Test cannot dismount on rom drive

    74     test.Next(_L("Test cannot dismount on Rom drive"));

    75     TFullName zName;

    76     r=TheFs.FileSystemName(zName,EDriveZ);

    77     test(r==KErrNone);

    78     r=TheFs.DismountFileSystem(zName,EDriveZ);

    79     test.Printf(_L("r=%d"),r);

    80     // NB if paging is enabled on a ROFS partition which is part of the composite file system then the

    81     // likelihood is that there will be a at least one file clamped: in this case there error will be KErrInUse

    82     test(r==KErrAccessDenied || r==KErrInUse);

    84     // Test cannot dismount on wrong drive

    85     test.Next(_L("Test cannot dismount on wrong drive"));

    86     r=TheFs.DismountFileSystem(aFs,EDriveA);

    87     test(r==KErrNotReady);

    89     // Test cannot dismount with wrong name

    90     test.Next(_L("Test cannot dismount with wrong file system name"));

    91     r=TheFs.DismountFileSystem(_L("abc"),aDrive);

    92     test(r==KErrNotFound);

    94     // Test cannot dismount with a file open

    95     test.Next(_L("Test cannot dismount with a file open"));

    96     r=TheFs.SetSessionPath(newSess);

    97     RFile file;

    98     r=file.Replace(TheFs,_L("abc"),EFileShareAny);

    99     test(r==KErrNone);

   100     r=TheFs.SessionPath(newSess);

   101     TBool open;

   102     r=TheFs.IsFileOpen(_L("abc"),open);

   103     test(r==KErrNone);

   104     test(open);

   105     r=TheFs.DismountFileSystem(aFs,aDrive);

   106     test(r==KErrInUse);

   107     file.Close();

   109     // Now test dismount works

   110     test.Next(_L("Test dismounts OK"));

   111     r=TheFs.DismountFileSystem(aFs,aDrive);

   112     if(r!=KErrNone)

   113         {

   114         test.Printf(_L("Error = %d"),r);

   115         test(EFalse);

   116         }

   117     TFullName n;

   118     r=TheFs.FileSystemName(n,aDrive);

   119     test(r==KErrNone || r==KErrNotFound);

   120     test(!n.Length());

   121     r=file.Replace(TheFs,_L("abc"),EFileShareAny);

   122     test(r==KErrNotReady);

   123     file.Close();

   125     r=TheFs.MountFileSystem(aFs,aDrive);

   126     if(r!=KErrNone)

   127         {

   128         test.Printf(_L("error = %d\n"),r);

   129         test(EFalse);

   130         }

   131     r=TheFs.FileSystemName(n,aDrive);

   132     test(r==KErrNone);

   133     test(n.Compare(aFs)==0);

   134     r=file.Replace(TheFs,_L("abc"),EFileShareAny); // ??? bang

   135     test(r==KErrNone);

   136     file.Close();

   137     r=TheFs.SetSessionPath(oldSess);

   138     test(r==KErrNone);

   139     }

   141 static void TestDismountFileSystem(TInt aDrive)

   142     {

   144     TInt r;

   145     TFullName name;

   146     r=TheFs.FileSystemName(name,aDrive);

   147     test(r==KErrNone || r==KErrNotFound);

   148     if(name.Length())

   149         CheckDismount(name,aDrive);

   150     }

   152 #if defined(__EPOC32__)

   153 static void TestFileSystem(TInt aDrive)

   154 //

   155 // Mount a new CTestFileSystem on the drive under test

   156 //

   157     {

   158     TBuf<64> b;

   159     TChar c;

   160     TInt r=TheFs.DriveToChar(aDrive,c);

   161     test(r==KErrNone);

   162     TDriveInfo di;

   163     r=TheFs.Drive(di,aDrive);

   164     test(r==KErrNone);

   165     b.Format(_L("Test mounting of test file system on %c: (DrvAtt:%x MedAtt:%x)"),(TUint)c,di.iDriveAtt,di.iMediaAtt);

   166     test.Next(b);

   168     test.Next(_L("Test mounting of test file system"));

   169     r=TheFs.AddFileSystem(_L("T_TFSYS"));

   170     if(r!=KErrNone && r!=KErrAlreadyExists)

   171         {

   172         test.Printf(_L("error=%d"),r);

   173         test(EFalse);

   174         }

   176     TFullName oldFs;

   177     r=TheFs.FileSystemName(oldFs,aDrive);

   178 //  TFileName oldFs;

   179 //  r=TheFs.FileSystemName(oldFs,aDrive);

   180     test(r==KErrNone);

   181     r=TheFs.DismountFileSystem(oldFs,aDrive);

   182     if(r!=KErrNone)

   183         {

   184         test.Printf(_L("Error = %d"),r);

   185         test(EFalse);

   186         }

   187     r=TheFs.MountFileSystem(_L("Test"),aDrive);

   188     test(r==KErrNone);

   190     TFileName newFs;

   191     r=TheFs.FileSystemName(newFs,aDrive);

   192     test(r==KErrNone);

   193     test(newFs.Compare(_L("Test"))==0);

   195     // Check attributes

   196     TDriveInfo info;

   197     r=TheFs.Drive(info,aDrive);

   198     test(r==KErrNone);

   200     test.Printf(_L("iType=%d,iConnectionBusType=%d,iDriveAtt=%x,iMediaAtt=%x\n"),(TUint)info.iType,\

   201         (TUint)info.iConnectionBusType,info.iDriveAtt,info.iMediaAtt);

   203     //Try to remove filesystem without dismounting.

   204     r=TheFs.RemoveFileSystem(_L("Test"));

   205     if(r!=KErrInUse)

   206         {

   207         test.Printf(_L("error=%d"),r);

   208         test(EFalse);

   209         }

   210     r=TheFs.FileSystemName(newFs,aDrive);

   211     test(r==KErrNone);

   212     test(newFs.Compare(_L("Test"))==0);

   214     r=TheFs.DismountFileSystem(newFs,aDrive);

   215     test(r==KErrNone);

   217     r=TheFs.MountFileSystem(oldFs,aDrive);

   218     test(r==KErrNone);

   219     }

   220 #endif

   222 static void TestMountInvalidDrive()

   223 //

   224 // Attempt to mount FAT on non-local drive

   225     {

   226     test.Start(_L("TestMountInvalidDrive"));

   228     TInt r;

   230     test.Next(_L("Adding EFAT"));

   231 #ifdef __WINS__

   232     _LIT(KFsNm, "EFAT32");

   233 #else

   234     _LIT(KFsNm, "ELOCAL");

   235 #endif

   237     r = TheFs.AddFileSystem(KFsNm);

   238     test.Printf(_L("afs: r = %d\n"), r);

   239     test(r == KErrNone || r == KErrAlreadyExists);

   240     test.Next(_L("mounting FAT on drive R"));

   241     r = TheFs.MountFileSystem(KFileSystemName_FAT, EDriveR);

   242     test(r == KErrArgument);

   244     test.End();

   245     }

   247 // Additional step for INC083446: Corrupted miniSD not detected as corrupted by phone

   248 static void TestMountingBrokenMedia(TInt aDrive)

   249 //

   250 // Mount a new CTestFileSystem on the drive under test

   251 //

   252     {

   253     if (aDrive==EDriveC) // ??? Can't test on C:

   254         return;

   256     TBuf<64> b;

   257     TChar c;

   258     TInt r=TheFs.DriveToChar(aDrive,c);

   259     test(r==KErrNone);

   260     TDriveInfo di;

   261     r=TheFs.Drive(di,aDrive);

   262     test(r==KErrNone);

   263     b.Format(_L("Test mounting of test file system on %c: (DrvAtt:%x MedAtt:%x)"),(TUint)c,di.iDriveAtt,di.iMediaAtt);

   264     test.Next(b);

   266     test.Next(_L("Test mounting of test file system"));

   267     r=TheFs.AddFileSystem(_L("T_TFSYS2"));

   268     if(r!=KErrNone && r!=KErrAlreadyExists)

   269         {

   270         test.Printf(_L("error=%d"),r);

   271         test(EFalse);

   272         }

   274     TFullName oldFs;

   275     r=TheFs.FileSystemName(oldFs,aDrive);

   276     test(r==KErrNone);

   277     r=TheFs.DismountFileSystem(oldFs,aDrive);

   278     if(r!=KErrNone)

   279         {

   280         test.Printf(_L("Error = %d"),r);

   281         test(EFalse);

   282         }

   283     r=TheFs.MountFileSystem(_L("Test2"),aDrive);

   284     test(r == KErrCorrupt);

   286     TFileName newFs;

   287     r=TheFs.FileSystemName(newFs,aDrive);

   288     test(r==KErrNone);

   289     test(newFs.Compare(_L("Test2"))==0);

   291     // Get the number of remounts by checking the volume attributes -

   292     // T_TFSYS2 hijacks the iBattery member to report back the number of times MountL() has been called

   293     TDriveInfo info;

   294     TInt remounts;

   295     r=TheFs.Drive(info,aDrive);

   296     test(r==KErrNone);

   297     test.Printf(_L("iType=%d,iBattery=%d,iDriveAtt=%x,iMediaAtt=%x\n"),(TUint)info.iType,\

   298         (TUint)info.iBattery,info.iDriveAtt,info.iMediaAtt);

   299     remounts = (TInt) info.iBattery;

   300     test.Printf(_L("Initial remounts = %d"), remounts);

   302     // Make the file server attempt to remount the drive by looking for a non-existant DLL

   303     // The file server should setop trying to remount the driver after KMaxMountFailures attempts

   304     const TInt KMaxMountFailures = 3;   // copied from sf_drv.cpp

   305     const TInt KEntryAttempts = 10;

   306     TInt entryAttempts;

   307     for (entryAttempts=0; entryAttempts < KEntryAttempts; entryAttempts++)

   308         {

   309         TEntry entry;

   310         _LIT(KNonExistantFilename, "NONEXISTANT_FILENAME.DLL");

   311         r = TheFs.Entry(KNonExistantFilename, entry);

   312         test(r == KErrCorrupt);

   313         }

   314     r=TheFs.Drive(info,aDrive);

   315     test(r==KErrNone);

   316     test.Printf(_L("iType=%d,iBattery=%d,iDriveAtt=%x,iMediaAtt=%x\n"),(TUint)info.iType,\

   317         (TUint)info.iBattery,info.iDriveAtt,info.iMediaAtt);

   318     remounts = (TInt) info.iBattery;

   319     test.Printf(_L("Remounts = %d"), remounts);

   320     test(remounts ==  KMaxMountFailures);

   322     // simulate a media change to reset failure count

   323     r = TheFs.RemountDrive(aDrive, NULL, 0);

   325     // now try mounting again & verify the the file server attempts to mount the drive again

   326     for (entryAttempts=0; entryAttempts < KEntryAttempts; entryAttempts++)

   327         {

   328         TEntry entry;

   329         _LIT(KNonExistantFilename, "NONEXISTANT_FILENAME.DLL");

   330         r = TheFs.Entry(KNonExistantFilename, entry);

   331         test(r == KErrCorrupt);

   332         }

   333     r=TheFs.Drive(info,aDrive);

   334     test(r==KErrNone);

   335     test.Printf(_L("iType=%d,iBattery=%d,iDriveAtt=%x,iMediaAtt=%x\n"),(TUint)info.iType,\

   336         (TUint)info.iBattery,info.iDriveAtt,info.iMediaAtt);

   337     remounts = (TInt) info.iBattery;

   338     test.Printf(_L("Remounts = %d"), remounts);

   339     test(remounts ==  KMaxMountFailures * 2);

   343     r=TheFs.DismountFileSystem(newFs,aDrive);

   344     test(r==KErrNone);

   345     r=TheFs.MountFileSystem(oldFs,aDrive);

   346     test(r==KErrNone);

   348     r=TheFs.RemoveFileSystem(_L("Test2"));

   349     if(r!=KErrNone)

   350         {

   351         test.Printf(_L("error=%d"),r);

   352         test(EFalse);

   353         }

   354     }

   357 /**

   358     Testing obtaining media serial number for the substituted drives

   359 */

   360 static void TestSubstDriveMediaSerialNumber()

   361 {

   362     test.Next(_L("Test obtaining media serial number for the substituted drives"));

   364     TInt  nRes;

   365     const TInt currDrvNum=CurrentDrive();

   367     TDriveInfo drvInfo;

   368     nRes=TheFs.Drive(drvInfo, currDrvNum);

   369     test(nRes==KErrNone);

   371     if(drvInfo.iDriveAtt & (KDriveAttRom | KDriveAttRedirected | KDriveAttSubsted))

   372     {

   373         test.Printf(_L("Can't test on this drive!\n"));

   374         return;

   375     }

   377     TMediaSerialNumber serNum;

   379     //-- test Media Serial Number on unexisting drive

   380     {

   381     for(TInt drvNum=EDriveA; drvNum<=EDriveZ; ++drvNum)

   382         {

   383         TDriveInfo drvInfo;

   384         if(KErrNone==TheFs.Drive(drvInfo, drvNum) && drvInfo.iType==EMediaNotPresent)

   385             {

   386             // found a non-extant drive, test it...

   387             nRes = TheFs.GetMediaSerialNumber(serNum, drvNum);

   388             test(nRes == KErrNotReady);

   389             break;

   390             }

   391         }

   392     }

   394     nRes = TheFs.GetMediaSerialNumber(serNum, currDrvNum);

   395     if(nRes != KErrNone)

   396     {

   397         test.Printf(_L("Test is inconsintent on this drive!\n"));

   398         return;

   399     }

   401     TFileName substPath;                //-- path to the directory to substitute

   402     const TInt KSubstDrv = EDriveO;     //-- drive to be substituted

   404     //-- make directory, which will be substituted ad a drive

   405     substPath.Format(_L("%c:\\SubstDrv1\\"), (TUint8)'A'+currDrvNum);

   406     MakeDir(substPath);

   408     nRes = TheFs.SetSubst(substPath, KSubstDrv);

   409     test(nRes == KErrNone);

   411     //-- an attempt to obtain Media Serial Number on a substed drive shall result in KErrNotSupported

   412     nRes = TheFs.GetMediaSerialNumber(serNum, KSubstDrv);

   413     test(nRes == KErrNotSupported);

   415     //-- delete substed drive

   416     nRes = TheFs.SetSubst(_L(""), KSubstDrv);

   417     test(nRes == KErrNone);

   418 }

   421 //----------------------------------------------------------------------------------------------

   422 //! @SYMTestCaseID      PBASE-t_fsys-0317

   423 //! @SYMTestType        CIT

   424 //! @SYMPREQ            CR0882

   425 //! @SYMTestCaseDesc    This test case is testing querying file system sub type name using

   426 //!                     RFs::QueryVolumeInfoExt() API.

   427 //! @SYMTestActions     1   querys sub type of file system on volumes mounted with 'Fat' file system

   428 //!                     2   querys sub type of file system on volumes mounted with 'Lffs' file system

   429 //!                     3   querys sub type of file system on volumes mounted with 'rofs' file system

   430 //!                     4   querys sub type of file system on volumes mounted with other file systems

   431 //! @SYMTestExpectedResults

   432 //!                     1   returned error code should be KErrNone, descriptor should match 'FAT12' or 'FAT16' or 'FAT32'

   433 //!                     2   returned error code should be KErrNotSupported, descriptor should match 'Lffs'

   434 //!                     3   returned error code should be KErrNotSupported, descriptor should match 'rofs'

   435 //!                     4   returned error code should be KErrNotSupported, descriptor length should not be zero

   436 //! @SYMTestPriority        High

   437 //! @SYMTestStatus          Implemented

   438 //----------------------------------------------------------------------------------------------

   439 static void TestFileSystemSubTypeQuery()

   440     {

   441     test.Next(_L("Test querying sub type of the mounted file system"));

   442     TFSName fsName;

   443     TPckgBuf<TFSName> subName;

   444     TInt i, r;

   445     TDriveInfo driveInfo;

   446     TPckgBuf<TBool> fDrvSyncBuf;

   449     for(i = EDriveA; i <= EDriveZ; ++i, subName.Zero())

   450         {

   451         r = TheFs.FileSystemName(fsName, i);

   452         if (r == KErrNone)

   453             {

   454             test.Printf(_L("Tested on drive: %c.\n"), (char)(i+'A'));

   455             r=TheFs.Drive(driveInfo, i);

   456             test(r==KErrNone);

   458             if (driveInfo.iType==EMediaNotPresent)

   459                 {

   460                 test.Printf(_L("The media is not present.\n"));

   461                 r = TheFs.QueryVolumeInfoExt(i, EFileSystemSubType, subName);

   462                 test(r == KErrNone || r == KErrNotReady);

   463                 }

   464             else if (driveInfo.iType==EMediaCdRom)

   465                 {

   466                 test.Printf(_L("CD ROM with no media will report not ready!\n"));

   467                 r = TheFs.QueryVolumeInfoExt(i, EFileSystemSubType, subName);

   468                 test(r == KErrNotReady);

   469                 }

   470             else

   471                 {

   472                 r = TheFs.QueryVolumeInfoExt(i, EFileSystemSubType, subName);

   473                 test_KErrNone(r);

   475                 //-- test EIsDriveSync command

   476                 r = TheFs.QueryVolumeInfoExt(i, EIsDriveSync, fDrvSyncBuf);

   477                 test(r == KErrNone);

   478                 if(fDrvSyncBuf())

   479                     test.Printf(_L("The drive is Synchronous.\n"));

   480                 else

   481                     test.Printf(_L("The drive is Asynchronous.\n"));

   483                 //-----------------

   485                 // if Fat, testing returning sub type name

   486                 if (fsName.CompareF(KFileSystemName_FAT)==0)

   487                     {

   488                     test(r == KErrNone);

   489                     test(subName().CompareF(KFSSubType_FAT12)==0 ||

   490                          subName().CompareF(KFSSubType_FAT16)==0 ||

   491                          subName().CompareF(KFSSubType_FAT32)==0);

   492                     continue;

   493                     }

   495                 // if Lffs, testing returning file system name

   496                 if (fsName.CompareF(_L("Lffs"))==0)

   497                     {

   498                     test(r == KErrNone);

   499                     test(subName().CompareF(_L("Lffs"))==0);

   500                     continue;

   501                     }

   502                 // if rofs, testing returning file system name

   503                 if (fsName.CompareF(_L("rofs"))==0)

   504                     {

   505                     test(r == KErrNone);

   506                     test(subName().CompareF(_L("rofs"))==0);

   507                     continue;

   508                     }

   509                 // if Composite, testing returning file system name

   510                 if (fsName.CompareF(_L("Composite"))==0)

   511                     {

   512                     test(r == KErrNone);

   513                     test(subName().CompareF(_L("Composite"))==0);

   514                     continue;

   515                     }

   517                 // else

   518                 test(r == KErrNone);

   519                 test(subName().Length()!=0);

   521                 }

   522             }

   523         }

   524     }

   526 //----------------------------------------------------------------------------------------------

   527 //! @SYMTestCaseID      PBASE-t_fsys-0318

   528 //! @SYMTestType        CIT

   529 //! @SYMPREQ            CR0882

   530 //! @SYMTestCaseDesc    This test case is testing querying file system's cluster size using

   531 //!                     RFs::QueryVolumeInfoExt() API.

   532 //! @SYMTestActions     1   querys cluster size of file system on volumes mounted with 'Fat' file system

   533 //!                     2   querys cluster size of file system on volumes mounted with 'Lffs' file system

   534 //!                     3   querys cluster size of file system on volumes mounted with other file systems

   535 //! @SYMTestExpectedResults

   536 //!                     1   returned error code should be KErrNone, cluster size should be non-zero

   537 //!                     2   returned error code should be KErrNone, cluster size should be 512

   538 //!                     3   returned error code should be KErrNone, cluster size should be KErrNotSupported

   539 //! @SYMTestPriority        High

   540 //! @SYMTestStatus          Implemented

   541 //----------------------------------------------------------------------------------------------

   542 static void TestFileSystemClusterSizeQuery()

   543     {

   544     test.Next(_L("Test querying cluster size information of the mounted file system"));

   545     TFullName fsName;

   546     TPckgBuf<TVolumeIOParamInfo> ioInfo;

   547     TInt i, r;

   548     TDriveInfo driveInfo;

   549     for(i = EDriveA; i <= EDriveZ; ++i)

   550         {

   551         r = TheFs.FileSystemName(fsName, i);

   552         if (r == KErrNone)

   553             {

   554             test.Printf(_L("Tested on drive: %c.\n"), (char)(i+'A'));

   556             r=TheFs.Drive(driveInfo, i);

   557             test(r==KErrNone);

   558             // if no media present

   559             if (driveInfo.iType==EMediaNotPresent)

   560                 {

   561                 r = TheFs.QueryVolumeInfoExt(i, EIOParamInfo, ioInfo);

   562                 test(r == KErrNone || r == KErrNotReady);

   563                 }

   564             else if (driveInfo.iType==EMediaCdRom)

   565                 {

   566                 test.Printf(_L("CD ROM with no media!\n"));

   567                 r = TheFs.QueryVolumeInfoExt(i, EIOParamInfo, ioInfo);

   568                 test(r == KErrNone || r == KErrNotReady);

   569                 }

   570             else

   571                 {

   572                 r = TheFs.QueryVolumeInfoExt(i, EIOParamInfo, ioInfo);

   573                 test(KErrNone == r);

   574                 // if Fat

   575                 if (fsName.CompareF(KFileSystemName_FAT)==0)

   576                     {

   577                     test(ioInfo().iClusterSize != 0);

   578                     continue;

   579                     }

   580                 // else if Lffs

   581                 if (fsName.CompareF(_L("Lffs"))==0)

   582                     {

   583                         TBusLocalDrive drive;

   584                         TBool changeFlag = EFalse;

   585                         TInt locDriveNumber;

   586                         TLocalDriveCaps DriveCaps;

   587                         TLocalDriveCapsV7 DriveCapsV7;

   588                         for(locDriveNumber = 0; locDriveNumber < KMaxLocalDrives; locDriveNumber++)

   589                         {

   590                             r = drive.Connect(locDriveNumber,changeFlag);

   591                             if(r==KErrNone)

   592                             {

   594                                 TPckg<TLocalDriveCaps> capsPckg(DriveCaps);

   595                                 r=drive.Caps(capsPckg);

   596                                 if((r==KErrNone) && (DriveCaps.iFileSystemId==KDriveFileSysLFFS))

   597                                 {

   598                                     break;

   599                                 }

   600                                 drive.Disconnect();

   601                             }

   602                         }

   603                         TPckg<TLocalDriveCapsV7> capsPckg(DriveCapsV7);

   604                         r=drive.Caps(capsPckg);

   605                         test(r==KErrNone);

   606                         drive.Disconnect();

   607                         if(DriveCapsV7.iObjectModeSize == 0)

   608                         {

   609                     test(ioInfo().iClusterSize == 512);

   610                     continue;

   611                         }

   612                         else

   613                         {

   614                             test((TUint32)(ioInfo().iClusterSize) == DriveCapsV7.iObjectModeSize);

   615                             continue;

   616                         }

   617                     }

   618                 // else

   619                 //-- we can not suggest anything about unknown filesystem, thus do not check the result.

   620                 //test(ioInfo().iClusterSize == KErrNotSupported);

   622                 }

   623             }

   624         }

   625     }

   627 //----------------------------------------------------------------------------------------------

   628 //! @SYMTestCaseID      PBASE-t_fsys-0319

   629 //! @SYMTestType        CIT

   630 //! @SYMPREQ            CR0882

   631 //! @SYMTestCaseDesc    This test case is testing querying block size of underlying media using

   632 //!                     RFs::QueryVolumeInfoExt() API.

   633 //! @SYMTestActions     1   querys block size on volumes mounted with MMC card type of media

   634 //!                     2   querys block size on volumes mounted with RAM type of media

   635 //!                     3   querys block size on volumes mounted with NOR flash type of media

   636 //!                     4   querys block size on volumes mounted with Nand flash (code) type of media

   637 //!                     5   querys block size on volumes mounted with Nand flash (data) type of media

   638 //! @SYMTestExpectedResults

   639 //!                     1   returned error code should be KErrNone, block size should be 512

   640 //!                     2   returned error code should be KErrNone, block size should be KDefaultVolumeBlockSize

   641 //!                     3   returned error code should be KErrNone, block size should be KDefaultVolumeBlockSize

   642 //!                     4   returned error code should be KErrNone, block size should be 512

   643 //!                     5   returned error code should be KErrNone, block size should be 512

   644 //! @SYMTestPriority        High

   645 //! @SYMTestStatus          Implemented

   646 //----------------------------------------------------------------------------------------------

   647 static void TestMediaBlockSizeQuery()

   648     {

   649     test.Next(_L("Test querying block size information of the underlying media"));

   650     #if defined(__WINS__)

   651         test.Printf(_L("This test case runs on hardware only"));

   652         return;

   654     #else   // test runs on hardware only.

   655     TFSName fsName;

   656     TPckgBuf<TVolumeIOParamInfo> ioInfo;

   657     TInt i, r;

   658     TDriveInfo driveInfo;

   659     for(i = EDriveA; i <= EDriveZ; ++i)

   660         {

   661         r = TheFs.FileSystemName(fsName, i);

   662         if (r == KErrNone)

   663             {

   664             test.Printf(_L("Tested on drive: %c.\n"), (char)(i+'A'));

   665             r=TheFs.Drive(driveInfo, i);

   666             test(r==KErrNone);

   667             // if no media present

   668             if (driveInfo.iType==EMediaNotPresent)

   669                 {

   670                 r = TheFs.QueryVolumeInfoExt(i, EIOParamInfo, ioInfo);

   671                 test(r == KErrNone || r == KErrNotReady);

   672                 }

   673             else if (driveInfo.iType==EMediaCdRom)

   674                 {

   675                 test.Printf(_L("CD ROM with no media will report not ready!\n"));

   676                 r = TheFs.QueryVolumeInfoExt(i, EIOParamInfo, ioInfo);

   677                 test(r == KErrNotReady);

   678                 }

   679             else

   680                 {

   681                 r = TheFs.QueryVolumeInfoExt(i, EIOParamInfo, ioInfo);

   682                 test(KErrNone == r);

   683                 // if MMC, test block size >= 512;

   684                 // (Version 4.3 MMC cards introduce the concept of a "Super Page" which should be used as

   685                 // guide when calculating the cluster size. For these cards the reported block size may be

   686                 // any multiple of 512).

   687                 if ((driveInfo.iType == EMediaHardDisk) &&

   688                     (driveInfo.iDriveAtt & KDriveAttRemovable) &&

   689                     (driveInfo.iDriveAtt & KDriveAttLocal))

   690                     {

   691                     test(ioInfo().iBlockSize >= 512);

   692                     continue;

   693                     }

   694                 // if RAM, test block size == 1;

   695                 if ((driveInfo.iType == EMediaRam) &&

   696                     (driveInfo.iDriveAtt & KDriveAttLocal) &&

   697                     (driveInfo.iDriveAtt & KDriveAttInternal))

   698                     {

   699                     test(ioInfo().iBlockSize == 1);

   700                     continue;

   701                     }

   702                 // if NOR flash, test block size == 512 (default block size);

   703                 if ((driveInfo.iType == EMediaFlash) &&

   704                     (driveInfo.iDriveAtt & KDriveAttLocal) &&

   705                     (driveInfo.iDriveAtt & KDriveAttInternal))

   706                     {

   707                     TBusLocalDrive drive;

   708                     TBool changeFlag = EFalse;

   709                     TInt locDriveNumber;

   710                     TLocalDriveCaps DriveCaps;

   711                     TLocalDriveCapsV7 DriveCapsV7;

   712                     for(locDriveNumber = 0; locDriveNumber < KMaxLocalDrives; locDriveNumber++)

   713                         {

   714                         r = drive.Connect(locDriveNumber,changeFlag);

   715                         if(r==KErrNone)

   716                             {

   717                             TPckg<TLocalDriveCaps> capsPckg(DriveCaps);

   718                             r=drive.Caps(capsPckg);

   719                             if((r==KErrNone) && (DriveCaps.iFileSystemId==KDriveFileSysLFFS))

   720                                 {

   721                                 break;

   722                                 }

   723                             drive.Disconnect();

   724                             }

   725                         }

   726                     TPckg<TLocalDriveCapsV7> capsPckg(DriveCapsV7);

   727                     r=drive.Caps(capsPckg);

   728                     test(r==KErrNone);

   729                     if ((fsName.CompareF(_L("Lffs"))==0) && (DriveCapsV7.iObjectModeSize != 0))

   730                         {

   731                         test(ioInfo().iBlockSize == (TInt) DriveCapsV7.iObjectModeSize);

   732                         continue;

   733                         }

   734                     else

   735                         {

   736                         test(ioInfo().iBlockSize == (TInt) KDefaultVolumeBlockSize);

   737                         continue;

   738                         }

   739                     }

   740                 // if Nand flash (with Fat file system), test block size == 512 (small-block) or 2048 (large-block)

   741                 if ((driveInfo.iType == EMediaNANDFlash) &&

   742                     (driveInfo.iDriveAtt & KDriveAttLocal) &&

   743                     (driveInfo.iDriveAtt & KDriveAttInternal))

   744                     {

   745                     test(ioInfo().iBlockSize == 512 || ioInfo().iBlockSize == 2048);

   746                     continue;

   747                     }

   748                 }

   749             }

   750         }

   751     #endif // __WINS__

   752     }

   754 //----------------------------------------------------------------------------------------------

   755 //! @SYMTestCaseID      PBASE-t_fsys-0320

   756 //! @SYMTestType        CIT

   757 //! @SYMPREQ            CR0882

   758 //! @SYMTestCaseDesc    This test case is testing wrapper API RFs::FileSystemSubType() has the same

   759 //!                     behaviours as RFs::QueryVolumeInfoExt()

   760 //! @SYMTestActions     1   querys file system sub type name by both APIs

   761 //! @SYMTestExpectedResults

   762 //!                     1   returned error codes and descriptors of both API should be identical

   763 //! @SYMTestPriority        High

   764 //! @SYMTestStatus          Implemented

   765 //----------------------------------------------------------------------------------------------

   766 static void TestFileSystemSubType()

   767     {

   768     test.Next(_L("Test wrapper API RFs::FileSystemSubType()'s behaviour"));

   769     TFSName fsName;

   770     TPckgBuf<TFSName> subName;

   771     TInt r;

   772     TFSName subName1;

   773     TInt r1;

   775     for(TInt i = EDriveA; i <= EDriveZ; ++i)

   776         {

   777         r = TheFs.FileSystemName(fsName, i);

   778         if (r == KErrNone)

   779             {

   780             test.Printf(_L("Tested on drive: %c.\n"), (char)(i+'A'));

   781             r = TheFs.QueryVolumeInfoExt(i, EFileSystemSubType, subName);

   782             r1 = TheFs.FileSystemSubType(i, subName1);

   783             test(r==r1);

   784             if (subName().Length())

   785                 {

   786                 test(subName().CompareF(subName1)==0);

   787                 }

   788             else

   789                 {

   790                 test(subName1.Length()==0);

   791                 }

   792             }

   793         }

   794     }

   796 //----------------------------------------------------------------------------------------------

   797 //! @SYMTestCaseID      PBASE-t_fsys-0321

   798 //! @SYMTestType        CIT

   799 //! @SYMPREQ            CR0882

   800 //! @SYMTestCaseDesc    This test case is testing wrapper API RFs::VolumeIOParam() has the same

   801 //!                     behaviours as RFs::QueryVolumeInfoExt()

   802 //! @SYMTestActions     1   querys volume IO params by both APIs

   803 //! @SYMTestExpectedResults

   804 //!                     1   returned error codes and IO param values of both API should be identical

   805 //! @SYMTestPriority        High

   806 //! @SYMTestStatus          Implemented

   807 //----------------------------------------------------------------------------------------------

   808 static void TestVolumeIOParam()

   809     {

   810     test.Next(_L("Test wrapper API RFs::VolumeIOParam()'s behaviour"));

   811     TFSName fsName;

   812     TPckgBuf<TVolumeIOParamInfo> ioInfo;

   813     TInt r;

   814     TVolumeIOParamInfo ioInfo1;

   815     TInt r1;

   817     for(TInt i = EDriveA; i <= EDriveZ; ++i)

   818         {

   819         r = TheFs.FileSystemName(fsName, i);

   820         if (r == KErrNone)

   821             {

   822             test.Printf(_L("Tested on drive: %c.\n"), (char)(i+'A'));

   823             r = TheFs.QueryVolumeInfoExt(i, EIOParamInfo, ioInfo);

   824             r1 = TheFs.VolumeIOParam(i, ioInfo1);

   825             test(r==r1);

   826             test(ioInfo().iBlockSize == ioInfo1.iBlockSize);

   827             test(ioInfo().iClusterSize == ioInfo1.iClusterSize);

   828             test(ioInfo().iRecReadBufSize == ioInfo1.iRecReadBufSize);

   829             test(ioInfo().iRecWriteBufSize == ioInfo1.iRecWriteBufSize);

   830             }

   831         }

   832     }

   835 //----------------------------------------------------------------------------------------------

   836 //! @SYMTestCaseID      PBASE-t_fsys-0322

   837 //! @SYMTestType        CIT

   838 //! @SYMPREQ            CR0882

   839 //! @SYMTestCaseDesc    This test case is testing RFs::QueryVolumeInfoExt() API on a testing file system

   840 //! @SYMTestActions     0   mounts testing file system on a certain drive

   841 //!                     1   querys file system's sub type name on the drive under testing

   842 //!                     2   querys file system's cluster size on the drive under testing

   843 //! @SYMTestExpectedResults

   844 //!                     1   returned error code should be KErrNone, sub type name should match 'Test3SubType'

   845 //!                     2   returned error code should be KErrNone, cluster size should equal 1024

   846 //! @SYMTestPriority        High

   847 //! @SYMTestStatus          Implemented

   848 //----------------------------------------------------------------------------------------------

   849 static void TestQueryVolumeInfoExtOnTestFS(TInt aDrive)

   850     {

   851     if (aDrive==EDriveC) // Can't test on C:

   852         return;

   854     TInt r;

   856     test.Printf(_L("Tested on drive: %c.\n"), (char)(aDrive+'A'));

   858     // Mount a new CTestFileSystem on the drive under test

   859     test.Next(_L("Test RFs::QueryVolumeInfoExt() on Testing File System"));

   860     r = TheFs.AddFileSystem(_L("T_TFSYS3"));

   861     if (r != KErrNone && r != KErrAlreadyExists)

   862         {

   863         test.Printf(_L("error=%d"),r);

   864         test(EFalse);

   865         }

   866     TFSName oldFs;

   867     r = TheFs.FileSystemName(oldFs,aDrive);

   868     test(r==KErrNone);

   869     r = TheFs.DismountFileSystem(oldFs,aDrive);

   870     if (r != KErrNone)

   871         {

   872         test.Printf(_L("Error = %d"),r);

   873         test(EFalse);

   874         }

   875     r = TheFs.MountFileSystem(_L("Test3"),aDrive);

   876     test(r==KErrNone);

   877     TFSName newFs;

   878     r = TheFs.FileSystemName(newFs,aDrive);

   879     test(r==KErrNone);

   880     test(newFs.Compare(_L("Test3"))==0);

   882     // Sub type name query:

   883     TPckgBuf<TFSName> subNameP;

   884     r = TheFs.QueryVolumeInfoExt(aDrive, EFileSystemSubType, subNameP);

   885     test(r==KErrNone);

   886     test(subNameP() == _L("Test3SubType"));

   888     // Cluster size querys:

   889     TPckgBuf<TVolumeIOParamInfo> ioInfoP;

   890     r = TheFs.QueryVolumeInfoExt(aDrive, EIOParamInfo, ioInfoP);

   891     test(r==KErrNone);

   892     test(ioInfoP().iClusterSize==1024);

   894     // Mount the original file system back

   895     r=TheFs.DismountFileSystem(newFs,aDrive);

   896     test(r==KErrNone);

   897     r=TheFs.MountFileSystem(oldFs,aDrive);

   898     test(r==KErrNone);

   900     r=TheFs.RemoveFileSystem(_L("Test3"));

   901     if(r!=KErrNone)

   902         {

   903         test.Printf(_L("error=%d"),r);

   904         test(EFalse);

   905         }

   906     }

   909 //----------------------------------------------------------------------------------------------

   910 /**

   911     Test remounting the file system with objects opened.

   912     scenario:

   913     1. create a file

   914     2. open it.

   915     3. forcedly remount the file system

   916     4. read this file (this will imply remounting the filesystem)

   917 */

   918 static void TestRemountFSWithOpenedObjects()

   919 {

   920     test.Next(_L("Testing forcedly remounting FS with objects opened.\n"));

   922     TInt nRes;

   924     //-- 1. create a file

   925     _LIT(KFile, "\\test_file.file");

   926     const TUint KFileSz = 5000;

   928     nRes = CreateCheckableStuffedFile(TheFs, KFile, KFileSz);

   929     test_KErrNone(nRes);

   931     RFile file;

   933     //-- 2. open this file

   934     nRes = file.Open(TheFs, KFile, EFileRead);

   935     test_KErrNone(nRes);

   937     //-- 2.1 try to dismount the FS, it must fail because of the opened object.

   938     TBuf<40> fsName;

   939     nRes = TheFs.FileSystemName(fsName, CurrentDrive());

   940     test_KErrNone(nRes);

   942     nRes = TheFs.DismountFileSystem(fsName, CurrentDrive());

   943     test(nRes == KErrInUse);

   946     //-- 3. forcedly remount the drive

   947     nRes = TheFs.RemountDrive(CurrentDrive());

   948     if(nRes == KErrNotSupported)

   949     {//-- this feature is not supported and the test is inconsistent.

   950         test.Printf(_L("RemountDrive() is not supported, the test is inconsistent!"));

   952         //-- remounting must work at least on MMC drives

   953         const TBool isFAT = Is_Fat(TheFs, CurrentDrive());

   955         TDriveInfo  driveInfo;

   956         nRes = TheFs.Drive(driveInfo, CurrentDrive());

   957         test_KErrNone(nRes);

   959         test(!isFAT || (!(driveInfo.iDriveAtt & KDriveAttRemovable)));

   961     }

   962     else

   963     {

   964         test_KErrNone(nRes);

   965     }

   967     User::After(500*K1mSec);

   969     //-- 4. read this file. The FS will be remounted and the read must be OK.

   970     TBuf8<40> buf;

   971     nRes = file.Read(0, buf, 30);

   972     test_KErrNone(nRes);

   974     file.Close();

   976     //-- 5. verify the file, just in case.

   977     nRes = VerifyCheckableFile(TheFs, KFile);

   978     test_KErrNone(nRes);

   980     //-- 6. delete the file

   981     TheFs.Delete(KFile);

   983 }

   984 //----------------------------------------------------------------------------------------------

   985 static void TestFileSystem_MaxSupportedFileSizeQuery()

   986 {

   987     test.Next(_L("Test querying max. supported file size on this file system"));

   988     TFullName fsName;

   989     TPckgBuf<TVolumeIOParamInfo> ioInfo;

   990     TVolumeIOParamInfo& volInfo = ioInfo();

   992     const TInt drvNo=CurrentDrive();

   994     TInt nRes;

   996     nRes = TheFs.FileSystemName(fsName, drvNo);

   997     test_KErrNone(nRes);

   999     nRes = TheFs.QueryVolumeInfoExt(drvNo, EIOParamInfo, ioInfo);

  1000     test_KErrNone(nRes);

  1002     test.Printf(_L("FS:'%S' Max File Size:0x%LX\n"), &fsName, volInfo.iMaxSupportedFileSize);

  1003     if(volInfo.iMaxSupportedFileSize == KMaxTUint64)

  1004     {

  1005         test.Printf(_L("Max File Size query isn't supported by this FS\n"));

  1006     }

  1009     //-- check the value for FAT FS only.

  1010     if(Is_Fat(TheFs, drvNo))

  1011     {

  1012         test(volInfo.iMaxSupportedFileSize == KMaxSupportedFatFileSize);

  1013     }

  1015 }

  1017 //----------------------------------------------------------------------------------------------

  1018 GLDEF_C void CallTestsL()

  1019 //

  1020 // Do all tests

  1021 //

  1022     {

  1024     //-- set up console output

  1025     Fat_Test_Utils::SetConsole(test.Console());

  1027     TInt drive=CurrentDrive();

  1029     PrintDrvInfo(TheFs, drive);

  1031     //Do not run this test on the NAND drive, as

  1032     //this has the FTL mounted as a primary extension

  1033     //which causes the test to fail

  1034     #if defined(__WINS__)

  1035         if (drive==EDriveU)

  1036             return;

  1037     #else

  1038         TDriveInfo driveInfo;

  1039         TheFs.Drive(driveInfo,drive);

  1040         if (driveInfo.iType == EMediaNANDFlash)

  1041             {

  1042             return;

  1043             }

  1044     #endif

  1046     //---------------------------------------

  1048     TestFileSystemNames();

  1049     TestDismountFileSystem(CurrentDrive());

  1050 #if defined(__EPOC32__)

  1051     TestFileSystem(CurrentDrive());

  1052 #endif

  1054     TestMountInvalidDrive();

  1056     TestMountingBrokenMedia(CurrentDrive());

  1057     TestSubstDriveMediaSerialNumber();

  1059     TestFileSystemSubTypeQuery();

  1060     TestFileSystemClusterSizeQuery();

  1061     TestMediaBlockSizeQuery();

  1062     TestFileSystemSubType();

  1063     TestVolumeIOParam();

  1064     TestQueryVolumeInfoExtOnTestFS(CurrentDrive());

  1066     TestFileSystem_MaxSupportedFileSizeQuery();

  1068     TestRemountFSWithOpenedObjects();

  1071     }

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200
changeset 1	260cb5ec6c19
permissions	-rw-r--r--