// Copyright (c) 1998-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the License "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// f32test\scndrv\t_scn32dr1.cpp

//

//

#include <f32file.h>

#include <e32test.h>

#include "t_server.h"

#include "fat_utils.h"

using namespace Fat_Test_Utils;

#ifdef __VC32__

    // Solve compilation problem caused by non-English locale

    #pragma setlocale("english")

#endif

/*

T_testscndrv tests the scandrive utility. Errors in this test will be

introduced using the RRawdDisk class.  The correct fixup is tested by rereading

the disk.  Drives tested are the default path(epoc) and X: (wins). This test

returns immediately if used on the internal ram drive

*/

/*

  The initial FAT12 directory structure (with cluster number in brackets) is as follows:

  |

   - scndrv (2)

        |

        - dir1 (3-4)

        |   |

        |   <a very long file name (19 entries)> (5)

        |

        - dir2 (6)

            |

            - full (7)

            |   |

            |   |

            |   - <seven 2*32 bytes entries> (11-17)

            |

            - somedirwith3entries (8)

            |

            - somedir2with3entries (9)

            |

            - almostfull(10)

                |

                - <two lots of 6*32 bytes entries> (18+19)

*/

/*

  The initial FAT32 directory structure (with cluster number in brackets is as follows):

  |

   - scndrv (3)

        |

        - dir1 (4)

        |   |

        |   <a very long file name (19 entries)> (5)

        |

        - dir2 (6)

            |

            - full (7)

            |   |

            |   |

            |   - <seven 2*32 bytes entries> (11-17)

            |

            - somedirwith3entries (8)

            |

            - somedir2with3entries (9)

            |

            - almostfull(10)

                |

                - <two lots of 6*32 bytes entries> (18+19)

*/

GLDEF_D RTest test(_L("T_SCN32DR1"));

LOCAL_D const TInt KMaxFatEntries  = 2048;

LOCAL_D const TInt KMaxFatSize     = KMaxFatEntries * 4;

LOCAL_D const TInt KDirAttrReadOnly  = 0x01;

LOCAL_D const TInt KDirAttrHidden    = 0x02;

LOCAL_D const TInt KDirAttrSystem    = 0x04;

LOCAL_D const TInt KDirAttrVolumeId  = 0x08;

LOCAL_D const TInt KDirAttrDirectory = 0x10;

LOCAL_D const TInt KDirAttrArchive   = 0x20;

LOCAL_D const TInt KDirAttrLongName  = KDirAttrReadOnly | KDirAttrHidden | KDirAttrSystem | KDirAttrVolumeId;

LOCAL_D const TInt KDirAttrLongMask  = KDirAttrLongName | KDirAttrDirectory | KDirAttrArchive;

LOCAL_D const TInt KDirLastLongEntry = 0x40;

LOCAL_D RRawDisk TheRawDisk;

LOCAL_D TFatBootSector BootSector;

LOCAL_D TFileName TheDrive=_L("?:\\");

LOCAL_D HBufC8* FatBufPtr = NULL;

LOCAL_D HBufC8* DirBufPtr = NULL;

LOCAL_D HBufC8* ExtBufPtr = NULL;

LOCAL_D TInt32  ExtBufAdd = 0;

LOCAL_D TInt32  ExtBufLen = 0;

LOCAL_D HBufC8* FatDiskPtr = NULL;

LOCAL_D HBufC8* DirDiskPtr = NULL;

static TFatType gDiskType = EInvalid;

LOCAL_D TInt gDriveNumber;

LOCAL_D TInt gBytesPerCluster;

LOCAL_D TInt gEntriesPerCluster;

LOCAL_D TInt gRootDirSectors;

LOCAL_D TInt gRootDirEntries;

LOCAL_D TInt gRootDirStart;      // in bytes

LOCAL_D TInt gRootSector;

LOCAL_D TInt gFatStartBytes;

LOCAL_D TInt gFatTestSize;       // in bytes

LOCAL_D TInt gFatTestEntries;

LOCAL_D TInt gFatSizeSectors;

LOCAL_D TInt gFirstDataSector;

LOCAL_D TInt gMaxDataCluster;

LOCAL_D TInt gDataStartBytes;

LOCAL_D TInt gEndOfChain;        // for FAT12/16/32

// cluster numbers in 1 and >1 sector per cluster modes

LOCAL_D TInt gClusterRootDir;        //  2    2

LOCAL_D TInt gClusterScnDrv;         //  3    3

LOCAL_D TInt gClusterDir1;           //  4    4

LOCAL_D TInt gClusterDir1ext;        //  5    4

LOCAL_D TInt gClusterDir2;           //  7    6

LOCAL_D TInt gClusterDir2_Full;      //  8    7

LOCAL_D TInt gClusterDir2_SD3E;      //  9    8

LOCAL_D TInt gClusterDir2_SD23E;     // 10    9

LOCAL_D TInt gClusterDir2_AFull;     // 11   10

LOCAL_D TInt gClusterEndMaxDepth;    // 147   146

LOCAL_D TFileName LastInFull;

class TEntryInfo

    {

public:

    TEntryInfo(TInt aBytePos,TInt aLength):iBytePos(aBytePos),iLength(aLength){}

    TEntryInfo(){}

public:

    TInt iBytePos;

    TInt iLength;

    };

LOCAL_C TInt DirBufferSize()

//

// returns size in bytes nec for buffer to store relevant disk data

//

    {

    return(gMaxDataCluster*gBytesPerCluster);

    }

LOCAL_C TInt PosInBytes(TInt aFatIndex)

//

// Return number of bytes into the FAT

//

    {

    TInt fatPosInBytes = -1;

    switch (gDiskType)

        {

        case EFat32:

            fatPosInBytes=aFatIndex<<2;

            break;

        case EFat16:

            fatPosInBytes=aFatIndex<<1;

            break;

        case EFat12:

            fatPosInBytes=(aFatIndex*3>>1);

            break;

        default:

            test(0);

        }

    return(fatPosInBytes);

    }

LOCAL_C TUint32 MaxClusters()

//

// Return the number of data clusters on the disk

//

    {

    TUint32 totSec = (BootSector.TotalSectors() ? BootSector.TotalSectors() : BootSector.HugeSectors());

    TUint32 numSec = totSec - gFirstDataSector;

    return numSec / BootSector.SectorsPerCluster();

    }

LOCAL_C TInt ClusterToByte(TInt aCluster)

//

// converts cluster number to byte offset on disk

//

    {

    TInt pos;

    if (aCluster < 2)

        pos = gRootDirStart;

    else

        pos = (aCluster - 2) * gBytesPerCluster + gFirstDataSector * BootSector.BytesPerSector();

    return pos;

    }

LOCAL_C TInt ByteToCluster(TInt aBytePos)

//

// Converts byte offset from root dir buffer to cluster number

//

    {

    if (aBytePos < gRootDirStart)

        return -1;

    if (aBytePos < gDataStartBytes)

        return 0;

    return (aBytePos - gDataStartBytes) / gBytesPerCluster + 2;

    }

LOCAL_C TInt ClusterEntryToBytes(TInt aCluster,TInt aEntry)

//

// converts position in cluster and entry number to byte pos from root directory

//

    {

    TInt pos;

    pos = ClusterToByte(aCluster) - gRootDirStart + aEntry*KSizeOfFatDirEntry;

    return pos;

    }

LOCAL_C TInt FindUnMatch(const TUint8* aBuf, const TUint8* aCmp, TInt aLen, TInt aStart=0)

//

// Return position in buffers which doesn't match, or -1 if it matches

//

    {

    for (TInt i = aStart; i < aStart + aLen; i++)

        if (aBuf[i] != aCmp[i])

            return i;

    return -1;

    }

LOCAL_C TUint32 GetFatEntry(TUint32 aIndex, const TUint8* aFat=NULL)

//

// Read a single FAT entry from disk or FAT copy and return it

//

    {

    TInt pos = PosInBytes(aIndex);

    TUint8  data[4];

    TUint8* ptr = data;

    if (aFat)

        ptr = (TUint8*)aFat + pos;

    else

        {

        pos += BootSector.ReservedSectors() * BootSector.BytesPerSector();

        TInt r=TheRawDisk.Open(TheFs,gSessionPath[0]-'A');

        test(r==KErrNone);

        TPtr8 buf(&data[0], 4);

        r=TheRawDisk.Read(pos, buf);

        test(r==KErrNone);

        TheRawDisk.Close();

        }

    TUint32 val = 0;

    switch (gDiskType)

        {

        case EFat32:

            val = ptr[0] + (ptr[1] << 8) + (ptr[2] << 16) + (ptr[3] << 24);

            break;

        case EFat16:

            val = ptr[0] + (ptr[1] << 8);

            break;

        case EFat12:

            val = ptr[0] + (ptr[1] << 8);

            if (aIndex & 1)

                    val >>= 4;

            val &= 0xFFF;

            break;

        default:

            test(0);

        }

    return val;

    }

LOCAL_C void WriteFat(TInt aFatIndex,TInt aValue,const TUint8* aFat)

//

// Write a value to both fats starting at aFat

//

    {

    TUint8* p=(TUint8*)(aFat+PosInBytes(aFatIndex));

    switch (gDiskType)

        {

        case EFat32:

            p[0] = (TUint8) (aValue);

            p[1] = (TUint8) (aValue >> 8);

            p[2] = (TUint8) (aValue >> 16);

            p[3] = (TUint8) (aValue >> 24);

            break;

        case EFat16:

            p[0] = (TUint8) (aValue);

            p[1] = (TUint8) (aValue >> 8);

            break;

        case EFat12:

            {

            TUint8 mask=0x0F;

            TBool odd=(aFatIndex)&1;

            TUint8 fatVal;

            TInt value=aValue;

            if(odd)

                {

                mask<<=4;

                value<<=4;

                fatVal=p[0];

                fatVal&=~mask;

                fatVal|=(TUint8)(value&0xFF);

                p[0]=fatVal;

                p[1]=(TUint8)(value>>8);

                }

            else

                {

                p[0]=(TUint8)(value&0xFF);

                fatVal=p[1];

                fatVal&=~mask;

                fatVal|=(TUint8)(value>>8);

                p[1]=fatVal;

                }

            }

            break;

        default:

            test(0);

        }

    return;

    }

static void DoReadBootSector()

    {

    TInt nRes = ReadBootSector(TheFs, CurrentDrive(), KBootSectorNum<<KDefaultSectorLog2, BootSector);

    test(nRes == KErrNone);

    if(!BootSector.IsValid())

        {

        test.Printf(_L("Wrong bootsector! Dump:\n"));

        BootSector.PrintDebugInfo();

        test(0);

        }

    // Calculate derived variables (fixed for a particular disk format)

    if (BootSector.RootDirEntries() == 0)

        {

        test.Printf(_L("Disk is FAT32\n"));

        gDiskType = EFat32;

        gEndOfChain = 0x0FFFFFFF;

        }

    else if (BootSector.FatType() == EFat16)

        {

        test.Printf(_L("Disk is FAT16\n"));

        gDiskType = EFat16;

        gEndOfChain = 0xFFFF;

        }

    else

        {

        test.Printf(_L("Disk is FAT12\n"));

        gDiskType = EFat12;

        gEndOfChain = 0x0FFF;

        }

    gBytesPerCluster   = BootSector.BytesPerSector() * BootSector.SectorsPerCluster();

    gFatStartBytes     = BootSector.ReservedSectors() * BootSector.BytesPerSector();

    gEntriesPerCluster = gBytesPerCluster / KSizeOfFatDirEntry;

    TBool big = (BootSector.SectorsPerCluster() > 1);

    switch (gDiskType)

        {

        case EFat12:

        case EFat16:

            gRootDirEntries     = BootSector.RootDirEntries();

            gRootDirSectors     = ((gRootDirEntries * KSizeOfFatDirEntry + BootSector.BytesPerSector() - 1) / BootSector.BytesPerSector());

            gFatSizeSectors     = BootSector.FatSectors();

            gRootSector         = BootSector.ReservedSectors() + BootSector.NumberOfFats() * gFatSizeSectors;

            gFirstDataSector    = gRootSector + gRootDirSectors;

            gDataStartBytes     = gFirstDataSector * BootSector.BytesPerSector();

            gRootDirStart       = gRootSector * BootSector.BytesPerSector();

            gClusterRootDir     = (big ?   0 :   0);

            gClusterScnDrv      = (big ?   2 :   2);

            gClusterDir1        = (big ?   3 :   3);

            gClusterDir1ext     = (big ?   3 :   4);

            gClusterDir2        = (big ?   5 :   6);

            gClusterDir2_Full   = (big ?   6 :   7);

            gClusterDir2_SD3E   = (big ?   7 :   8);

            gClusterDir2_SD23E  = (big ?   8 :   9);

            gClusterDir2_AFull  = (big ?   9 :  10);

            gClusterEndMaxDepth = (big ? 145 : 146);

            break;

        case EFat32:

            //

            // FAT32 will alway pre-allocate a single cluster for the root directory

            //

            //  - The following calculations may look wierd (as the spec says that the FAT32 root dir

            //    is not fixed) but for the purposes of this test we assume that root dir is only

            //    one cluster in size, so we don't fill up the disk trying to fill up the root dir.

            //

            gRootDirEntries     = gBytesPerCluster * 1 / KSizeOfFatDirEntry;    // Maximum entries within default FAT32 root directory (before extension)

            gRootDirSectors     = 0;                                            // FAT32 has no fixed root directory sectors over which to skip

            gFatSizeSectors     = BootSector.FatSectors32();

            gRootSector         = BootSector.ReservedSectors() + BootSector.NumberOfFats() * gFatSizeSectors;

            gFirstDataSector    = gRootSector;

            gDataStartBytes     = gFirstDataSector * BootSector.BytesPerSector();

            gRootDirStart       = (BootSector.RootClusterNum() - 2) * gBytesPerCluster + gDataStartBytes;

            gClusterRootDir     = (big ?   2 :   2);

            gClusterScnDrv      = (big ?   3 :   3);

            gClusterDir1        = (big ?   4 :   4);

            gClusterDir1ext     = (big ?   4 :   5);

            gClusterDir2        = (big ?   6 :   7);

            gClusterDir2_Full   = (big ?   7 :   8);

            gClusterDir2_SD3E   = (big ?   8 :   9);

            gClusterDir2_SD23E  = (big ?   9 :  10);

            gClusterDir2_AFull  = (big ?  10 :  11);

            gClusterEndMaxDepth = (big ? 146 : 147);

            break;

        default:

            break;

        }

    gMaxDataCluster = gClusterDir2_AFull + 2 + (gFirstDataSector / BootSector.SectorsPerCluster() + 1);

    gFatTestEntries = MaxClusters();

    if (gFatTestEntries > KMaxFatSize)

        gFatTestEntries = KMaxFatSize;

    }

GLDEF_C void DumpBootSector()

//

// Display (in log) TFatBootSector structure

//

    {

    RDebug::Print(_L("iBytesPerSector    = %8d"), BootSector.BytesPerSector());

    RDebug::Print(_L("iSectorsPerCluster = %8d"), BootSector.SectorsPerCluster());

    RDebug::Print(_L("iReservedSectors   = %8d"), BootSector.ReservedSectors());

    RDebug::Print(_L("iNumberOfFats      = %8d"), BootSector.NumberOfFats());

    RDebug::Print(_L("iRootDirEntries    = %8d"), BootSector.RootDirEntries());

    RDebug::Print(_L("iTotalSectors      = %8d"), BootSector.TotalSectors());

    RDebug::Print(_L("iMediaDescriptor   = %8d"), BootSector.MediaDescriptor());

    RDebug::Print(_L("iFatSectors        = %8d"), BootSector.FatSectors());

    RDebug::Print(_L("iSectorsPerTrack   = %8d"), BootSector.SectorsPerTrack());

    RDebug::Print(_L("iNumberOfHeads     = %8d"), BootSector.NumberOfHeads());

    RDebug::Print(_L("iHiddenSectors     = %8d"), BootSector.HiddenSectors());

    RDebug::Print(_L("iHugeSectors       = %8d"), BootSector.HugeSectors());

    if (gDiskType == EFat32)

        {

        RDebug::Print(_L("iFatSectors32      = %8d"), BootSector.FatSectors32());

        RDebug::Print(_L("iFATFlags          = %8d"), BootSector.FATFlags());

        RDebug::Print(_L("iVersionNumber     = %8d"), BootSector.VersionNumber());

        RDebug::Print(_L("iRootClusterNum    = %8d (0x%08X)"), BootSector.RootClusterNum(), gRootDirStart);

        RDebug::Print(_L("iFSInfoSectorNum   = %8d (0x%08X)"), BootSector.FSInfoSectorNum(), BootSector.FSInfoSectorNum() * BootSector.BytesPerSector());

        RDebug::Print(_L("iBkBootRecSector   = %8d (0x%08X)"), BootSector.BkBootRecSector(), BootSector.BkBootRecSector() * BootSector.BytesPerSector());

        }

    }

GLDEF_C void DumpFat(const TUint8* aFat=NULL)

//

// Dump to the log all those FAT entries which are non-zero

//

    {

    TInt32 max = MaxClusters();

    if (max > KMaxFatEntries)

        max = KMaxFatEntries;

    RDebug::Print(_L("---------------- DUMP OF FAT ---------------"));

    for (TInt32 i = 0; i < max; i++)

        {

        TInt32 val = GetFatEntry(i, aFat);

        TInt32 msk = 0x0FFFFFFF;

        switch (gDiskType)

            {

            case EFat32:

                msk = 0x0FFFFFFF;

                break;

            case EFat16:

                msk = 0xFFFF;

                break;

            case EFat12:

                msk = 0x0FFF;

                break;

            default:

                test(0);

            }

        if ((val & msk) == (0x0FFFFFFF & msk))

            RDebug::Print(_L("    %8d -> EOC"), i);

        else if ((val & msk) == (0x0FFFFFF8 & msk))

            RDebug::Print(_L("    %8d -> Media"), i);

        else if ((val & msk) == (0x0FFFFFF7 & msk))

            RDebug::Print(_L("    %8d -> BAD"), i);

        else if (val > max)

            RDebug::Print(_L("    %8d -> 0x%08X"), i, val);

        else if (val != 0)

            RDebug::Print(_L("    %8d -> %d"), i, val);

        }

    RDebug::Print(_L("--------------------------------------------"));

    }

GLDEF_C TDes* DirAttributes(TInt aAttrib)

//

// Return a pointer to a local buffer containing the attribute letters.

//

    {

    LOCAL_D TBuf<6> str;

    LOCAL_D char*   atr = "RHSVDA";

    str.Fill(TText('-'), 6);

    for (TInt i = 0; i < 6; i++)

        if ((aAttrib >> i) & 1)

            str[i] = atr[i];

    return &str;

    }

GLDEF_C TBool IsValidDirEntry(TFatDirEntry* aDir)

//

// Test whether buffer is a valid normal directory entry

//

    {

    // first character must be 0x05 or greater than space

    if (aDir->iData[0] < 0x21 && aDir->iData[0] != 0x05)

        return EFalse;

    // other characters must be not less than space

    for (TInt i = 1; i < 11; i++)

        if (aDir->iData[i] < 0x20)

            return EFalse;

    return ETrue;

    }

GLDEF_C void GetLongNamePart(TDes16& aName, const TUint8* aEntry, TInt aPos, TInt aOffset, TInt aLength)

//

// Extract part of a long name entry into the name buffer.

//

// @param aName   buffer to put name

// @param aEntry  directory entry raw data

// @param aPos    character in buffer to start name segment

// @param aOffset offset in directory entry of the segment

// @param aLength number of characters in the segment

//

    {

    for (TInt i = 0; i < aLength; i++)

        {

        TInt at = i * 2 + aOffset;

        TInt ch = aEntry[at] + aEntry[at+1] * 256;

        aName[aPos++] = TText(ch);

        }

    }

GLDEF_C void ExtractNameString(TDes16& aName, const TUint8* aEntry)

//

// Extract a long name part from a directory entry, truncate it at the first

// NUL (0) character and put quotes round it.

//

    {

    aName.SetLength(15);

    TInt len = aName.Length() - 1;

    TText qu = '\'';

    aName[0] = qu;

    GetLongNamePart(aName, aEntry,  1,  1, 5);

    GetLongNamePart(aName, aEntry,  6, 14, 6);

    GetLongNamePart(aName, aEntry, 12, 28, 2);

    TInt i;

    for (i = 0; i < len; i++)

        if (aName[i] == 0)

            break;

    aName[i++] = qu;

    aName.SetLength(i);

    }

GLDEF_C TBool DumpDirEntry(TInt aNum, const TUint8* aEntry)

//

// Dump a single directory entry to the log.  Return false if it was end of

// directory or an invalid entry (and don't display it).

//

    {

    TFatDirEntry* d = (TFatDirEntry*)aEntry;

    if (d->IsErased())

        {

        //RDebug::Print(_L("%5d: ERASED"), aNum);

        }

    else if (d->IsEndOfDirectory())

        {

        if (aNum > 0)

            RDebug::Print(_L("%5d: ------------- end of directory"), aNum);

        return EFalse;

        }

    else if ((d->Attributes() & KDirAttrLongMask) == KDirAttrLongName)

        {

        TBuf16<15> name;

        ExtractNameString(name, aEntry);

        TInt ord = aEntry[0];

        if (ord & KDirLastLongEntry)

            RDebug::Print(_L("%5d: %-15S #%-2d LAST"), aNum, &name, ord & ~KDirLastLongEntry);

        else

            RDebug::Print(_L("%5d: %-15S #%-2d"), aNum, &name, ord & ~KDirLastLongEntry);

        }

    else if (!IsValidDirEntry(d))

        {

        if (aNum > 0)

            RDebug::Print(_L("%5d: ============= INVALID ENTRY"), aNum);

        return EFalse;

        }

    else

        {

        TBuf<11> name;

        name.Copy(d->Name());

        RDebug::Print(_L("%5d: '%S'   %S  start %-5d size %d"),

                      aNum, &name, DirAttributes(d->Attributes()), d->StartCluster(), d->Size());

        }

    return ETrue;

    }

GLDEF_C void DumpDirCluster(const TUint8* aData, TInt aCluster=0)

//

// Dump directory entries until end of cluster or invalid/end entry found.

//

    {

    if (aCluster > 2)

        aData += (aCluster-2) * gBytesPerCluster;

    for (TInt i = 0; i < gBytesPerCluster; i += KSizeOfFatDirEntry)

        {

        if (DumpDirEntry(i/KSizeOfFatDirEntry, aData))

            aData += KSizeOfFatDirEntry;

        else

            break;

        }

    }

GLDEF_C void DumpRootDir(const TUint8* aData)

//

// Dump the data area buffer, trying to interpret directory clusters (only look

// at clusters which are marked as 'used' in the FAT).

//

    {

    RDebug::Print(_L("Root dir @ 0x%08X:"), gRootDirStart);

    for (TInt i = 0; i < BootSector.RootDirEntries(); i++)

        {

        if (DumpDirEntry(i, aData))

            aData += KSizeOfFatDirEntry;

        else

            break;

        }

    }

GLDEF_C void DumpData(const TUint8* aFat, const TUint8* aDir)

//

// Dump the data area buffer, trying to interpret directory clusters (only look

// at clusters which are marked as 'used' in the FAT).

//

    {

    RDebug::Print(_L("--------------- DATA AREA ------------------"));

    if (gDiskType != EFat32)

        {

        DumpRootDir(aDir);

        }

    TInt max = (gFatTestEntries < gMaxDataCluster ? gFatTestEntries : gMaxDataCluster);

    for (TInt cluster = 2; cluster < max; cluster++)

        {

        if (GetFatEntry(cluster, aFat) != 0)

            {

            RDebug::Print(_L("Cluster %d @ 0x%08X:"), cluster, ClusterToByte(cluster));

            DumpDirCluster(aDir+gDataStartBytes-gRootDirStart, cluster);

            }

        }

    RDebug::Print(_L("--------------------------------------------"));

    }

GLDEF_C void DumpData(const TUint8* aFat, TInt aStart, TInt aEnd = -1)

//

// Dump clusters from disk (allows dumping of clusters not in our buffers).

// Only look at clusters marked as 'used' in the FAT.  Note that if aFat is

// NULL the FAT entries will also be read from disk (slower but allows for ones

// outside our copy in memory).

//

    {

    if (aStart > gFatTestEntries)

        return;

    RDebug::Print(_L("--------------- DATA AREA ------------------"));

    if (aEnd > gFatTestEntries)

        aEnd = gFatTestEntries;

    if (aEnd < 0)

        aEnd = aStart + 1;

    if (aStart < 2 && gDiskType != EFat32)

        {

        HBufC8* buf=HBufC8::New(BootSector.RootDirEntries() * KSizeOfFatDirEntry);

        test(buf != NULL);

        TPtr8 ptr=buf->Des();

        TInt r=TheRawDisk.Open(TheFs,gSessionPath[0]-'A');

        test(r==KErrNone);

        r=TheRawDisk.Read(gRootDirStart, ptr);

        test(r==KErrNone);

        TheRawDisk.Close();

        DumpRootDir(buf->Ptr());

        delete(buf);

        aStart = 2;

        }

    for (TInt cluster = aStart; cluster < aEnd; cluster++)

        {

        if (GetFatEntry(cluster, aFat) != 0)

            {

            HBufC8* buf=HBufC8::New(gBytesPerCluster);

            test(buf!=NULL);

            TPtr8 ptr=buf->Des();

            TInt r=TheRawDisk.Open(TheFs,gSessionPath[0]-'A');

            test(r==KErrNone);

            r=TheRawDisk.Read(ClusterToByte(cluster), ptr);

            test(r==KErrNone);

            TheRawDisk.Close();

            RDebug::Print(_L("Cluster %d @ 0x%08X:"), cluster, ClusterToByte(cluster));

            DumpDirCluster(ptr.Ptr());

            delete buf;

            }

        }

    RDebug::Print(_L("--------------------------------------------"));

    }

GLDEF_C void DumpHex(const TUint8* aData, TInt aLen, TInt aBase=0)

//

// Dump a block of memory to the log in hex.

//

    {

    for (TInt base = 0; base < aLen; base += 16)

        {

        TBuf<16*3+3+16+1> buf;

        TInt off;

        for (off = base; off < aLen && off < base + 16; off++)

            {

            buf.Append(TText(' '));

            buf.AppendNumFixedWidth(aData[off], EHex, 2);

            }

        buf.Append(_L("  |"));

        for (off = base; off < aLen && off < base + 16; off++)

            {

            TUint8 ch = aData[off];

            buf.Append(ch < 0x20 || ch > 0x7E ? TText('_') : TText(ch));

            }

        buf.Append(_L("|"));

        RDebug::Print(_L("%04X: %S"), base+aBase, &buf);

        }

    }

GLDEF_C void DumpHex(const TPtrC8& aData, TInt aLen, TInt aBase=0)

//

// Dump a block of memory to the log in hex.

//

    {

    DumpHex(aData.Ptr(), aLen, aBase);

    }

GLDEF_C void DumpHex(TInt aPos, TInt aLen, TInt aBase=0)

//

// Dump a block of memory to the log in hex.

//

    {

    TPtr8 dirBuf=DirBufPtr->Des();

    DumpHex(dirBuf.Ptr()+aPos, aLen, aBase);

    }

GLDEF_C void Dump(TEntryInfo& aEntry)

//

// Dump an entry description to the log in hex

//

    {

    RDebug::Print(_L("--- TEntryInfo 0x%08X, %d"), aEntry.iBytePos, aEntry.iLength);

    TInt len = aEntry.iLength*KSizeOfFatDirEntry;

    DumpHex(aEntry.iBytePos, len, aEntry.iBytePos);

    }

LOCAL_C TInt GetStartCluster(TInt aCluster, TInt aEntry)

//

// Get the start cluster pertaining to a directory entry in a specific

// directory cluster, return -1 if not available (invalid entry).

//

    {

    HBufC8* buf=HBufC8::New(gBytesPerCluster*2);

    test(buf!=NULL);

    TPtr8 ptr=buf->Des();

    TInt r=TheRawDisk.Open(TheFs,gSessionPath[0]-'A');

    test(r==KErrNone);

    r=TheRawDisk.Read(ClusterToByte(aCluster), ptr);

    test(r==KErrNone);

    TheRawDisk.Close();

    RDebug::Print(_L("Cluster %d @ 0x%08X:"), aCluster, ClusterToByte(aCluster));

    TFatDirEntry* d = (TFatDirEntry*)ptr.Ptr() + aEntry;

    while ((d->Attributes() & KDirAttrLongMask) == KDirAttrLongName && aEntry < gEntriesPerCluster)

        {

        if (d->IsErased() || d->IsEndOfDirectory())

            break;

        ++aEntry;

        d = (TFatDirEntry*)ptr.Ptr() + aEntry;

        }

    TInt start = d->StartCluster();

    if (d->IsErased())

        start = -1;

    else if (d->IsEndOfDirectory())

        start = -1;

    else if ((d->Attributes() & KDirAttrLongMask) == KDirAttrLongName)

        start = -1;

    else if (!IsValidDirEntry(d))

        start = -1;

    delete buf;

    return start;

    }

LOCAL_C void Format()

    {

    TInt nRes;

#if 0

    TFatFormatParam fmt;

    fmt.iFatType = EFat32;

    fmt.iSecPerCluster = 1;

    nRes = FormatFatDrive(TheFs, CurrentDrive(), ETrue, &fmt);

#else

    nRes = FormatFatDrive(TheFs, CurrentDrive(), ETrue);

#endif

    test(nRes == KErrNone);

    }

LOCAL_C void CreateDeepDir(TFileName& aDir,TInt aDepth)

//

// Increase directory strucutre by aDepth starting with aDir.

//

    {

    TFileName num;

    num.Num(1);

    num+=_L("\\");

    TInt r;

    while(aDepth--)

        {

        num[0] = TText(aDepth % 26 + 'A');

        aDir+=num;

        r=TheFs.MkDir(aDir);

        test(r==KErrNone);

        }

    }

LOCAL_C void DeleteDeepDir(TFileName& aDir,TInt aDepth)

//

// Delete dir structure.

//

    {

    TInt r;

    while(aDepth--)

        {

        r=TheFs.RmDir(aDir);

        test(r==KErrNone);

        aDir.SetLength(aDir.Length()-2);

        }

    }

LOCAL_C void CreateMaxDepthDir(TFileName& aDir1,TFileName& aDir2)

//

// Create directory structure with max possible depth-1.

// Achieved by using dir names of one character.

//

    {

    //create dir structure with depth of 25

    CreateDeepDir(aDir1,25);

    // split dir structure

    aDir2=aDir1;

    aDir2+=_L("a\\");

    TInt r=TheFs.MkDir(aDir2);

    test(r==KErrNone);

    // create dir with depth of 126 directories - one short of max depth

    CreateDeepDir(aDir1,101);

    // create dir with depth of 90

    CreateDeepDir(aDir2,64);

    }

LOCAL_C void DeleteMaxDepthDir(TFileName&aDir1,TFileName&aDir2)

//

// Deletes max depth dir structure.

//

    {

    DeleteDeepDir(aDir2,64);

    TInt r=TheFs.RmDir(aDir2);

    test(r==KErrNone);

    aDir2.SetLength(aDir2.Length()-2);

    DeleteDeepDir(aDir1,102);

    DeleteDeepDir(aDir1,24);

    }

LOCAL_C void MakeVeryLongName(TFileName& aLong)

//

// appends a very long file name to aLong

//

    {

    // create a name to take up 18 vfat entries - (1 sector + 2 entries)

    for(TInt i=0;i<234;++i)

        {

        TInt c='a'+i%26;

        aLong.Append(c);

        }

    }

GLDEF_C void CreateLongNames(TFileName& aLong, TInt aClusters)

//

// Creates entries to fill up the number of directory clusters

//

    {

    TInt len = aLong.Length(); // length of directory prefix

    MakeVeryLongName(aLong);

    TInt count = 0;

    RFile temp;

    for (TInt i = 0; i < aClusters * gEntriesPerCluster; i += 19)

        {

        aLong[len+0] = TText(count/26 + 'A');

        aLong[len+1] = TText(count%26 + 'A');

        count++;

        TInt r=temp.Create(TheFs,aLong,EFileShareAny);

        test(r==KErrNone);

        temp.Close();

        }

    }

GLDEF_C void DeleteLongNames(TFileName& aLong, TInt aClusters)

//

// Deletes entries created by CreateLongNames()

//

    {

    TInt len = aLong.Length(); // length of directory prefix

    MakeVeryLongName(aLong);

    TInt count = 0;

    for (TInt i = 0; i < aClusters * gEntriesPerCluster; i += 19)

        {

        aLong[len+0] = TText(count/26 + 'A');

        aLong[len+1] = TText(count%26 + 'A');

        count++;

        TInt r=TheFs.Delete(aLong);

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

        }

    }

LOCAL_C void DeleteRootDir(TInt aNum=0)

//

// Delete all entries in the root directory up to the last - aNum

//

    {

    test.Next(_L("Delete Root Directory Entries"));

    TInt maxRootEntries = gRootDirEntries;

    TFileName name=_L("\\???xxx");

    TInt count=0;

    TInt entriesSoFar=2;

    TInt r;

    count = 0;

    for (entriesSoFar=0; entriesSoFar<maxRootEntries - aNum; entriesSoFar+=2)

        {

        name[1]=(TUint16)(count/26/26+'a');

        name[2]=(TUint16)(count/26%26+'a');

        name[3]=(TUint16)(count%26+'a');

        r=TheFs.Delete(name);

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

        ++count;

        }

    }

LOCAL_C void CreateRootDir()

//

// fill up root directory to 1 clusters by creating entries and then deleting

// them except the last.

//

    {

    test.Next(_L("Create Root Directory Entries"));

    TInt maxRootEntries = gRootDirEntries;

    TFileName name=_L("\\???xxx");

    TInt count=0;

    TInt entriesSoFar=2;

    TInt r;

    RFile f;

    for (entriesSoFar=0; entriesSoFar<maxRootEntries; entriesSoFar+=2)

        {

        name[1]=(TUint16)(count/26/26+'a');

        name[2]=(TUint16)(count/26%26+'a');

        name[3]=(TUint16)(count%26+'a');

        r=f.Create(TheFs, name, EFileWrite);

        test(r==KErrNone);

        f.Close();