Fix for bug 3292 - [GCCE] Possible undefined behaviour warning in kerneltest/f32test/server/t_fatcharsetconv_SpecificCases.cpp
Fix for bug 3293 - [GCCE] Incorrect operator precedence assumptions in kerneltest/f32test/server/t_fsrv.cpp
Fix for bug 3295 - [GCCE] deprecated conversion from string constant to 'char*' in f32test build
Fix for bug 3297 - [GCCE] Operator precedence warnings in kerneltest/f32test/demandpaging/t_nandpaging.cpp
Fix for bug 3309 - [GCCE] Terminal backslashes in comments are parsed as line-continuations in f32test
// Copyright (c) 1996-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\server\b_fat32.cpp
//
//
#define __E32TEST_EXTENSION__
#include <f32file.h>
#include <e32test.h>
#include <e32math.h>
#include "fat_utils.h"
#include "t_server.h"
using namespace Fat_Test_Utils;
RTest test(_L("B_FAT32"));
static RRawDisk TheDisk;
static RFile TheFile;
static RDir TheDir;
static TEntry TheEntry;
static TFileName TheFileName;
static TBuf<16> TheDrive;
static HBufC8* pBuffer1=NULL;
static HBufC8* pBuffer2=NULL;
static TBuf8<0x800> TheBuffer;
static TEntry TheFileInfo;
static TVolumeInfo TheVolumeInfo;
static TBuf<8> ThePddName;
static TFatBootSector TheBootSector;
static TInt64 rndSeed;
static TFatType gDiskType = EInvalid;
static TInt gFatBits = 0;
static TInt gBytesPerCluster;
static TInt gEntriesPerCluster;
static TInt gDataStartBytes;
static TInt gRootDirSectors;
static TInt gTotalSectors;
static TInt gRootDirStart;
static TInt gRootSector;
static TInt gRootCluster;
static TInt gFatTestEntries;
static TInt gFatSizeSectors;
static TInt gFirstDataSector;
static TInt gFirstDataCluster;
static TInt gClusterCount;
static TInt gEndOfChain; // for FAT12/16/32
const TInt KMaxFatEntries = 2048;
const TInt KMaxFatSize = KMaxFatEntries * 4;
const TUint KDirAttrReadOnly = 0x01;
const TUint KDirAttrHidden = 0x02;
const TUint KDirAttrSystem = 0x04;
const TUint KDirAttrVolumeId = 0x08;
const TUint KDirAttrDirectory = 0x10;
const TUint KDirAttrArchive = 0x20;
const TUint KDirAttrLongName = KDirAttrReadOnly | KDirAttrHidden | KDirAttrSystem | KDirAttrVolumeId;
const TUint KDirAttrLongMask = KDirAttrLongName | KDirAttrDirectory | KDirAttrArchive;
const TUint KDirLastLongEntry = 0x40;
void CreateFatEntry(const TDesC& aDir, TBool aVFatEntry, TDes *apFileName=NULL);
#define Error(aMess,aErr) PutError(__FILE__, __LINE__, aMess,aErr)
static void PutError(const char* aFile, TInt aLine, const TDesC& aMessage,TInt anErr)
{
TFileName buf;
TPtrC8 ptr((const TUint8*)aFile);
buf.Copy(ptr);
test.Printf(_L("%S failed - %d\n"), &aMessage,anErr);
test.Printf(_L("In %S line %d\n"), &buf, aLine);
test(0);
}
//
// Position calculation and disk reading routines
// Return number of bytes into the FAT
static TInt PosInBytes(TInt aFatIndex)
{
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);
}
static TUint32 MaxClusters()
//
// Return the number of data clusters on the disk
//
{
TUint32 totSec = (TheBootSector.TotalSectors() ? TheBootSector.TotalSectors() : TheBootSector.HugeSectors());
TUint32 numSec = totSec - gFirstDataSector;
return numSec / TheBootSector.SectorsPerCluster();
}
static TInt ClusterToByte(TInt aCluster)
//
// converts cluster number to byte offset on disk
//
{
if (aCluster < 2)
return gRootDirStart;
TInt sector = (aCluster - 2) * gBytesPerCluster + gFirstDataSector * TheBootSector.BytesPerSector();
return sector;
}
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 += TheBootSector.ReservedSectors() * TheBootSector.BytesPerSector();
TInt r=TheDisk.Open(TheFs,gSessionPath[0]-'A');
test_KErrNone(r);
TPtr8 buf(&data[0], 4);
r=TheDisk.Read(pos, buf);
test_KErrNone(r);
TheDisk.Close();
}
TUint32 val = 0;
switch (gDiskType)
{
case EFat32:
val = *(TUint32*)ptr;
break;
case EFat16:
val = *(TUint16*)ptr;
break;
case EFat12:
val = *(TUint16*)ptr;
if (aIndex & 1)
val >>= 4;
val &= 0xFFF;
break;
default:
test(0);
}
return val;
}
void MarkFatEntry(TUint32 aIndex)
//
// Marks a single FAT entry by modifying it's top 4 bits to
//
{
TInt pos = PosInBytes(aIndex);
pos += TheBootSector.ReservedSectors() * TheBootSector.BytesPerSector();
TInt r=TheDisk.Open(TheFs,gSessionPath[0]-'A');
test_KErrNone(r);
TUint8 data[4];
TPtr8 buf(&data[0], 4);
r=TheDisk.Read(pos, buf);
test_KErrNone(r);
data[3] &= 0x0F;
data[3] |= 0xA0;
r=TheDisk.Write(pos, buf);
test_KErrNone(r);
TheDisk.Close();
}
void DumpBootSector()
//
// Display (in log) TFatBootSector structure
//
{
RDebug::Print(_L("BytesPerSector = %8d"), TheBootSector.BytesPerSector());
RDebug::Print(_L("SectorsPerCluster = %8d (%d bytes)"),
TheBootSector.SectorsPerCluster(), gBytesPerCluster);
RDebug::Print(_L("ReservedSectors = %8d"), TheBootSector.ReservedSectors());
RDebug::Print(_L("NumberOfFats = %8d"), TheBootSector.NumberOfFats());
RDebug::Print(_L("RootDirEntries = %8d"), TheBootSector.RootDirEntries());
RDebug::Print(_L("TotalSectors = %8d"), TheBootSector.TotalSectors());
RDebug::Print(_L("MediaDescriptor = %8d"), TheBootSector.MediaDescriptor());
RDebug::Print(_L("FatSectors = %8d"), TheBootSector.FatSectors());
RDebug::Print(_L("SectorsPerTrack = %8d"), TheBootSector.SectorsPerTrack());
RDebug::Print(_L("NumberOfHeads = %8d"), TheBootSector.NumberOfHeads());
RDebug::Print(_L("HiddenSectors = %8d"), TheBootSector.HiddenSectors());
RDebug::Print(_L("HugeSectors = %8d"), TheBootSector.HugeSectors());
//New for FAT32
if(TheBootSector.RootDirEntries() == 0) //indicates we have FAT32 volume
{
RDebug::Print(_L("FatSectors32 = %8d"), TheBootSector.FatSectors32());
RDebug::Print(_L("FATFlags = %8d"), TheBootSector.FATFlags());
RDebug::Print(_L("VersionNumber = %8d"), TheBootSector.VersionNumber());
RDebug::Print(_L("RootClusterNum = %8d (0x%08X)"),
TheBootSector.RootClusterNum(),
gRootDirStart);
RDebug::Print(_L("FSInfoSectorNum = %8d (0x%08X)"),
TheBootSector.FSInfoSectorNum(),
TheBootSector.FSInfoSectorNum() * TheBootSector.BytesPerSector());
RDebug::Print(_L("BkBootRecSector = %8d (0x%08X)"),
TheBootSector.BkBootRecSector(),
TheBootSector.BkBootRecSector() * TheBootSector.BytesPerSector());
}
TInt fatEntries = gFatSizeSectors*TheBootSector.BytesPerSector();
switch (gDiskType)
{
case EFat32:
fatEntries /= 4;
break;
case EFat16:
fatEntries /= 2;
break;
case EFat12:
fatEntries *= 3;
fatEntries /= 2;
break;
default:
test(0);
}
RDebug::Print(_L("ClusterCount = %8d (%ld bytes)"), gClusterCount, ((TInt64)gClusterCount)*gBytesPerCluster);
RDebug::Print(_L("FatEntries = %8d (%d sectors)"), fatEntries, gFatSizeSectors);
RDebug::Print(_L("RootSector = %8d (0x%08X)"), gRootSector, gRootDirStart);
RDebug::Print(_L("FirstDataSector = %8d (0x%08X)"), gFirstDataSector, gDataStartBytes);
}
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("--------------------------------------------"));
}
TDes* DirAttributes(TInt aAttrib)
//
// Return a pointer to a local buffer containing the attribute letters.
//
{
static TBuf<6> str(_L("------"));
static char const * atr = "RHSVDA";
for (TInt i = 0; i < 6; i++)
if ((aAttrib >> i) & 1)
str[i] = atr[i];
return &str;
}
TBool IsValidDirChar(TUint8 aChar, TUint8 aMin=0x20)
//
// Test whether a character is valid as part of a short filename, aMin is to
// distinguish between first character (which can't be space) and later ones
// which can include space but nothing less. Note that E5 is a valid character
// in any position, even though it means 'erased' in the first character.
//
{
const TUint8* inval = (TUint8*)"\x22\x2A\x2B\x2C\x2F\x3A\x3B\x3C\x3D\x3E\x3F\x5B\x5C\x5D\x7C";
if (aChar < aMin)
return EFalse;
for (const TUint8* p = inval; *p; p++)
if (aChar == *p)
return EFalse;
return ETrue;
}
TBool IsValidDirEntry(TFatDirEntry* aDir)
//
// Test whether buffer is a valid normal directory entry
//
{
// top two bits of attributes must be zero
if (aDir->iData[11] & 0xC0)
return EFalse;
// first character must be 0x05 or greater than space
if (!IsValidDirChar(aDir->iData[0], 0x21) && aDir->iData[0] != 0x05)
return EFalse;
// other characters in name must be not less than space
for (TInt i = 1; i < 11; i++)
if (!IsValidDirChar(aDir->iData[i]))
return EFalse;
return ETrue;
}
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);
}
}
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);
}
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())
{
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))
{
RDebug::Print(_L("%5d: not valid"), aNum);
return EFalse;
}
else
{
TBuf<11> name;
name.Copy(d->Name());
RDebug::Print(_L("%5d: '%S' %S cluster %d"),
aNum, &name, DirAttributes(d->Attributes()), d->StartCluster());
}
return ETrue;
}
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;
}
}
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;
if (aEnd > gFatTestEntries)
aEnd = gFatTestEntries;
if (aEnd <= 0)
aEnd = aStart + 1;
RDebug::Print(_L("--------------- DATA AREA ------------------"));
if (aEnd > gFatTestEntries)
aEnd = gFatTestEntries;
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=TheDisk.Open(TheFs,gSessionPath[0]-'A');
test_KErrNone(r);
r=TheDisk.Read(ClusterToByte(cluster), ptr);
test_KErrNone(r);
TheDisk.Close();
RDebug::Print(_L("Cluster %d @ 0x%08X:"), cluster, ClusterToByte(cluster));
DumpDirCluster(ptr.Ptr());
delete buf;
}
}
RDebug::Print(_L("--------------------------------------------"));
}
void DumpData(TInt aStart=0, TInt aEnd=0)
//
// 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 == 0)
{
if (aEnd <= 0)
aEnd = 1;
TInt num = (gDiskType == EFat32 ? aEnd*gEntriesPerCluster : TheBootSector.RootDirEntries());
TInt pos = gRootDirStart;
TInt ent = 0;
HBufC8* buf=HBufC8::New(KSizeOfFatDirEntry);
test(buf!=NULL);
TPtr8 ptr=buf->Des();
TInt r=TheDisk.Open(TheFs,gSessionPath[0]-'A');
test_KErrNone(r);
RDebug::Print(_L("--------------- ROOT DIR ------------------"));
for (TInt i = 0; i < num; i++)
{
r=TheDisk.Read(pos, ptr);
test_KErrNone(r);
if (!DumpDirEntry(ent, ptr.Ptr()))
break;
pos += KSizeOfFatDirEntry;
}
RDebug::Print(_L("-------------------------------------------"));
TheDisk.Close();
delete buf;
}
else if (aStart == 1)
{
DumpData(0, 1);
DumpData(NULL, gFirstDataCluster, aEnd);
}
else
{
DumpData(NULL, aStart, aEnd);
}
}
void DumpHex(const TUint8* aData, TInt aLen)
//
// Dump a block of memory to the log in hex.
//
{
for (TInt base = 0; base < aLen; base += 16)
{
TBuf<16*3> buf;
TInt off;
for (off = base; off < aLen && off < base + 16; off++)
{
buf.Append(TText(' '));
buf.AppendNumFixedWidth(aData[off], EHex, 2);
}
RDebug::Print(_L("%04X: %S"), base, &buf);
}
}
//---------------------------------------------------------------------------------------------------------------
static void DoReadBootSector(TFatBootSector& aBootSector)
{
TInt nRes = ReadBootSector(TheFs, CurrentDrive(), KBootSectorNum<<KDefaultSectorLog2, aBootSector);
test(nRes == KErrNone);
if(!aBootSector.IsValid())
{
test.Printf(_L("Wrong bootsector! Dump:\n"));
aBootSector.PrintDebugInfo();
test(0);
}
// Calculate derived variables (fixed for a particular disk format)
if (TheBootSector.FatType() == EFat32)
{
gDiskType = EFat32;
gFatBits = 32;
gEndOfChain = 0x0FFFFFFF;
}
else if (TheBootSector.FatType() == EFat16)
{
gDiskType = EFat16;
gFatBits = 16;
gEndOfChain = 0xFFFF;
}
else
{
gDiskType = EFat12;
gFatBits = 12;
gEndOfChain = 0x0FFF;
}
gBytesPerCluster = TheBootSector.BytesPerSector() * TheBootSector.SectorsPerCluster();
gRootDirSectors = ((TheBootSector.RootDirEntries() * KSizeOfFatDirEntry + TheBootSector.BytesPerSector() - 1) /
TheBootSector.BytesPerSector());
gEntriesPerCluster = gBytesPerCluster / KSizeOfFatDirEntry;
gTotalSectors = (TheBootSector.TotalSectors() ? TheBootSector.TotalSectors() : TheBootSector.HugeSectors());
switch (gDiskType)
{
case EFat12:
case EFat16:
gFatSizeSectors = TheBootSector.FatSectors();
gRootSector = TheBootSector.ReservedSectors() + TheBootSector.NumberOfFats() * gFatSizeSectors;
gFirstDataSector = gRootSector + gRootDirSectors;
gRootCluster = 0;
gFirstDataCluster = 2;
gDataStartBytes = gFirstDataSector * TheBootSector.BytesPerSector();
gRootDirStart = gRootSector * TheBootSector.BytesPerSector();
break;
case EFat32:
gFatSizeSectors = TheBootSector.FatSectors32();
gRootSector = TheBootSector.ReservedSectors() + TheBootSector.NumberOfFats() * gFatSizeSectors;
gFirstDataSector = gRootSector + gRootDirSectors;
gRootCluster = 2;
gFirstDataCluster = 3;
gDataStartBytes = gFirstDataSector * TheBootSector.BytesPerSector();
gRootDirStart = (TheBootSector.RootClusterNum() - 2) * gBytesPerCluster + gDataStartBytes;
break;
default:
break;
}
gClusterCount = (gTotalSectors - gFirstDataSector) / TheBootSector.SectorsPerCluster();
gFatTestEntries = MaxClusters();
if (gFatTestEntries > KMaxFatSize)
gFatTestEntries = KMaxFatSize;
}
static TInt CalcShifts(TInt aSize)
//
// Calculate the number of shifts to get >= aSize (aSize should be a power of 2
// anyway).
//
{
TInt x=0;
while (aSize>>=1)
x++;
return(x);
}
static TInt SectorShifts()
//
// Calculate number of shifts for sector size.
//
{
return(CalcShifts(TheBootSector.BytesPerSector()));
}
static TInt ClusterShifts()
//
// Calculate number of shifts for cluster size.
//
{
return(CalcShifts(TheBootSector.BytesPerSector()*TheBootSector.SectorsPerCluster()));
}
//
// Quick Format the disk
//
static void FormatPack()
{
#if 0
//-- FAT32 SPC:1; for the FAT32 testing on the emulator
TFatFormatParam fp;
fp.iFatType = EFat32;
fp.iSecPerCluster = 1;
FormatFatDrive(TheFs, CurrentDrive(), ETrue, &fp);
#else
FormatFatDrive(TheFs, CurrentDrive(), ETrue);
#endif
DoReadBootSector(TheBootSector);
}
static void TestReadWrite(TInt64 aPos,TInt aLen,TInt anErr)
//
// Read and write to the disk
//
{
TPtr8 buffer((TUint8*)pBuffer1->Ptr(),aLen);
test.Printf(_L("TestReadWrite pos=0x%lx,len=%d\n"),aPos,aLen);
TInt r;
if ((r=TheDisk.Read(aPos,buffer))!=anErr)
{
test.Printf(_L("ERROR: anErr=%d ret=%d\n"),anErr,r);
test(EFalse);
}
buffer.SetLength(aLen);
if ((r=TheDisk.Write(aPos,buffer))!=anErr)
{
test.Printf(_L("ERROR: anErr=%d ret=%d\n"),anErr,r);
test(EFalse);
}
}
static TInt ReadWriteWord(TInt64 aPos,TInt aMask,TInt aValue)
//
// Read 2 bytes from aPos and Write over masked bits with aValue
//
{
TUint16 word;
TPtr8 buffer((TUint8*)&word,sizeof(word));
TInt r=TheDisk.Read(aPos,buffer);
if (r!=KErrNone)
return(r);
word&=((aValue&aMask)|~aMask);
word|=(aValue&aMask);
r=TheDisk.Write(aPos,buffer);
return(r);
}
static TInt ReadWriteDWord(TInt64 aPos,TInt aMask,TInt aValue)
//
// Read 4 bytes from aPos and Write over masked bits with aValue
//
{
TUint32 word;
TPtr8 buffer((TUint8*)&word,sizeof(word));
TInt r=TheDisk.Read(aPos,buffer);
if (r!=KErrNone)
return(r);
word&=((aValue&aMask)|~aMask);
word|=(aValue&aMask);
r=TheDisk.Write(aPos,buffer);
return(r);
}
static void FatWrite(TInt aCluster,TInt aValue)
//
//
//
{
TInt pos=0;
TInt mask=0;
const TUint32 KFirstFatSectorPos = TheBootSector.FirstFatSector() * TheBootSector.BytesPerSector();
switch (gDiskType)
{
case EFat32:
mask=0xffffffff;
pos=KFirstFatSectorPos+(aCluster<<2);
break;
case EFat16:
mask=0xffff;
pos=KFirstFatSectorPos+(aCluster<<1);
break;
case EFat12:
mask=0x0fff;
pos=KFirstFatSectorPos+aCluster+(aCluster>>1);
if (aCluster & 1)
{
mask=0xfff0;
aValue<<=4;
}
break;
default:
test(0);
}
TInt r=TheDisk.Open(TheFs,CurrentDrive());
test_KErrNone(r);
test(ReadWriteDWord(pos,mask,aValue)==KErrNone);
TheDisk.Close();
}
static void TestRwWord(TInt64 aPos,TInt anErr)
//
//
//
{
TInt r;
TUint16 wBuf;
TUint16 rBuf;
TUint16 mask=0;
TUint16 value=0;
test.Printf(_L("Test read and write value to 0x%lx\n"),aPos);
if ((r=ReadWriteWord(aPos,mask,value))!=anErr)
{
test.Printf(_L("ERROR: anErr=%d, ret=%d\n"),anErr,r);
test(EFalse);
}
if (anErr==KErrNone && aPos==0)
{
wBuf=0xff00;
TPtrC8 writebuf((TUint8*)&wBuf,sizeof(wBuf));
test(TheDisk.Write(aPos,writebuf)==KErrNone);
mask=0x0505;
value=0xa4a4;
test.Printf(_L("Test RWW mask=%04x value%04x\n"),mask,value);
if ((r=ReadWriteWord(aPos,mask,value))!=anErr)
{
test.Printf(_L("ERROR: anErr=%d, ret=%d\n"),anErr,r);
test(EFalse);
}
TPtr8 readBuf((TUint8*)&rBuf,sizeof(rBuf));
if ((r=TheDisk.Read(aPos,readBuf))!=KErrNone)
{
test.Printf(_L("ERROR: anErr=%d, ret=%d\n"),anErr,r);
test(EFalse);
}
test(rBuf==0xfe04);
}
if (anErr==KErrNone && aPos==1)
{
wBuf=0xff00;
TPtrC8 writebuf((TUint8*)&wBuf,sizeof(wBuf));
test(TheDisk.Write(aPos,writebuf)==KErrNone);
mask=0xffff;
value=0xa3a3;
test.Printf(_L("Test RWW mask=%04x value%04x\n"),mask,value);
if ((r=ReadWriteWord(aPos,mask,value))!=anErr)
{
test.Printf(_L("ERROR: anErr=%d, ret=%d\n"),anErr,r);
test(EFalse);
}
TPtr8 readBuf((TUint8*)&rBuf,sizeof(rBuf));
if ((r=TheDisk.Read(aPos,readBuf))!=KErrNone)
{
test.Printf(_L("ERROR: anErr=%d, ret=%d\n"),anErr,r);
test(EFalse);
}
test(rBuf==0xa3a3);
}
}
static void TestRwDWord(TInt64 aPos,TInt anErr)
//
//
//
{
TInt r;
TUint32 wBuf;
TUint32 rBuf;
TUint32 mask=0;
TUint32 value=0;
test.Printf(_L("Test read and write value to 0x%lx\n"),aPos);
if ((r=ReadWriteDWord(aPos,mask,value))!=anErr)
{
test.Printf(_L("ERROR: anErr=%d, ret=%d\n"),anErr,r);
test(EFalse);
}
if (anErr==KErrNone && aPos==0)
{
wBuf=0xff00ff00;
TPtrC8 writebuf((TUint8*)&wBuf,sizeof(wBuf));
test(TheDisk.Write(aPos,writebuf)==KErrNone);
mask = 0x0505195c;
value = 0xa4a4c634;
test.Printf(_L("Test RWW mask=%04x value%04x\n"),mask,value);
if ((r=ReadWriteDWord(aPos,mask,value))!=anErr)
{
test.Printf(_L("ERROR: anErr=%d, ret=%d\n"),anErr,r);
test(EFalse);
}
TPtr8 readBuf((TUint8*)&rBuf,sizeof(rBuf));
if ((r=TheDisk.Read(aPos,readBuf))!=KErrNone)
{
test.Printf(_L("ERROR: anErr=%d, ret=%d\n"),anErr,r);
test(EFalse);
}
test(rBuf==0xfe04e614);
}
if (anErr==KErrNone && aPos==1)
{
wBuf=0xff0000ff;
TPtrC8 writebuf((TUint8*)&wBuf,sizeof(wBuf));
test(TheDisk.Write(aPos,writebuf)==KErrNone);
mask=0xffffffff;
value=0xa3a3dead;
test.Printf(_L("Test RWW mask=%04x value%04x\n"),mask,value);
if ((r=ReadWriteDWord(aPos,mask,value))!=anErr)
{
test.Printf(_L("ERROR: anErr=%d, ret=%d\n"),anErr,r);
test(EFalse);
}
TPtr8 readBuf((TUint8*)&rBuf,sizeof(rBuf));
if ((r=TheDisk.Read(aPos,readBuf))!=KErrNone)
{
test.Printf(_L("ERROR: anErr=%d, ret=%d\n"),anErr,r);
test(EFalse);
}
test(rBuf==0xa3a3dead);
}
}
static TInt ThrottleDirEntries(TInt aDirEntries, TInt aRemainder)
{
// throttle the number of entries needed, since for large cluster
// sizes, this can take forever (eg 2GB card -> a cluster size of 32K
// -> 1024 entries per cluster
const TInt KMaxDirEntries = 2048;
test(aRemainder < KMaxDirEntries);
TInt maxDirEntries = KMaxDirEntries - aRemainder;
if (aDirEntries > maxDirEntries)
{
RDebug::Print(_L("Reducing directory entries from %d to %d"), aDirEntries, maxDirEntries);
aDirEntries = maxDirEntries;
}
return aDirEntries;
}
static void TestLoopedSubDir()
//
//
{
test.Printf(_L("Test looped sub-dir\n"));
FormatPack();
TInt r=TheFs.MkDir(_L("\\D\\"));
if (r!=KErrNone && r!=KErrAlreadyExists)
Error(_L("Failed to make directory"),r);
TheFileName=_L("\\D\\");
TInt i=0;
TInt dirEntriesNeeded = ((TheBootSector.BytesPerSector()*TheBootSector.SectorsPerCluster()/KSizeOfFatDirEntry)-2);
dirEntriesNeeded = ThrottleDirEntries(dirEntriesNeeded, 2);
//-- generate some number of VFAT dir. entries by creating 8.3 temp. files in a lower case
for (i=0;i<dirEntriesNeeded;i++)
{
CreateFatEntry(TheFileName, ETrue);
}
test.Printf(_L("Test dir with no match\n"));
FatWrite(gFirstDataCluster,gFirstDataCluster);
if ((r=TheDir.Open(TheFs,_L("\\D\\nomatch"),KEntryAttMaskSupported))!=KErrNone)
Error(_L("Failed Directory open"),r);
if ((r=TheDir.Read(TheEntry))!=KErrCorrupt)
Error(_L("Failed Directory read"),r);
TheDir.Close();
test.Printf(_L("Test dir with match\n"));
if ((r=TheDir.Open(TheFs,_L("\\D\\*.*"),KEntryAttMaskSupported))!=KErrNone)
Error(_L("Failed Directory open"),r);
if ((r=TheDir.Read(TheEntry))!=KErrNone)
Error(_L("Failed Directory read"),r);
TheDir.Close();
test.Printf(_L("Test dir without loop\n"));
FatWrite(gFirstDataCluster,gEndOfChain);
if ((r=TheDir.Open(TheFs,_L("\\D\\nomatch"),KEntryAttMaskSupported))!=KErrNone)
Error(_L("Directory open"),r);
if ((r=TheDir.Read(TheEntry))!=KErrEof)
Error(_L("Reading empty dir returned"),r);
TheDir.Close();
test.Printf(_L("Test dir with long filenames\n"));
FormatPack();
r=TheFs.MkDir(_L("\\D\\"));
if (r!=KErrNone && r!=KErrAlreadyExists)
Error(_L("Failed to make directory"),r);
TheFileName=_L("\\D\\");
dirEntriesNeeded = ((TheBootSector.BytesPerSector()*TheBootSector.SectorsPerCluster()/KSizeOfFatDirEntry)-3);
dirEntriesNeeded = ThrottleDirEntries(dirEntriesNeeded, 3);
//-- generate some number of VFAT dir. entries by creating 8.3 temp. files in a lower case
for (i=0;i<dirEntriesNeeded;i++)
{
CreateFatEntry(TheFileName, ETrue);
}
MakeFile(_L("\\D\\longfileName.Long"));
test.Printf(_L("Test dir with no match\n"));
FatWrite(gFirstDataCluster,gFirstDataCluster);
if ((r=TheDir.Open(TheFs,_L("\\D\\nomatch"),KEntryAttMaskSupported))!=KErrNone)
Error(_L("Failed Directory open"),r);
if ((r=TheDir.Read(TheEntry))!=KErrCorrupt)
Error(_L("Failed Directory read"),r);
TheDir.Close();
test.Printf(_L("Test dir with match\n"));
if ((r=TheDir.Open(TheFs,_L("\\D\\*.*"),KEntryAttMaskSupported))!=KErrNone)
Error(_L("Failed Directory open"),r);
if ((r=TheDir.Read(TheEntry))!=KErrNone)
Error(_L("Failed Directory read"),r);
TheDir.Close();
test.Printf(_L("Test dir without loop\n"));
FatWrite(gFirstDataCluster,gEndOfChain);
if ((r=TheDir.Open(TheFs,_L("\\D\\nomatch"),KEntryAttMaskSupported))!=KErrNone)
Error(_L("Directory open"),r);
#if !defined _UNICODE
if ((r=TheDir.Read(TheEntry))!=KErrCorrupt)
Error(_L("Reading empty dir returned"),r);
#endif
TheDir.Close();
}
static void TestLoopedFile()
//
// Test Looped file
//
{
test.Printf(_L("Test looped file\n"));
FormatPack();
TInt r;
test.Next(_L("CreateFile"));
test(TheFile.Replace(TheFs,_L("\\LOOPED1.TMP"),EFileRead|EFileWrite)==KErrNone);
TPtr8 buf=pBuffer1->Des();
test(TheFile.Write(buf,TheBootSector.BytesPerSector()-1)==KErrNone);
TheFile.Close();
test.Next(_L("Write 1 cluster loop"));
FatWrite(gFirstDataCluster,gFirstDataCluster); /* tiny loop */
if ((r=TheFile.Open(TheFs,_L("\\LOOPED1.TMP"),EFileRead|EFileWrite))!=KErrCorrupt)
Error(_L("Error opening corrupt file"),r);
FatWrite(gFirstDataCluster,0);
if ((r=TheFile.Open(TheFs,_L("\\LOOPED1.TMP"),EFileRead|EFileWrite))!=KErrCorrupt)
Error(_L("Error opening corrupt file"),r);
FatWrite(gFirstDataCluster,gEndOfChain);
if ((r=TheFile.Open(TheFs,_L("\\LOOPED1.TMP"),EFileRead|EFileWrite))!=KErrNone)
Error(_L("Error opening file"),r);
if ((r=TheFile.Write(buf,TheBootSector.BytesPerSector()*TheBootSector.SectorsPerCluster()*2-1))!=0)
Error(_L("Error writing to file"),r);
TheFile.Close();
test.Next(_L("Write 2 cluster loop"));
FatWrite(gFirstDataCluster+1,gFirstDataCluster); /* 2 cluster loop */
if ((r=TheFile.Open(TheFs,_L("\\LOOPED1.TMP"),EFileRead|EFileWrite))!=KErrCorrupt)
Error(_L("Error opening corrupt file"),r);
FatWrite(gFirstDataCluster+1,gEndOfChain);
if ((r=TheFile.Open(TheFs,_L("\\LOOPED1.TMP"),EFileRead|EFileWrite))!=KErrNone)
Error(_L("Error opening file"),r);
TInt len=16384;
TInt size=0L;
while (size < gBytesPerCluster * 500)
{
test.Printf(_L("\rWriting %d "),size);
if ((r=TheFile.Write(buf,len))!=KErrNone)
{
if (r!=KErrDiskFull)
Error(_L("File write error"),r);
len>>=1;
if (len==0)
break;
}
else
size+=len;
}
test.Printf(_L("\n"));
TheFile.Close();
RDebug::Print(_L("File created size %d"), size);
TInt clust=((size-1)>>ClusterShifts())+gFirstDataCluster;
FatWrite(clust,gFirstDataCluster);
if ((r=TheFile.Open(TheFs,_L("\\LOOPED1.TMP"),EFileRead|EFileWrite))!=KErrCorrupt)
Error(_L("Error opening corrupt file"),r);
FatWrite(clust,gEndOfChain);
if ((r=TheFs.Delete(_L("\\LOOPED1.TMP")))!=KErrNone)
Error(_L("Error deleting file"),r);
RDebug::Print(_L("File removed"));
r=TheFs.CheckDisk(gSessionPath);
test_KErrNone(r);
}
static void TestFatEntry(TUint16 aFileSize,TInt aCorruptFatCluster)
//
// Test fat entry
//
{
TInt r;
test.Printf(_L("File size=%d, cluster value=0x%x\n"),aFileSize,aCorruptFatCluster);
FormatPack();
r=TheFile.Replace(TheFs,_L("\\CORRUPT2.TMP"),EFileRead|EFileWrite);
test_KErrNone(r);
TheBuffer.SetLength(aFileSize);
Mem::Fill(&TheBuffer[0],aFileSize,'A');
r=TheFile.Write(TheBuffer);
test_KErrNone(r);
TheFile.Close();
FatWrite(gFirstDataCluster,aCorruptFatCluster);
TInt pos=0;
r=TheFile.Open(TheFs,_L("\\CORRUPT2.TMP"),EFileRead|EFileWrite);
test_Value(r, r == KErrNone || r==KErrCorrupt);
if (r==KErrNone)
{
r=TheFile.Seek(ESeekStart,pos);
test_KErrNone(r);
r=TheFile.Write(TheBuffer);
if ((gDriveCacheFlags & EFileCacheWriteOn) && (r == KErrNone))
r = TheFile.Flush();
if (r != KErrCorrupt)
{
test.Printf(_L("Predicted error %d Actual error %d\n"),KErrCorrupt,r);
Error(_L("Failed write"),r);
}
TheFile.Close();
}
FatWrite(gFirstDataCluster,gEndOfChain);
pos=0;
r=TheFile.Open(TheFs,_L("\\CORRUPT2.TMP"),EFileRead|EFileWrite);
test_KErrNone(r);
r=TheFile.Seek(ESeekStart,pos);
test_KErrNone(r);
r=TheFile.Write(TheBuffer);
if ((gDriveCacheFlags & EFileCacheWriteOn) && (r == KErrNone))
r = TheFile.Flush();
// if the file size <= cluster size then writing last cluster marker to
// cluster 2 should have no effect
if(aFileSize>TheBootSector.SectorsPerCluster()<<SectorShifts())
{
if (r!=KErrCorrupt)
{
test.Printf(_L("Predicted error %d Actual error %d\n"),KErrCorrupt,r);
Error(_L("Failed write"),r);
}
}
else
{
if (r!=KErrNone)
{
test.Printf(_L("Predicted error %d Actual error %d\n"),KErrNone,r);
Error(_L("Failed write"),r);
}
}
TheFile.Close();
}
static void TestDirEntry(TInt anInitialSize,TInt aWriteLen,TInt aCorruptStartCluster)
//
// Test directory entry
//
{
test.Printf(_L("Initial size=%d, len=%d, start cluster=0x%x\n"),anInitialSize,aWriteLen,aCorruptStartCluster);
FormatPack();
TInt r;
test(TheFile.Create(TheFs,_L("\\CORRUPT1.TMP"),EFileRead|EFileWrite)==KErrNone);
TheBuffer.SetLength(anInitialSize);
Mem::Fill(&TheBuffer[0],anInitialSize,'A');
r=TheFile.Write(TheBuffer);
test_KErrNone(r);
TheFile.Close();
r=TheDisk.Open(TheFs,CurrentDrive());
test_KErrNone(r);
TPtr8 sectorBuf((TUint8*)pBuffer1->Ptr(),TheBootSector.BytesPerSector());
TInt pos = gRootDirStart;
r=TheDisk.Read(pos,sectorBuf);
test_KErrNone(r);
TFatDirEntry* pE=(TFatDirEntry*)pBuffer1->Ptr();
while (pE->IsVFatEntry()) // UNICODE entries are VFat by definition
pE++;
pE->SetStartCluster(aCorruptStartCluster);
test(TheDisk.Write(pos,sectorBuf)==KErrNone);
//-- a small hack to avoid problems with the fact that FAT[1] entry
//-- is now used for marking volume as clean. TheDisk.Close() cause volume remout and
//-- the data
TheDisk.Close();
r=TheDisk.Open(TheFs,CurrentDrive());
test_KErrNone(r);
pos=0;
TPtr8 buffer1(pBuffer1->Des());
r=TheDisk.Read(pos,buffer1);
test_KErrNone(r);
TheDisk.Close();
r=TheFs.Entry(_L("\\CORRUPT1.TMP"),TheEntry);
test_Value(r, r == KErrNone || r==KErrCorrupt);
TTime saveTime=TheEntry.iModified;
if (r!=KErrNone)
saveTime.HomeTime();
r=TheFile.Open(TheFs,_L("\\CORRUPT1.TMP"),EFileRead|EFileWrite);
if (r==KErrNone)
{
TheBuffer.SetLength(aWriteLen);
Mem::Fill(&TheBuffer[0],aWriteLen,'B');
if ((r=TheFile.Write(TheBuffer))!=KErrCorrupt)
{
test.Printf(_L("Predicted error %d Actual error %d\n"),KErrCorrupt,r);
Error(_L("Failed write"),r);
}
TheFile.Close();
}
r=TheDisk.Open(TheFs,CurrentDrive());
test_KErrNone(r);
pos=0;
TPtr8 buffer2(pBuffer2->Des());
r=TheDisk.Read(pos,buffer2);
test_KErrNone(r);
//-- this bit is dodgy. The buffers may differ because of volume finalisation stuff
//-- FAT[1] and FSInfo sectors
test(buffer1==buffer2);
TheDisk.Close();
r=TheFs.SetModified(_L("\\CORRUPT1.TMP"),saveTime);
test_Value(r, r == KErrNone || r==KErrCorrupt);
r=TheFs.Entry(_L("\\CORRUPT1.TMP"),TheEntry);
test_Value(r, r == KErrNone || r==KErrCorrupt);
}
static void TestBounds()
//
// Test reading/writing past the end of a drive
//
{
test.Next(_L("Test read/write past boundaries"));
test(TheFs.Volume(TheVolumeInfo,CurrentDrive())==KErrNone);
TInt64 size=TheVolumeInfo.iSize;
TInt r=TheDisk.Open(TheFs,CurrentDrive());
test_KErrNone(r);
TPtr8 buffer(pBuffer1->Des());
TInt64 pos=size - 2*buffer.MaxLength();
TInt inc=buffer.MaxLength();
FOREVER
{
TPtr8 tempbuf((TUint8*)pBuffer1->Ptr(),inc);
r=TheDisk.Read(pos,tempbuf);
test.Printf(_L("Read %08X:%08X len %d r %d\r"), I64HIGH(pos),I64LOW(pos), inc, r);
test_Value(r, r == KErrNone || r==KErrCorrupt);
if (r==KErrNone)
pos+=inc;
else
{
inc>>=1;
if (inc==0)
break;
}
test(pos<2*size);
}
TInt64 maxcalc= TInt64(gTotalSectors) * TInt64(TheBootSector.BytesPerSector());
test.Printf(_L("\n"));
test.Printf(_L("Volume size = %ld\n"), size);
test.Printf(_L("RawDiskSize = %ld\n"), maxcalc);
test.Printf(_L("MaxReadPos = %ld\n"), pos);
TInt64 maxpos = pos;
// check that the calculated raw size of the disk is equal to the MaxReadPos that
// has just been discovered by trial and error
test(maxcalc == maxpos);
for (TInt64 bsize = 1; bsize < 8; bsize++)
{
test.Printf(_L("\n"));
test.Printf(_L("Buffer size %d\n"), bsize);
for (TInt64 bpos = MAKE_TINT64(0, 0x1000); bpos < MAKE_TINT64(0x3FFFFFFF,0); bpos<<=1)
{
TInt64 endPos = (bpos + 1);
for (TInt64 lpos = bpos - bsize; lpos <= endPos; lpos++)
{
TPtr8 temp((TUint8*) (pBuffer1->Ptr()), (TInt) bsize);
TInt expect = (lpos+bsize-1 < maxpos ? KErrNone : KErrCorrupt);
r=TheDisk.Read(lpos, temp);
RDebug::Print(_L("Read %08X:%08X result %d \r"), I64HIGH(lpos), I64LOW(lpos), r);
test_Value(r, r == expect);
}
}
}
RDebug::Print(_L("\n"));
TestReadWrite(0L,0,0);
TestReadWrite(0L,1,0);
TestReadWrite(pos-1,1,0);
TestReadWrite(pos-0x100,0x100,0);
TestReadWrite(pos-1,2,KErrCorrupt);
TestReadWrite(pos-0x100,0x101,KErrCorrupt);
TestReadWrite(pos-0xff,0x100,KErrCorrupt);
TestReadWrite(pos,0,0);
TestReadWrite(pos,1,KErrCorrupt);
TestReadWrite(pos-16384,16384,0);
TestReadWrite(pos-16384,16385,KErrCorrupt);
TInt errVal=(pos>32768+0x100) ? KErrNone : KErrCorrupt;
TestReadWrite(32768L,0x100,errVal);
errVal=(pos>32768+0x101) ? KErrNone : KErrCorrupt;
TestReadWrite(32768L,0x101,errVal);
errVal=(pos>32768+0x1ff) ? KErrNone : KErrCorrupt;
TestReadWrite(32768L,0xff,errVal);
errVal=(pos>65000+0x100) ? KErrNone : KErrCorrupt;
TestReadWrite(65000L,0x100,errVal);
errVal=(pos>0x2000000+1) ? KErrNone : KErrCorrupt;
TestReadWrite(0x2000000L,1,errVal);
TestRwWord(0L,0);
TestRwWord(1L,0);
TestRwWord(pos-2,0);
TestRwWord(pos-1,KErrCorrupt);
TestRwWord(pos,KErrCorrupt);
TestRwWord(pos+1,KErrCorrupt);
TestRwDWord(0L,0);
TestRwDWord(1L,0);
TestRwDWord(2L,0);
TestRwDWord(3L,0);
TestRwDWord(pos-4,0);
TestRwDWord(pos-3,KErrCorrupt);
TestRwDWord(pos-2,KErrCorrupt);
TestRwDWord(pos-1,KErrCorrupt);
TestRwDWord(pos,KErrCorrupt);
TestRwDWord(pos+1,KErrCorrupt);
TheDisk.Close();
}
static void TestClusters()
{
test.Next(_L("Test corrupt start cluster"));
// Initial Write Corrupt
// Size Len Cluster
TestDirEntry(1024, 513, 0);
TestDirEntry( 512, 512, 0);
TestDirEntry(1024, 513, 1);
TestDirEntry( 512, 512, 1);
TestDirEntry(1024, 513, 0xff0);
test.Printf(_L("Test corrupt chain\n"));
TestFatEntry(1536,0);
TestFatEntry(1536,1);
// TInt fatCacheSize=FatCacheSize();
// TUint16 cluster16=(TUint16)(fatCacheSize/2);
// TUint16 cluster12=(TUint16)((fatCacheSize/3)*2);
// TestFatEntry(1536,cluster12);
// TestFatEntry(1536,cluster16);
TestFatEntry(1536,0xff0);
// don't test when only one cluster for the file
if(1536>gBytesPerCluster)
TestFatEntry(1536,gEndOfChain);
TestLoopedFile();
TestLoopedSubDir();
}
static void TestClusterAllocation()
//
// Test number of clusters allocated
//
{
test.Next(_L("Test number of clusters allocated is correct"));
FormatPack();
RFile f;
TInt r;
r=f.Replace(TheFs,_L("\\GOBLIN.TMP"),EFileRead|EFileWrite);
test_KErrNone(r);
f.SetSize(4*gBytesPerCluster); // 4 Clusters
f.Close();
r=f.Replace(TheFs,_L("\\WIZARD.TMP"),EFileRead|EFileWrite);
test_KErrNone(r);
f.SetSize(5*gBytesPerCluster); // 5 Clusters
f.Close();
r=f.Replace(TheFs,_L("\\TROLL.TMP"),EFileRead|EFileWrite);
test_KErrNone(r);
f.SetSize(3*gBytesPerCluster); // 3 Clusters
f.Close();
r=f.Replace(TheFs,_L("\\GNOME.TMP"),EFileRead|EFileWrite);
test_KErrNone(r);
f.SetSize(10*gBytesPerCluster); // 10 Clusters
f.Close();
r=f.Replace(TheFs,_L("\\CYCLOPS.TMP"),EFileRead|EFileWrite);
test_KErrNone(r);
f.SetSize(gBytesPerCluster); // 1 Cluster
f.Close();
r=f.Replace(TheFs,_L("\\PIXIE.TMP"),EFileRead|EFileWrite);
test_KErrNone(r);
f.SetSize(gBytesPerCluster); // 1 Cluster
f.Close();
r=TheDisk.Open(TheFs,CurrentDrive());
test_KErrNone(r);
TPtr8 sectorBuf((TUint8*)pBuffer1->Ptr(),TheBootSector.BytesPerSector());
TInt pos = gRootDirStart;
test(TheDisk.Read(pos,sectorBuf)==KErrNone);
TheDisk.Close();
TFatDirEntry* pE=(TFatDirEntry*)pBuffer1->Ptr();
while (pE->IsVFatEntry()) // UNICODE 8.3 filenames are VFAT by definition
pE++;
TInt cluster=pE->StartCluster();
TBuf8<15> name=pE->Name();
test(name==_L8("GOBLIN TMP"));
pE++;
while (pE->IsVFatEntry())
pE++;
test((pE->StartCluster()-cluster)==4);
cluster=pE->StartCluster();
name=pE->Name();
test(name==_L8("WIZARD TMP"));
pE++;
while (pE->IsVFatEntry())
pE++;
test((pE->StartCluster()-cluster)==5);
cluster=pE->StartCluster();
name=pE->Name();
test(name==_L8("TROLL TMP"));
pE++;
while (pE->IsVFatEntry())
pE++;
test((pE->StartCluster()-cluster)==3);
cluster=pE->StartCluster();
name=pE->Name();
test(name==_L8("GNOME TMP"));
pE++;
while (pE->IsVFatEntry())
pE++;
test ((pE->StartCluster()-cluster)==10);
cluster=pE->StartCluster();
name=pE->Name();
test(name==_L8("CYCLOPS TMP"));
pE++;
while (pE->IsVFatEntry())
pE++;
test((pE->StartCluster()-cluster)==1);
name=pE->Name();
test(name==_L8("PIXIE TMP"));
r=TheFs.Delete(_L("\\GOBLIN.TMP"));
test_KErrNone(r);
r=TheFs.Delete(_L("\\WIZARD.TMP"));
test_KErrNone(r);
r=TheFs.Delete(_L("\\TROLL.TMP"));
test_KErrNone(r);
r=TheFs.Delete(_L("\\GNOME.TMP"));
test_KErrNone(r);
r=TheFs.Delete(_L("\\CYCLOPS.TMP"));
test_KErrNone(r);
r=TheFs.Delete(_L("\\PIXIE.TMP"));
test_KErrNone(r);
FormatPack();
}
static void TestMakeDir(const TDesC& aName, TUint aNewClust, TUint aParentClust)
//
// Test make dir
//
{
test.Printf(_L("Checking cluster %02d, parent %d: \"%S\"\n"), aNewClust, aParentClust, &aName);
TInt r=TheFs.MkDir(aName);
test_Value(r, r == KErrNone || r==KErrAlreadyExists);
TInt pos=ClusterToByte(aNewClust);
TPtr8 sectorBuf((TUint8*)pBuffer1->Ptr(),gBytesPerCluster);
r=TheDisk.Open(TheFs,CurrentDrive());
if ((r=TheDisk.Read(pos,sectorBuf))!=KErrNone)
Error(_L("Reading data"),r);
TheDisk.Close();
TFatDirEntry* pE=(TFatDirEntry*)pBuffer1->Ptr();
if (pE->Name()[0]!='.' || pE->Name()[1]!=' ')
{
while (pE->IsVFatEntry())
pE++;
if (pE->Name()[0]!='.' || pE->Name()[1]!=' ')
Error(_L("Failed to find '.' entry"),KErrNone);
}
if (pE->StartCluster()!=aNewClust)
Error(_L("Bad directory start cluster"),KErrNone);
pE++;
if (pE->Name()[0]!='.' || pE->Name()[1]!='.')
Error(_L("Second entry is not '..'"),KErrNone);
if (pE->StartCluster() != ((aParentClust==(TUint)gRootCluster)?0:aParentClust))
Error(_L("Start cluster of .. is not parent directory"),KErrNone);
}
static void TestParentDir(TBool aUseVfat)
{
test.Next(_L("TestParentDir()"));
TInt root = gRootCluster;
TInt cl = gFirstDataCluster;
TInt p1 = cl;
FormatPack();
TestMakeDir(_L("\\P1\\"), cl++, root);
const TInt nDirEntries= gBytesPerCluster / KSizeOfFatDirEntry; //-- number of dir. entries to fill 1 cluster
const TInt nFiles = aUseVfat ? nDirEntries/2 : nDirEntries; //-- number of 8.3 files to fill 1 cluster
cl++;
for (TInt i=0;i<nFiles;i++)
{
CreateFatEntry(_L("\\P1\\"), aUseVfat);
}
TInt p1p2 = cl;
if(aUseVfat)
{
TestMakeDir(_L("\\p1\\p2\\"), cl++, p1);
TestMakeDir(_L("\\p1\\p21\\"), cl++, p1);
TestMakeDir(_L("\\p1\\p2\\p3\\"), cl++, p1p2);
TestMakeDir(_L("\\p1\\p2\\p33\\"), cl++, p1p2);
TestMakeDir(_L("\\p1\\p2\\p34\\"), cl++, p1p2);
TestMakeDir(_L("\\p1\\p2\\p35\\"), cl++, p1p2);
TestMakeDir(_L("\\p1\\p2\\p36\\"), cl++, p1p2);
TestMakeDir(_L("\\p1\\p2\\p37\\"), cl++, p1p2);
TestMakeDir(_L("\\p1\\p2\\p38\\"), cl++, p1p2);
}
else
{
TestMakeDir(_L("\\P1\\P2\\"), cl++, p1);
TestMakeDir(_L("\\P1\\P21\\"), cl++, p1);
TestMakeDir(_L("\\P1\\P2\\P3\\"), cl++, p1p2);
TestMakeDir(_L("\\P1\\P2\\P33\\"), cl++, p1p2);
TestMakeDir(_L("\\P1\\P2\\P34\\"), cl++, p1p2);
TestMakeDir(_L("\\P1\\P2\\P35\\"), cl++, p1p2);
TestMakeDir(_L("\\P1\\P2\\P36\\"), cl++, p1p2);
TestMakeDir(_L("\\P1\\P2\\P37\\"), cl++, p1p2);
TestMakeDir(_L("\\P1\\P2\\P38\\"), cl++, p1p2);
TestMakeDir(_L("\\P1\\P2\\P39\\"), cl++, p1p2);
TestMakeDir(_L("\\P1\\P2\\P40\\"), cl++, p1p2);
TestMakeDir(_L("\\P1\\P2\\P41\\"), cl++, p1p2);
TestMakeDir(_L("\\P1\\P2\\P42\\"), cl++, p1p2);
TestMakeDir(_L("\\P1\\P2\\P43\\"), cl++, p1p2);
TestMakeDir(_L("\\P1\\P2\\P44\\"), cl++, p1p2);
TestMakeDir(_L("\\P1\\P2\\P45\\"), cl++, p1p2);
}
// if sectors/cluster == 1 then the directory \p1\p2\ will now have to
// allocate another cluster
if(TheBootSector.SectorsPerCluster()==1)
++cl;
if(aUseVfat)
{
TestMakeDir(_L("\\p1\\p2\\p310\\"), cl++, p1p2);
TestMakeDir(_L("\\p1\\p2\\p311\\"), cl++, p1p2);
TestMakeDir(_L("\\p1\\p2\\p312\\"), cl++, p1p2);
TestMakeDir(_L("\\p1\\p2\\p313\\"), cl++, p1p2);
TestMakeDir(_L("\\p1\\p2\\p314\\"), cl++, p1p2);
TestMakeDir(_L("\\p1\\p2\\p315\\"), cl++, p1p2);
TestMakeDir(_L("\\p1\\p2\\p316\\"), cl++, p1p2);
TestMakeDir(_L("\\p1\\p2\\p317\\"), cl++, p1p2);
}
else
{
TestMakeDir(_L("\\P1\\P2\\P310\\"), cl++, p1p2);
TestMakeDir(_L("\\P1\\P2\\P311\\"), cl++, p1p2);
TestMakeDir(_L("\\P1\\P2\\P312\\"), cl++, p1p2);
TestMakeDir(_L("\\P1\\P2\\P313\\"), cl++, p1p2);
TestMakeDir(_L("\\P1\\P2\\P314\\"), cl++, p1p2);
TestMakeDir(_L("\\P1\\P2\\P315\\"), cl++, p1p2);
TestMakeDir(_L("\\P1\\P2\\P316\\"), cl++, p1p2);
TestMakeDir(_L("\\P1\\P2\\P317\\"), cl++, p1p2);
TestMakeDir(_L("\\P1\\P2\\P318\\"), cl++, p1p2);
TestMakeDir(_L("\\P1\\P2\\P319\\"), cl++, p1p2);
TestMakeDir(_L("\\P1\\P2\\P320\\"), cl++, p1p2);
TestMakeDir(_L("\\P1\\P2\\P321\\"), cl++, p1p2);
TestMakeDir(_L("\\P1\\P2\\P322\\"), cl++, p1p2);
TestMakeDir(_L("\\P1\\P2\\P323\\"), cl++, p1p2);
TestMakeDir(_L("\\P1\\P2\\P324\\"), cl++, p1p2);
TestMakeDir(_L("\\P1\\P2\\P325\\"), cl++, p1p2);
}
// if sectors/cluster <= 2 then the directory \p1\p2\ will have to
// allocate another cluster
if(TheBootSector.SectorsPerCluster()<=2)
++cl;
TestMakeDir(_L("\\P1\\P2\\P330\\"), cl++, p1p2);
TestMakeDir(_L("\\P11\\"), cl++, root);
}
static const TInt KMaxFiles=5;
//
// Test root dir size
//
static void TestRoot()
{
test.Next(_L("Test root dir size"));
if (gDiskType == EFat32)
{
test.Printf(_L("Not possible on FAT32 filesystem\n"));
return;
}
FormatPack();
TInt rootEntries=TheBootSector.RootDirEntries();
test.Printf(_L("Total root entries allowed = %d\n"),rootEntries);
TFileName fileName[KMaxFiles]; // KMaxFiles=5 in this test
TFileName tempName;
TInt numberOfEntries=rootEntries;
TInt r;
RFile f;
//-- generate 8.3 FAT entries, temp files created in upper-case, otherwise it will be 2 vFAT entries
while(numberOfEntries--)
{
if (numberOfEntries<KMaxFiles)
CreateFatEntry(_L("\\"), EFalse, &fileName[numberOfEntries]);
else
CreateFatEntry(_L("\\"), EFalse);
}
r = f.Create(TheFs, _L("\\123456.78"), EFileRead|EFileWrite);
test_Value(r, r == KErrDirFull);
f.Close();
TInt i=0;
for (i=0;i<KMaxFiles;i++)
{
r=TheFs.Delete(fileName[i]);
test_KErrNone(r);
}
r=TheFs.SetSessionPath(_L("\\"));
test_KErrNone(r);
TInt nameLength=(KMaxFiles-1)*13; // -1 for zero terminator
CreateLongName(tempName,gSeed,nameLength*2);
r=f.Create(TheFs,tempName,0); // Needs 9 free entries - there are only 5 available
test_Value(r, r == KErrDirFull);
tempName.SetLength(nameLength+1);
r=f.Create(TheFs,tempName,0); // Needs 6 free entries - there are only 5 available
test_Value(r, r == KErrDirFull);
tempName.SetLength(nameLength);
r=f.Create(TheFs,tempName,0); // Needs 5 free entries - there are 5 available
test_KErrNone(r);
f.Close();
#if 0 // This is the old test that assumed UNICODE builds
// which created VFAT entries even for uppercase 8.3 file names
TInt i=0;
for (i=0;i<KMaxFiles-2;i++)
{
r=TheFs.Delete(fileName[i]); // UNICODE build - free 6 entries (delete 3 files)
test_KErrNone(r);
}
r=TheFs.SetSessionPath(_L("\\"));
test_KErrNone(r);
TInt vFatUnitNameSize=13;
TInt nameLength=(KMaxFiles-1)*vFatUnitNameSize-1; //
CreateLongName(tempName,gSeed,nameLength*2);
r=f.Create(TheFs,tempName,0); // Needs 9 free entries
test_Value(r, r == KErrDirFull);
nameLength=(KMaxFiles)*vFatUnitNameSize;
tempName.SetLength(nameLength+1);
r=f.Create(TheFs,tempName,0); // Needs 7 free entries
test_Value(r, r == KErrDirFull);
tempName.SetLength(nameLength);
r=f.Create(TheFs,tempName,0); // Needs 6 free entries
test_KErrNone(r);
f.Close();
#endif
TheFs.Delete(tempName);
tempName.SetLength(nameLength-7);
r=f.Create(TheFs,tempName,0);
test_KErrNone(r);
f.Close();
r=f.Create(TheFs,_L("ASDF"),0);
test_Value(r, r == KErrDirFull);
TheFs.Delete(tempName);
tempName.SetLength(nameLength-15);
r=f.Create(TheFs,tempName,0);
test_KErrNone(r);
f.Close();
tempName=_L("testname");
r=f.Create(TheFs,tempName,0);
test_Value(r, r == KErrDirFull);
tempName.UpperCase();
r=f.Create(TheFs,tempName,0);
test_KErrNone(r);
f.Close();
r=TheFs.SetSessionPath(gSessionPath);
test_KErrNone(r);
}
static void TestVolumeSize()
//
// Test the volume size is zero when empty
//
{
test.Next(_L("Test the volume size"));
FormatPack();
TVolumeInfo volInfo;
TInt r=TheFs.Volume(volInfo);
test_KErrNone(r);
TInt64 calcsize = MAKE_TINT64(0, gClusterCount)*gBytesPerCluster;
if (volInfo.iSize > calcsize)
{
test.Printf(_L("volInfo.iSize = %ld\n"), volInfo.iSize);
test.Printf(_L("volInfo.iFree = %ld\n"), volInfo.iFree);
test.Printf(_L("calculated = %ld\n"), calcsize);
TInt diff = I64LOW(volInfo.iSize-calcsize);
test.Printf(_L("difference = %d (%d clusters)\n"), diff, diff/gBytesPerCluster);
test(0);
}
if (gDiskType == EFat32)
volInfo.iSize -= gBytesPerCluster; // root dir is part of the 'size'
if (volInfo.iSize != volInfo.iFree)
{
test.Printf(_L("volInfo.iSize = %ld\n"), volInfo.iSize);
test.Printf(_L("volInfo.iFree = %ld\n"), volInfo.iFree);
TInt diff = I64LOW(volInfo.iSize-volInfo.iFree);
test.Printf(_L("difference = %d (%d clusters)\n"), diff, diff/gBytesPerCluster);
DumpData();
DumpFat();
test(0);
}
RFile f[KMaxFiles];
TFileName fileName;
TInt i=0;
for (i=0;i<KMaxFiles;i++)
{
fileName=_L("\\File");
fileName.AppendNum(i);
r=f[i].Create(TheFs,fileName,0);
test_KErrNone(r);
}
TInt maxTotalSize=1048576;
TInt maxFileSize=maxTotalSize/KMaxFiles;
TInt maxIterations=20;
while(maxIterations--)
{
for (i=0;i<KMaxFiles;i++)
{
TInt randSize=Math::Rand(gSeed)%maxFileSize;
r=f[i].SetSize(randSize);
test_KErrNone(r);
}
test.Printf(_L("Countdown .. %d \r"),maxIterations);
}
test.Printf(_L("\n"));
TInt totalSize=0;
for (i=0;i<KMaxFiles;i++)
{
TInt size=0;
r=f[i].Size(size);
test_KErrNone(r);
totalSize+=((size+gBytesPerCluster-1)/gBytesPerCluster)*gBytesPerCluster;
}
r=TheFs.Volume(volInfo);
test_KErrNone(r);
if (gDiskType == EFat32)
volInfo.iSize -= gBytesPerCluster; // root dir is part of the 'size'
if (volInfo.iSize-volInfo.iFree!=totalSize)
{
test.Printf(_L("volInfo.iSize = %ld\n"), volInfo.iSize);
test.Printf(_L("volInfo.iFree = %ld\n"), volInfo.iFree);
test.Printf(_L("totalSize = %ld\n"), totalSize);
TInt diff = I64LOW(volInfo.iSize-volInfo.iFree) - totalSize;
test.Printf(_L("difference = %d (%d clusters)\n"), diff, diff/gBytesPerCluster);
}
test(volInfo.iSize-volInfo.iFree==totalSize);
for (i=0;i<KMaxFiles;i++)
f[i].Close();
for (i=0;i<KMaxFiles;i++)
{
fileName=_L("\\File");
fileName.AppendNum(i);
r=TheFs.Delete(fileName);
test_KErrNone(r);
}
r=TheFs.Volume(volInfo);
if (gDiskType == EFat32)
volInfo.iSize -= gBytesPerCluster; // root dir is part of the 'size'
test_KErrNone(r);
test(volInfo.iSize-volInfo.iFree==0);
MakeDir(gSessionPath);
TInt entries=(gBytesPerCluster/KSizeOfFatDirEntry)*5-2;
entries = ThrottleDirEntries(entries, 2);
TInt clusters = ((entries * KSizeOfFatDirEntry) + gBytesPerCluster-1) / gBytesPerCluster;
//-- create "entries" FAT dir. entries by creating 8.3 files in upper case
while(entries--)
{
CreateFatEntry(gSessionPath, EFalse);
}
r=TheFs.Volume(volInfo);
test_KErrNone(r);
if (gDiskType == EFat32)
volInfo.iSize -= gBytesPerCluster; // root dir is part of the 'size'
test.Printf(_L("volInfo.iSize = %ld\n"), volInfo.iSize);
test.Printf(_L("volInfo.iFree = %ld\n"), volInfo.iFree);
if (volInfo.iSize-volInfo.iFree!=clusters*gBytesPerCluster)
{
DumpFat();
DumpData(1, 200);
}
test(volInfo.iSize-volInfo.iFree==clusters*gBytesPerCluster);
//-- create 1 FAT dir. entry
CreateFatEntry(gSessionPath, EFalse);
r=TheFs.Volume(volInfo);
test_KErrNone(r);
if (gDiskType == EFat32)
volInfo.iSize -= gBytesPerCluster; // root dir is part of the 'size'
test.Printf(_L("volInfo.iSize = %ld\n"), volInfo.iSize);
test.Printf(_L("volInfo.iFree = %ld\n"), volInfo.iFree);
if (volInfo.iSize-volInfo.iFree!=(clusters+1)*gBytesPerCluster)
{
DumpFat();
DumpData(1, 200);
}
test(volInfo.iSize-volInfo.iFree==(clusters+1)*gBytesPerCluster);
CFileMan* fMan=CFileMan::NewL(TheFs);
r=fMan->RmDir(gSessionPath);
test_KErrNone(r);
delete fMan;
r=TheFs.Volume(volInfo);
test_KErrNone(r);
if (gDiskType == EFat32)
volInfo.iSize -= gBytesPerCluster; // root dir is part of the 'size'
if (volInfo.iSize-volInfo.iFree!=0)
{
DumpFat();
DumpData(1, 200);
}
test(volInfo.iSize-volInfo.iFree==0);
}
//
// Writes a standard dos entry to the disk and checks that this can be read
// (in Unicode build)
//
static void TestUnicodeEntry()
{
test.Next(_L("Test Unicode entry"));
const TInt KDirEntrySize=32;
FormatPack();
DoReadBootSector(TheBootSector);
TInt pos=gRootDirStart;
TBuf8<KDirEntrySize> buffer;
buffer.SetLength(KDirEntrySize);
buffer.FillZ();
buffer.Replace(0,11,_L8("TEST1 "));
TInt r=TheDisk.Open(TheFs,CurrentDrive());
test_KErrNone(r);
r=TheDisk.Write(pos,buffer);
test_KErrNone(r);
TheDisk.Close();
r=TheDir.Open(TheFs,_L("\\"),KEntryAttMaskSupported);
test_KErrNone(r);
r=TheDir.Read(TheEntry);
test_KErrNone(r);
test(TheEntry.iName==_L("TEST1"));
r=TheDir.Read(TheEntry);
test_Value(r, r == KErrEof);
TheDir.Close();
r=TheFs.SetSessionPath(_L("\\"));
test_KErrNone(r);
TEntry e;
r=TheFs.Entry(_L("TEST1"),e);
if(e.iName!=_L("TEST1"))
{
test.Printf(_L("e.iName = %S\n"),&e.iName);
test(EFalse);
}
}
static TUint32 GetValue(const TPtrC8& aData, TInt aOffset, TInt aLength)
{
TUint32 val = 0;
while (aLength-- > 0)
val = val * 256 + aData[aOffset+aLength];
return val;
}
static void TestDiskIntegrity(TBool aTestOnly=EFalse)
//
// Does 'sanity checking' on the BPB and other areas
//
{
if (!aTestOnly)
test.Next(_L("Test disk boot area integrity"));
TInt seclen = TheBootSector.BytesPerSector();
HBufC8 *bootp = HBufC8::NewL(seclen);
TPtr8 boot((TUint8*)bootp, seclen);
HBufC8 *backp = HBufC8::NewL(seclen);
TPtr8 back((TUint8*)backp, seclen);
HBufC8 *infop = HBufC8::NewL(seclen);
TPtr8 info((TUint8*)bootp, seclen);
TInt r=TheDisk.Open(TheFs,CurrentDrive());
if (r != KErrNone)
test.Printf(_L("Error %d opening on %C"), r, (TUint)gDriveToTest);
test_KErrNone(r);
r=TheDisk.Read(0, boot);
test_KErrNone(r);
TUint32 val = GetValue(boot, 510, 2);
RDebug::Print(_L("BPB magic number = 0x%X\n"), val);
test(aTestOnly || val == 0xAA55);
switch (boot[0])
{
case 0xEB:
RDebug::Print(_L("Jump %02X 0x%02X\n"), boot[0], boot[1]);
test(aTestOnly || boot[2] == 0x90);
break;
case 0xE9:
RDebug::Print(_L("Jump %02X 0x%02X%02X\n"), boot[0], boot[2], boot[1]);
break;
default:
RDebug::Print(_L("Invalid boot start: %02X %02X %02X\n"), boot[0], boot[1], boot[2]);
test(aTestOnly);
}
switch (gDiskType)
{
case EFat12:
test(aTestOnly || TheBootSector.ReservedSectors() >= 1);
test.Printf(_L("BPB sector OK\n"));
break;
case EFat16:
test(aTestOnly || TheBootSector.ReservedSectors() >= 1);
test.Printf(_L("BPB sector OK\n"));
break;
default:
test(aTestOnly || TheBootSector.ReservedSectors() >= 1);
test(aTestOnly || TheBootSector.ReservedSectors() > TheBootSector.BkBootRecSector());
test(aTestOnly || TheBootSector.ReservedSectors() > TheBootSector.FSInfoSectorNum());
test.Printf(_L("BPB sector OK\n"));
if (TheBootSector.BkBootRecSector() > 0)
{
r=TheDisk.Read(TheBootSector.BkBootRecSector()*seclen, back);
test(aTestOnly || r==KErrNone);
if (boot != back)
{
RDebug::Print(_L("Boot sector != backup\n"));
RDebug::Print(_L("Sector 0: Boot sector\n"));
DumpHex(boot.Ptr(), seclen);
RDebug::Print(_L("Sector %d: Backup sector\n"), TheBootSector.BkBootRecSector());
DumpHex(back.Ptr(), seclen);
test(aTestOnly);
}
test.Printf(_L("Backup BPB sector OK\n"));
}
else
test.Printf(_L("Backup BPB not present\n"));
if (TheBootSector.FSInfoSectorNum() > 0)
{
r=TheDisk.Read(TheBootSector.FSInfoSectorNum()*seclen, info);
test(aTestOnly || r==KErrNone);
// Test the 'magic numbers' (signatures) as specified
val = GetValue(info, 0, 4);
RDebug::Print(_L("FSI signature 1 = 0x%X\n"), val);
test(aTestOnly || val == 0x41615252);
val = GetValue(info, 484, 4);
RDebug::Print(_L("FSI signature 2 = 0x%X\n"), val);
test(aTestOnly || val == 0x61417272);
val = GetValue(info, 508, 4);
RDebug::Print(_L("FSI magic number = 0x%X\n"), val);
test(aTestOnly || val == 0xAA550000);
// Check the last known free count and the next free cluster value. If
// they are not calculated they should be 0xFFFFFFFF, otherwise must be
// less than the number of clusters.
val = GetValue(info, 488, 4);
RDebug::Print(_L("FSI last free # = 0x%X\n"), val);
test(aTestOnly || val == 0xFFFFFFFF || val <= (TUint32)gClusterCount);
val = GetValue(info, 492, 4);
RDebug::Print(_L("FSI next free # = 0x%X\n"), val);
test(aTestOnly || val == 0xFFFFFFFF || val < (TUint32)gClusterCount);
test.Printf(_L("FSInfo sector OK\n"));
}
break;
}
TheDisk.Close();
delete bootp;
delete backp;
delete infop;
}
static void TestFATTableEntries()
//
// Test that reading/writing FAT table entries preserves the upper 4 bits of data.
//
{
test.Next(_L("Test reading/writing FAT table entries"));
FormatPack();
TUint32 buf[16];
TInt i=0;
TInt r=KErrNone;
for (i=0; i <=7; i++)
{
buf[i] = GetFatEntry(i);
}
test.Printf(_L("First 8 FAT Entries before signature: \n"));
test.Printf(_L("%08x, %08x, %08x, %08x, %08x, %08x, %08x, %08x\n"),
buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6], buf[7]);
for (i=0; i <=7; i++)
{
MarkFatEntry(i);
}
for (i=0; i <=7; i++)
{
buf[i] = GetFatEntry(i);
}
test.Printf(_L("First 8 FAT Entries after signature: \n"));
test.Printf(_L("%08x, %08x, %08x, %08x, %08x, %08x, %08x, %08x\n"),
buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6], buf[7]);
test(TheFile.Create(TheFs,_L("\\CORRUPT1.TMP"),EFileRead|EFileWrite)==KErrNone);
TheBuffer.SetLength(2048);
Mem::Fill(&TheBuffer[0],2048,'X');
for(i=0; i<=20; i++)
{
r = TheFile.Write(TheBuffer);
test_KErrNone(r);
}
TheFile.Close();
for (i=8; i <=15; i++)
{
buf[i] = GetFatEntry(i-8);
}
test.Printf(_L("First 8 FAT Entries after file write: \n"));
test.Printf(_L("%08x, %08x, %08x, %08x, %08x, %08x, %08x, %08x\n"),
buf[8], buf[9], buf[10], buf[11], buf[12], buf[13], buf[14], buf[15]);
for (i=0; i<=7; i++)
{
test((buf[i] & 0xF0000000) == (buf[i+8] & 0xF0000000));
}
test.Printf(_L("Top 4 bits of first 8 FAT Entries have been preserved.\n"));
}
//-----------------------------------------------------------------------------
/**
Test that FAT[0] and FAT[1] just after formatting are compliant to FAT specs.
So that this test step shall be called just after the volume formatted.
*/
static void TestFirst2FatEntries()
{
test.Next(_L("Test FAT[0] and FAT[1] after formatting"));
TInt nRes;
TBuf8<8> fat1Buf; //-- buffer for FAT[0] & FAT[1] read from 1st FAT copy
TBuf8<8> fatBufCurr;
//-- read first several FAT entries from FAT1
const TUint32 posFat1Start = TheBootSector.FirstFatSector() * TheBootSector.BytesPerSector();
const TUint32 fatSize = TheBootSector.TotalFatSectors() * TheBootSector.BytesPerSector();
const TInt numFATs = TheBootSector.NumberOfFats();
nRes = MediaRawRead(TheFs, CurrentDrive(), posFat1Start, 8, fat1Buf);
test(nRes==KErrNone);
switch(gDiskType)
{
//----------- FAT12 ---------------------
case EFat12:
{
fat1Buf.SetLength(3); //-- FAT12 entry occupies 1.5 bytes
test.Printf(_L("FAT12, first 2 entries: %x %x %x\n"), fat1Buf[0], fat1Buf[1], fat1Buf[2]);
test(fat1Buf[0]==0xF8 && fat1Buf[1]==0xFF && fat1Buf[2]==0xFF); //-- see FAT specs, these are first 2 entries
//-- test that all copies of FAT have the same values in FAT[0] & FAT[1]
for(TInt i=1; i<numFATs; ++i)
{
nRes = MediaRawRead(TheFs, CurrentDrive(), posFat1Start + i*fatSize, 8, fatBufCurr);
test(nRes==KErrNone);
fatBufCurr.SetLength(3);
if(fatBufCurr != fat1Buf)
{
test.Printf(_L("1st 2 FAT entries in FAT#%d are different from FAT1!\n"), i);
test(0);
}
}
}
break;
//----------- FAT16 ---------------------
case EFat16:
{
typedef TUint16 TFat16Entry;
fat1Buf.SetLength(2*sizeof(TFat16Entry));
const TFat16Entry* pFat = (const TFat16Entry*)fat1Buf.Ptr();
const TFat16Entry fatEntry_0 = pFat[0]; //-- do not mask entries
const TFat16Entry fatEntry_1 = pFat[1]; //-- do not mask entries
test.Printf(_L("FAT16[0]=0x%x, FAT16[1]=0x%x\n"), fatEntry_0, fatEntry_1);
test(fatEntry_0 == 0xFFF8); //-- see FAT specs
test(fatEntry_1 == 0xFFFF); //-- the volume shall be clean just after the formatting. It can be 0x7FFF if a write to the volume occured.
//-- test that all copies of FAT have the same values in FAT[0] & FAT[1]
for(TInt i=1; i<numFATs; ++i)
{
nRes = MediaRawRead(TheFs, CurrentDrive(), posFat1Start + i*fatSize, 8, fatBufCurr);
test(nRes==KErrNone);
fatBufCurr.SetLength(2*sizeof(TFat16Entry));
if(fatBufCurr != fat1Buf)
{
test.Printf(_L("1st 2 FAT entries in FAT#%d are different from FAT1!\n"), i);
test(0);
}
}
}
break;
//----------- FAT32 ---------------------
case EFat32:
{
typedef TUint32 TFat32Entry;
fat1Buf.SetLength(2*sizeof(TFat32Entry));
const TFat32Entry* pFat = (const TFat32Entry*)fat1Buf.Ptr();
const TFat32Entry fatEntry_0 = pFat[0]; //-- do not mask entries
const TFat32Entry fatEntry_1 = pFat[1]; //-- do not mask entries
test.Printf(_L("FAT32[0]=0x%x, FAT32[1]=0x%x\n"), fatEntry_0, fatEntry_1);
test(fatEntry_0 == 0x0FFFFFF8); //-- see FAT specs
test(fatEntry_1 == 0x0FFFFFFF); //-- the volume shall be clean just after the formatting. It can be 0x07FFFFFF if a write to the volume occured.
//-- test that all copies of FAT have the same values in FAT[0] & FAT[1]
for(TInt i=1; i<numFATs; ++i)
{
nRes = MediaRawRead(TheFs, CurrentDrive(), posFat1Start + i*fatSize, 8, fatBufCurr);
test(nRes==KErrNone);
fatBufCurr.SetLength(2*sizeof(TFat32Entry));
if(fatBufCurr != fat1Buf)
{
test.Printf(_L("1st 2 FAT entries in FAT#%d are different from FAT1!\n"), i);
test(0);
}
}
}
break;
default:
test(0);
break;
};//switch(gDiskType)
}
/**
Exhaustive test of Data alignmemnt calculation
in this code the function
TInt TFatAlignment::AdjustFirstDataSectorAlignment(TInt aBlockSize)
should be exactly the same as
TInt CFatFormatCB::AdjustFirstDataSectorAlignment(TInt aBlockSize)
*/
class TFatAlignment
{
public:
enum {KDefFatResvdSec = 1, KDefFat32ResvdSec = 32}; ///< default number of FAT32 reserved sectors
public:
TFatAlignment();
void Init(TBool aFat32, TInt aNumberOfFats, TInt aMaxDiskSectors, TInt aSectorsPerCluster, TInt aRootDirEntries);
TUint32 MaxFat32Sectors() const;
TInt MaxFat16Sectors() const;
TInt MaxFat12Sectors() const;
TUint32 RootDirSectors() const;
TInt FirstDataSector() const;
TBool Is32BitFat() const;
TBool Is16BitFat() const;
TInt AdjustFirstDataSectorAlignment(TInt aBlockSize);
void Display();
public:
TInt iBytesPerSector;
TInt iNumberOfFats;
TInt iMaxDiskSectors;
TInt iSectorsPerCluster;
TInt iReservedSectors;
TInt iSectorsPerFat;
TInt iRootDirEntries;
TBool iFat32; // 0 = FAT16, 1 = FAT32
TInt iMaxIterations;
};
TFatAlignment::TFatAlignment()
{
iMaxIterations = 0;
}
void TFatAlignment::Init(TBool aFat32, TInt aNumberOfFats, TInt aMaxDiskSectors, TInt aSectorsPerCluster, TInt aRootDirEntries)
{
iBytesPerSector = 512;
iFat32 = aFat32;
iNumberOfFats = aNumberOfFats;
iMaxDiskSectors = aMaxDiskSectors;
iSectorsPerCluster = aSectorsPerCluster;
iRootDirEntries = aRootDirEntries;
iReservedSectors = iFat32 ? KDefFat32ResvdSec : KDefFatResvdSec;
iSectorsPerFat = iFat32 ? MaxFat32Sectors() : MaxFat16Sectors();
}
void TFatAlignment::Display()
{
RDebug::Print(_L("iFat32 %u iNumberOfFats %u,iMaxDiskSectors %u,iSectorsPerCluster %u,iReservedSectors %u,iSectorsPerFat %u, iRootDirEntries %u, FirstDataSector %08X"),
iFat32,
iNumberOfFats,
iMaxDiskSectors,
iSectorsPerCluster,
iReservedSectors,
iSectorsPerFat,
iRootDirEntries,
FirstDataSector());
}
TInt TFatAlignment::MaxFat16Sectors() const
{
TInt fatSizeInBytes=(2*iMaxDiskSectors)/iSectorsPerCluster+(iBytesPerSector-1);
return(fatSizeInBytes/iBytesPerSector);
}
TInt TFatAlignment::MaxFat12Sectors() const
{
TInt maxDiskClusters=iMaxDiskSectors/iSectorsPerCluster;
TInt fatSizeInBytes=maxDiskClusters+(maxDiskClusters>>1)+(iBytesPerSector-1);
return(fatSizeInBytes/iBytesPerSector);
}
TUint32 TFatAlignment::MaxFat32Sectors() const
{
TUint32 calc1 = iMaxDiskSectors - iReservedSectors;
TUint32 calc2 = (256 * iSectorsPerCluster) + iNumberOfFats;
calc2 = calc2 >> 1;
return (calc1 + (calc2 - 1))/calc2;
}
/**
@return Number of sectors in root directory. 0 for FAT32
*/
TUint32 TFatAlignment::RootDirSectors() const
{
const TInt KSizeOfFatDirEntry =32; ///< Size in bytes of a Fat directry entry
return ( (iRootDirEntries * KSizeOfFatDirEntry + (iBytesPerSector-1)) / iBytesPerSector );
}
TInt TFatAlignment::FirstDataSector() const
{
return( iReservedSectors + iNumberOfFats * iSectorsPerFat + RootDirSectors());
}
TBool TFatAlignment::Is32BitFat() const
{
return iFat32;
}
TBool TFatAlignment::Is16BitFat() const
{
return !iFat32;
}
#define __PRINT1
// AdjustFirstDataSectorAlignment()
// Attempts to align the first data sector on an erase block boundary by modifying the
// number of reserved sectors.
TInt TFatAlignment::AdjustFirstDataSectorAlignment(TInt aEraseBlockSizeInSectors)
{
const TBool bFat16 = Is16BitFat();
const TBool bFat32 = Is32BitFat();
// Save these 2 values in the event of a convergence failure; this should
// hopefully never happen, but we will cater for this in release mode to be safe,
TInt reservedSectorsSaved = iReservedSectors;
TInt sectorsPerFatSaved = iSectorsPerFat;
TInt reservedSectorsOld = 0;
// zero for FAT32
TInt rootDirSectors = (iRootDirEntries * KSizeOfFatDirEntry + (iBytesPerSector-1)) / iBytesPerSector;
TInt fatSectors = 0;
TInt KMaxIterations = 10;
TInt n;
for (n=0; n<KMaxIterations && reservedSectorsOld != iReservedSectors; n++)
{
reservedSectorsOld = iReservedSectors;
iSectorsPerFat = bFat32 ? MaxFat32Sectors() : bFat16 ? MaxFat16Sectors() : MaxFat12Sectors();
fatSectors = iSectorsPerFat * iNumberOfFats;
// calculate number of blocks
TInt nBlocks = (iReservedSectors + fatSectors + rootDirSectors + aEraseBlockSizeInSectors-1) / aEraseBlockSizeInSectors;
iReservedSectors = (nBlocks * aEraseBlockSizeInSectors) - rootDirSectors - fatSectors;
}
ASSERT(iReservedSectors >= (TInt) (bFat32 ? KDefFat32ResvdSec : KDefFatResvdSec));
if ((FirstDataSector() & (aEraseBlockSizeInSectors-1)) == 0)
{
return KErrNone;
}
else
{
iReservedSectors = reservedSectorsSaved;
iSectorsPerFat = sectorsPerFatSaved;
return KErrGeneral;
}
}
void TestFirstDataSectorAlignment()
{
test.Start(_L("Exhaustive test of data alignment calculation"));
typedef struct
{
TInt iNumberOfFats;
TInt iMaxDiskSectors;
TInt iSectorsPerCluster;
TInt iBlockSize;
TInt iRootDirEntries;
} STestVal;
STestVal testVals[] =
{
{2, 15720448, 32, 16*1024, 0}, // 4GB MoviNand, cluster size = 16K
{2, 106496, 2, 2048, 512}, // diskSize = 54MB, = block size = 1MB
{2, 1048576, 8, 2048, 0}, // diskSize = 512 MB
{2, 1048578, 8, 2048, 0}, // Doesn't converge with original algorithm
};
TFatAlignment fatAlignment;
TInt numOfTests = sizeof(testVals) / sizeof(STestVal);
for (TInt n=0; n<numOfTests; n++)
{
STestVal& testVal = testVals[n];
TBool fat32 = testVal.iMaxDiskSectors >= 1048576;
fatAlignment.Init(
fat32,
testVal.iNumberOfFats,
testVal.iMaxDiskSectors,
testVal.iSectorsPerCluster,
testVal.iRootDirEntries);
TInt r = fatAlignment.AdjustFirstDataSectorAlignment(testVal.iBlockSize);
test_KErrNone(r);
fatAlignment.Display();
}
const TInt64 KOneMByte = 1024*1024;
const TInt64 KOneGByte = 1024*KOneMByte;
const TInt64 KLastSizeToTest = 32*KOneGByte;
TInt iteration=0;
TInt64 diskSize;
TInt successes = 0;
TInt failures = 0;
for (iteration=0, diskSize = 16*KOneMByte; diskSize < KLastSizeToTest; iteration++, diskSize+=512)
{
TInt diskSizeInSectors = (TInt) (diskSize >> 9);
const TInt KMaxFAT16Entries=0xFFF0; ///< Maximum number of clusters in a Fat16 Fat table, 65520
TBool fat32 = EFalse;
TInt numberOfFats = 2;
TInt rootDirEntries;
TInt sectorsPerCluster;
TInt blockSizeInSectors = 32; // 16K for FAT16
if (diskSizeInSectors<4096) // < 2MB
{
rootDirEntries=128;
sectorsPerCluster=1;
}
else if (diskSizeInSectors<8400) // < 4MB
{
rootDirEntries=256;
sectorsPerCluster=2;
}
else if (diskSizeInSectors<16384) // < 8MB
{
rootDirEntries=512;
sectorsPerCluster=4;
}
else if (diskSizeInSectors<32680) // < 16MB
{
rootDirEntries=512;
sectorsPerCluster=8;
}
else if(diskSizeInSectors<1048576) // >= 16Mb - FAT16 < (1048576) 512MB
{
TInt minSectorsPerCluster=(diskSizeInSectors+KMaxFAT16Entries-1)/KMaxFAT16Entries;
rootDirEntries=512;
sectorsPerCluster=1;
while (minSectorsPerCluster>sectorsPerCluster)
sectorsPerCluster<<=1;
}
else //use FAT32
{
rootDirEntries=0; //this is always the case for fat32
if(diskSizeInSectors < 16777216) //8GB in 512byte sectors
sectorsPerCluster=8;
else if(diskSizeInSectors < 33554432) //16GB in 512byte sectors
sectorsPerCluster=16;
else if(diskSizeInSectors < 67108864) //32GB in 512byte sectors
sectorsPerCluster=32;
else
sectorsPerCluster=64; //Anything >= 32GB uses a 32K cluster size
blockSizeInSectors = 2048; // 1MB for FAT32
fat32 = ETrue;
}
fatAlignment.Init(
fat32,
numberOfFats,
diskSizeInSectors,
sectorsPerCluster,
rootDirEntries);
TInt r = fatAlignment.AdjustFirstDataSectorAlignment(blockSizeInSectors);
if (r == KErrNone)
successes++;
else
failures++;
// if (diskSize % 0x08000000 == 0)
// {
// RDebug::Print(_L("Iter %10lX of %10lX"), diskSize, KLastSizeToTest);
// fatAlignment.Display();
// }
}
RDebug::Print(_L("Total iterations %u"), iteration);
RDebug::Print(_L("Max loop count %u"), fatAlignment.iMaxIterations);
RDebug::Print(_L("successes %d failures %d, success rate %ld"),
successes, failures, (TInt64(successes) * 100) / TInt64(successes + failures));
test (failures == 0);
}
static void TestZeroLengthFile()
//
// Test what happens if you write more to a zero length file than
// will fit in the filesystem.
//
{
test.Next(_L("Test behaviour of extending a zero length file"));
FormatPack();
TInt r;
TVolumeInfo volInfo;
r=TheFs.Volume(volInfo);
test_KErrNone(r);
TInt64 spaceToUse = volInfo.iFree - gBytesPerCluster; // whole disk except 1 cluster
test.Printf(_L("spaceToUse %ld gClusterCount %d gBytesPerCluster %d\n"), spaceToUse, gClusterCount, gBytesPerCluster);
test.Printf(_L("Before fill, volInfo.iSize %ld volInfo.iFree %ld\n"), volInfo.iSize, volInfo.iFree);
RFile f;
TInt tempfiles = 0;
while (spaceToUse > K1GigaByte)
{
TFileName tempName;
r=f.Temp(TheFs,_L("\\"),tempName,EFileRead|EFileWrite);
test_KErrNone(r);
r=f.SetSize(K1GigaByte);
test_KErrNone(r);
f.Close();
spaceToUse -= K1GigaByte;
tempfiles++;
}
r=f.Replace(TheFs,_L("\\USESPACE.TMP"),EFileRead|EFileWrite);
test_KErrNone(r);
r=f.SetSize((TInt)spaceToUse);
test_KErrNone(r);
f.Close();
r=TheFs.Volume(volInfo);
test_KErrNone(r);
test.Printf(_L("After fill, volInfo.iSize %ld volInfo.iFree %ld\n"), volInfo.iSize, volInfo.iFree);
test(volInfo.iFree==gBytesPerCluster); // check we have 1 cluster free
r=f.Replace(TheFs,_L("\\FILE.TMP"),EFileRead|EFileWrite);
test_KErrNone(r);
r=f.SetSize(2*gBytesPerCluster); // 2 clusters (will fail since there's not space)
test_Value(r, r == KErrDiskFull);
f.Close();
r=TheFs.Volume(volInfo);
test_KErrNone(r);
test(volInfo.iFree==gBytesPerCluster); // check we still have 1 cluster free
r=f.Replace(TheFs,_L("\\USESPACE.TMP"),EFileRead|EFileWrite); // truncate file to 0
test_KErrNone(r);
f.Close();
r=TheFs.Volume(volInfo);
test_KErrNone(r);
test(volInfo.iFree==(spaceToUse+gBytesPerCluster)); // check we've freed up the space from USESPACE plus one cluster
test(TheBootSector.IsValid()); //-- TheBootSector is read after formatting
TInt64 rootDirpos = gRootDirStart;
//-- read 1 sector of the root dir.
r = MediaRawRead(TheFs, CurrentDrive(), rootDirpos, TheBootSector.BytesPerSector(), TheBuffer);
test_KErrNone(r);
const TFatDirEntry* pE=(TFatDirEntry*)TheBuffer.Ptr();
while (tempfiles-- > 0)
{
while (pE->IsVFatEntry())
pE++;
test(pE->Size()==(TUint)K1GigaByte);
pE++;
}
while (pE->IsVFatEntry())
pE++;
TBuf8<15> name=pE->Name();
test(name==_L8("USESPACETMP"));
test(pE->StartCluster()==0);
pE++;
while (pE->IsVFatEntry())
pE++;
name=pE->Name();
test(name==_L8("FILE TMP"));
test(pE->StartCluster()==0);
FormatPack();
}
//
// Call tests that may leave
//
void CallTestsL()
{
//-- init random generator
rndSeed = Math::Random();
//-- set up console output
Fat_Test_Utils::SetConsole(test.Console());
TInt drvNum;
TInt r=TheFs.CharToDrive(gDriveToTest,drvNum);
test_KErrNone(r);
if (!Is_Fat(TheFs,drvNum))
{
test.Printf(_L("CallTestsL: Skipped: test requires FAT filesystem\n"));
return;
}
//-- print drive information
PrintDrvInfo(TheFs, drvNum);
// check this is not the internal ram drive
TVolumeInfo v;
r=TheFs.Volume(v, drvNum);
test_KErrNone(r);
TBool isRamDrive = v.iDrive.iMediaAtt&KMediaAttVariableSize;
gSessionPath[0] = (TText)gDriveToTest;
// verify that the drive is large enough for proper testing
if (v.iSize<512*1024)
{
test.Printf(_L("CallTestsL: Skipped: test not supported on drives smaller than 512 KB\n"));
return;
}
FormatPack();
DumpBootSector();
test.Printf(_L("TotalSectors = %u (%u bytes)\n"),gTotalSectors,gTotalSectors*TheBootSector.BytesPerSector());
test.Printf(_L("Sector size = %u\n"),TheBootSector.BytesPerSector());
test.Printf(_L("Cluster size = %u sectors\n"),TheBootSector.SectorsPerCluster());
test.Printf(_L("Alloc unit = %u\n"), gBytesPerCluster);
test.Printf(_L("Fat is %u bit\n"), gFatBits);
User::After(200000); // 1/5 secs
// set up buffers
TInt bufLen = 16*gBytesPerCluster;
if (bufLen < 16*1024)
bufLen = 16*1024;
pBuffer1=HBufC8::NewL(bufLen);
pBuffer2=HBufC8::NewL(bufLen);
if (pBuffer1==NULL || pBuffer2==NULL)
Error(_L("OOM"),KErrNoMemory);
pBuffer1->Des().Zero();
pBuffer1->Des().SetLength(bufLen);
pBuffer2->Des().Zero();
pBuffer2->Des().SetLength(bufLen);
if (isRamDrive)
{
User::After(200000); // 1/5 secs
test.Printf(_L("*** Tests not valid on internal ram drive %C:\n"), (TUint)gDriveToTest);
User::After(200000); // 1/5 secs
}
else
{
TestZeroLengthFile();
#if defined(__WINS__)
TestFirstDataSectorAlignment();
#endif
TestFirst2FatEntries();
TestDiskIntegrity();
TestBounds();
TestUnicodeEntry();
TestClusters();
TestClusterAllocation();
TestParentDir(EFalse); // Test without VFAT entries
TestParentDir(ETrue); // Test with VFAT entries
TestRoot();
TestVolumeSize();
TestFATTableEntries();
FormatPack();
}
delete pBuffer1;
delete pBuffer2;
}
/**
Generate unique temp file name in upper (FAT entry) or lower case (2 VFAT entries)
@param aFN descriptor for the file name
@param aUpperCase if ETrue, the file name will be in upper case, in a lower case otherwise.
*/
void GenerateTmpFileName(TDes& aFN, TBool aUpperCase)
{
const TInt rnd = Math::Rand(rndSeed);
aFN.Format(_L("%08x.tmp"), rnd);
if(aUpperCase)
aFN.UpperCase();
else
aFN.LowerCase();
}
/**
Create FAT or VFAT entry in a speciified directory
@param aDir specifies the directory where enntry will be created
@param aVFatEntry if true, VFAT entry will be created (2 FAT entries, actually), otherwise - FAT entry
@param apFileName in !=NULL there will be placed the name of the file created
*/
void CreateFatEntry(const TDesC& aDir, TBool aVFatEntry, TDes *apFileName/*=NULL*/)
{
TFileName tmpFN;
RFile file;
TInt nRes;
do
{
GenerateTmpFileName(tmpFN, !aVFatEntry); //-- generates 8.3 file name FAT (1 entry) or VFAT (2 entries)
tmpFN.Insert(0, aDir);
nRes = file.Create(TheFs, tmpFN, EFileRead|EFileWrite);
if(nRes == KErrAlreadyExists)
continue; //-- current random name generator isn't perfect...
if(nRes != KErrNone)
Error(_L("Error creating a file"),nRes);
file.Close();
}while(nRes != KErrNone);
if(apFileName)
*apFileName = tmpFN;
}