TTestObject::~TTestObject()
{
RDebug::Printf("t_destruct_slave destructor called\n");
if (iTestType == ETestRecursive)
{
// Start child thread passing this thread's id
MainThreadId = RThread().Id();
RThread childThread;
test_KErrNone(childThread.Create(_L("ChildThread"), ChildThread, 4096, NULL, (TAny*)iTestType));
TRequestStatus status;
childThread.Rendezvous(status);
childThread.Resume();
// Wait for child to open handle on this thread
User::WaitForRequest(status);
test_KErrNone(status.Int());
childThread.Close();
// Set this thread non-critical
User::SetCritical(User::ENotCritical);
}
else if (iTestType == ETestDestructorExits)
{
User::Exit(iTestType);
}
RMsgQueue<TMessage> messageQueue;
TInt r = messageQueue.OpenGlobal(KMessageQueueName);
if (r != KErrNone)
Panic(r);
messageQueue.Send(EMessageDestruct);
if (r != KErrNone)
Panic(r);
}
TInt E32Main()
{
test.Title();
test.Start(_L("Testing ldd importing"));
test.Next(_L("Load the exporting ldd"));
TInt r=User::LoadLogicalDevice(KExportTestLddName);
test_Equal(KErrNone, r); // Don't allow KErrAlreadyExists as don't want ldd to be XIP.
RExportLdd exportLdd;
test_KErrNone(exportLdd.Open());
// The exported function multiplies the 2 arguments.
test_Equal(12, exportLdd.RunExport(3, 4));
test.Next(_L("Load the importing ldd"));
r=User::LoadLogicalDevice(KImportTestLddName);
test_Equal(KErrNone, r); // Don't allow KErrAlreadyExists as don't want ldd to be XIP.
RImportLdd importLdd;
test_KErrNone(importLdd.Open());
// The imported function multiplies the 2 arguments.
test_Equal(12, importLdd.RunImport(3, 4));
exportLdd.Close();
importLdd.Close();
test_KErrNone(User::FreeLogicalDevice(KExportTestLddName));
test_KErrNone(User::FreeLogicalDevice(KImportTestLddName));
test.End();
return KErrNone;
}
LOCAL_C void buildRomImageL()
//
// Build the ROM image.
//
{
test.Start(_L("Parse command line"));
HBufC* buf=HBufC::New(RProcess().CommandLineLength());
test(buf!=NULL);
TPtr cmd = buf->Des();
RProcess().CommandLine(cmd);
TLex lex(*buf);
TFileName n=lex.NextToken();
if (n.Length()==0)
n=_L("\\F32");
test(n.Length()!=0);
if (n.Right(1)==_L("\\"))
n.SetLength(n.Length()-1);
//
test.Next(_L("Create root mem dir"));
TRAPD(r,TheRootDir=CMemDir::NewL());
test_KErrNone(r);
//
test.Next(_L("Load directory structure"));
TheLevel=(-1);
TRAP(r,TheRootDir->LoadDirL(n));
test_KErrNone(r);
test(TheLevel==(-1));
//
delete buf;
test.End();
}
LOCAL_C void TestCaps()
//
// test format etc that require certain capabilities
//
{
driveBuf[0]=(TText)gDriveToTest;
r=TheFs.SessionPath(temp);
test_KErrNone(r);
test.Printf(_L("Session path: %S"),&temp);
r=TheFs.CreatePrivatePath(gTheDriveNum);
test_Value(r, r == KErrNone || r== KErrAlreadyExists);
TBuf<18> tempPri;
r=TheFs.PrivatePath(tempPri);
test_KErrNone(r);
theprivatepath = _L("?:");
theprivatepath.Append(tempPri);
DiskAdminTest();
TFileName thesessionpath;
r=TheFs.SetSessionToPrivate(gTheDriveNum);
test_KErrNone(r);
r=TheFs.SessionPath(thesessionpath);
test_KErrNone(r);
test(thesessionpath == theprivatepath);
}
LOCAL_C void CleanDirs()
//
// Remove system and private directories for scan with and without DC
// (note that the \Private directory may not be able to be removed at this
// point if it contains other directories, so failing with "in use" is
// permitted in this case).
//
{
TInt r;
r = TheFs.RmDir(_L("\\normal\\one\\"));
test_KErrNone(r);
r = TheFs.RmDir(_L("\\normal\\two\\"));
test_KErrNone(r);
r = TheFs.RmDir(_L("\\normal\\"));
test_KErrNone(r);
r = TheFs.RmDir(_L("\\sys\\one\\"));
test_Value(r, r == KErrPermissionDenied);
r = TheFs.RmDir(_L("\\sys\\two\\"));
test_Value(r, r == KErrPermissionDenied);
r = TheFs.RmDir(_L("\\sys\\"));
test_Value(r, r == KErrPermissionDenied);
r = TheFs.RmDir(_L("\\private\\one\\"));
test_Value(r, r == KErrPermissionDenied);
r = TheFs.RmDir(_L("\\private\\two\\"));
test_Value(r, r == KErrPermissionDenied);
r = TheFs.RmDir(_L("\\private\\"));
test_Value(r, r == KErrPermissionDenied);
r = TheFs.RmDir(_L("\\ZZZZZZ\\"));
test_KErrNone(r);
}
void UnfragmentMemory(TBool aDiscard, TBool aTouchMemory, TBool aFragThread)
{
test_Value(aTouchMemory, !aTouchMemory || !aFragThread);
if (aTouchMemory && !ManualTest)
{
TouchDataStop = ETrue;
User::WaitForRequest(TouchStatus);
test_Equal(EExitKill, TouchThread.ExitType());
test_KErrNone(TouchThread.ExitReason());
CLOSE_AND_WAIT(TouchThread);
}
if (aFragThread)
{
FragThreadStop = ETrue;
User::WaitForRequest(FragStatus);
test_Equal(EExitKill, FragThread.ExitType());
test_KErrNone(FragThread.ExitReason());
CLOSE_AND_WAIT(FragThread);
}
else
UnfragmentMemoryFunc();
if (CacheSizeAdjustable)
test_KErrNone(DPTest::SetCacheSize(OrigMinCacheSize, OrigMaxCacheSize));
CLOSE_AND_WAIT(Chunk);
}
LOCAL_C void Test2()
//
// Reproduce old bugs
//
{
test.Next(_L("Regression Protection"));
RFile f1,f2;
//
TInt r=f1.Replace(TheFs,_L("BIGFILE1.TST"),EFileWrite);
test_KErrNone(r);
r=f2.Replace(TheFs,_L("BIGFILE2.TST"),EFileWrite);
test_KErrNone(r);
//
WriteCluster(f1,0);
WriteCluster(f1,1);
WriteCluster(f1,2);
WriteCluster(f1,3);
WriteCluster(f1,4);
WriteCluster(f1,5);
WriteCluster(f2,0);
WriteCluster(f1,6);
//
SeekToCluster(f1,6);
SeekToCluster(f1,4);
//
f1.Close();
f2.Close();
r=TheFs.Delete(_L("BIGFile1.tst"));
test_KErrNone(r);
r=TheFs.Delete(_L("BIGFile2.tst"));
test_KErrNone(r);
CheckDisk();
}
LOCAL_C void privateSIDRFiletest()
//
//
//
{
r=TheFs.SetSessionToPrivate(gTheDriveNum);
test_KErrNone(r);
r=file1.Temp(TheFs,theprivatepath,fromTemp,EFileWrite);
test_KErrNone(r);
file1.Close();
r=file1.Create(TheFs,KFilePri,EFileWrite);
test_Value(r, r == KErrNone || r==KErrAlreadyExists);
file1.Close();
r=file1.Open(TheFs,KFilePri,EFileWrite);
test_KErrNone(r);
file1.Close();
r=file1.Open(TheFs,KFilePri,EFileRead);
test_KErrNone(r);
file1.Close();
r=file1.Replace(TheFs,KFilePri,EFileWrite);
test_KErrNone(r);
r=file1.Rename(KFilePri3);
test_Value(r, r == KErrNone || r==KErrAlreadyExists);
file1.Close();
}
void Test1(TUint32 aInt, TInt aDivisorExp)
{
TRealX realx;
SRatio r0x;
SRatio r0;
SRatio r1x;
SRatio r1;
TInt r;
test.Printf(_L("Test1 %08x %d\n"), aInt, aDivisorExp);
r = RatioSetValue(realx, aInt, aDivisorExp);
test_KErrNone(r);
r = RealToRatio(r0x, realx);
test_KErrNone(r);
r = Driver.RatioSet(r0, aInt, aDivisorExp);
RatioPrint2("R0X,R0", r0x, r0);
TestEqual(r0, r0x);
Test1M(r0);
r1x = r0x;
r = RatioReciprocal(r1x);
test_KErrNone(r);
r1 = r0;
r = Driver.RatioReciprocal(r1);
test_KErrNone(r);
RatioPrint2("R1X,R1", r1x, r1);
TestEqual(r1, r1x);
Test1M(r1);
}
LOCAL_C void RemountFileSystem(TInt aDrive, TBool aSync)
/// Unmount and remount the file system on the specified drive in the
/// selected mode.
/// @param aDrive Drive number (EDriveC etc.).
/// @param aSync Mount synchronous if true, asynchronous if not.
{
TChar c;
TInt r=TheFs.DriveToChar(aDrive,c);
r=TheFs.FileSystemName(gFsName, aDrive);
test_Value(r, r == KErrNone || r==KErrNotFound);
if (gFsName.Length() > 0)
{
r=TheFs.DismountFileSystem(gFsName, aDrive);
test_KErrNone(r);
}
TBufC<16> type = _L("asynchronous");
if (aSync)
type = _L("synchronous");
test.Printf(_L("Mount filesystem %c: %-8S as %S\n"), (TUint)c, &gFsName, &type);
#ifdef __CONCURRENT_FILE_ACCESS__
r=TheFs.MountFileSystem(gFsName, aDrive, aSync);
#else
r=TheFs.MountFileSystem(gFsName, aDrive);
#endif
test_KErrNone(r);
}
static void RecursiveRmDir(const TDesC& aDes)
//
// Delete directory contents recursively
//
{
CDir* pD;
TFileName n=aDes;
n.Append(_L("*"));
TInt r=TheFs.GetDir(n,KEntryAttMaskSupported,EDirsLast,pD);
if (r==KErrNotFound || r==KErrPathNotFound)
return;
test_KErrNone(r);
TInt count=pD->Count();
TInt i=0;
while (i<count)
{
const TEntry& e=(*pD)[i++];
if (e.IsDir())
{
TFileName dirName;
dirName.Format(_L("%S%S\\"),&aDes,&e.iName);
RecursiveRmDir(dirName);
}
else
{
TFileName fileName;
fileName.Format(_L("%S%S"),&aDes,&e.iName);
r=TheFs.Delete(fileName);
test_KErrNone(r);
}
}
delete pD;
r=TheFs.RmDir(aDes);
test_KErrNone(r);
}
TInt CCpuMeter::Construct()
{
iNumCpus = NumberOfCpus();
iNullThreads = (RThread*)User::AllocZ(iNumCpus*sizeof(RThread));
iDelta = (TInt*)User::AllocZ(iNumCpus*sizeof(TInt));
iMeas[0] = (TTimeIntervalMicroSeconds*)User::AllocZ(iNumCpus*sizeof(TTimeIntervalMicroSeconds));
iMeas[1] = (TTimeIntervalMicroSeconds*)User::AllocZ(iNumCpus*sizeof(TTimeIntervalMicroSeconds));
if (!iNullThreads || !iDelta || !iMeas[0] || !iMeas[1])
return KErrNoMemory;
TFullName kname;
_LIT(KLitKernelName, "ekern.exe*");
_LIT(KLitNull, "::Null");
TFindProcess fp(KLitKernelName);
test_KErrNone(fp.Next(kname));
test.Printf(_L("Found kernel process: %S\n"), &kname);
kname.Append(KLitNull);
TInt i;
for (i=0; i<iNumCpus; ++i)
{
TFullName tname(kname);
TFullName tname2;
if (i>0)
tname.AppendNum(i);
TFindThread ft(tname);
test_KErrNone(ft.Next(tname2));
TInt r = iNullThreads[i].Open(ft);
test_KErrNone(r);
iNullThreads[i].FullName(tname2);
test.Printf(_L("Found and opened %S\n"), &tname2);
}
for (i=0; i<iNumCpus; ++i)
iNullThreads[i].GetCpuTime(iMeas[0][i]);
iNextMeas = 1;
return KErrNone;
}
LOCAL_C int TestCodeAsync(TAny *NotUsed)
{
TInt Ignore;
TUint ModAddr;
TInt FirstJump;
TInt SecondJump;
ModAddr = GetCodeData((TInt *)TestCodeModFunc, Ignore, FirstJump, SecondJump);
FOREVER
{
TInt r = Device.WriteCode(0, ModAddr,SecondJump,sizeof(TInt));
test_KErrNone(r);
r = TestCodeModFunc();
test (2 == r);
r = Device.RestoreCode(0, ModAddr);
test_KErrNone(r);
r = TestCodeModFunc();
test (1 == r);
User::AfterHighRes(10);
}
}
/*
* Creates a Thread that modifies its code in a tight loop while the main
* thread moves the functions page around
*/
LOCAL_C TInt TestCodeModificationAsync(RPageMove& pagemove)
{
TInt ret;
RThread CodeThread;
TRequestStatus s;
/* Create the Thread to modify the code segment */
test_KErrNone(CodeThread.Create(_L("TestCodeAsync"), TestCodeAsync, KDefaultStackSize, NULL, NULL));
CodeThread.Logon(s);
CodeThread.SetPriority(EPriorityMore);
CodeThread.Resume();
TestCodeSetupDrive(CodeThread);
/* Loop trying to move the code page while the thread (CodeThread) modifies it */
for (TInt i=0; i<Repitions; i++)
{
test_KErrNone(pagemove.TryMovingUserPage((TAny*)TestCodeModFunc));
}
CodeThread.Kill(KErrNone);
User::WaitForRequest(s);
test_Equal(EExitKill, CodeThread.ExitType());
test_KErrNone(CodeThread.ExitReason());
CodeThread.Close();
ret = TestCodeModFunc();
test(ret == 1 || ret == 2);
return KErrNone;
}
void TestCommitDecommit(RPageMove& pagemove, RChunk& aChunk)
{
test.Printf(_L("Attempt to move a page while it is being committed and decommited\n"));
RThread thread;
TRequestStatus s;
test_KErrNone(thread.Create(_L("CommitDecommit"), &CommitDecommit, KDefaultStackSize, NULL, (TAny*)&aChunk));
thread.Logon(s);
thread.SetPriority(EPriorityMore);
thread.Resume();
TUint8* firstpage=(TUint8*)_ALIGN_DOWN((TLinAddr)aChunk.Base(), PageSize);
for (TInt i=0; i < Repitions; i++)
{
TInt r = pagemove.TryMovingUserPage(firstpage, ETrue);
// Allow all valid return codes as we are only testing that this doesn't
// crash the kernel and the page could be commited, paged out or decommited
// at any one time.
test_Value(r, r <= KErrNone);
}
thread.Kill(KErrNone);
User::WaitForRequest(s);
test_Equal(EExitKill,thread.ExitType());
test_KErrNone(thread.ExitReason());
thread.Close();
}
void TSessionTest::testDriveInfo()
//
// Test the drive info.
//
{
test.Start(_L("The drive info"));
TDriveList list;
TInt r=iFs.DriveList(list);
test_KErrNone(r);
for (TInt i=0;i<KMaxDrives;i++)
{
TInt att=list[i];
if (att)
{
TDriveInfo d;
r=iFs.Drive(d,i);
test_KErrNone(r);
printDriveInfo(i,d);
test.Printf(_L("\n"));
DriveInfo(i,d);
}
}
test.End();
}
LOCAL_C void RDirtest()
//
//
//
{
//system
TBuf<30> dirNameBuf(KSystemPath);
dirNameBuf[0]=(TText)gDriveToTest;
r=dir.Open(TheFs,dirNameBuf,KEntryAttNormal);
test_Value(r, r == KErrPermissionDenied);
dir.Close();
r=TheFs.GetDir(dirNameBuf,KEntryAttMatchMask,ESortByName,dirEntries);
test_Value(r, r == KErrPermissionDenied);
dirNameBuf.Zero();
delete dirEntries;
dirNameBuf=KPrivateFalseID;
dirNameBuf[0]=(TText)gDriveToTest;
r=dir.Open(TheFs,dirNameBuf,KEntryAttNormal);
test_Value(r, r == KErrPermissionDenied);
dir.Close();
r=TheFs.GetDir(dirNameBuf,KEntryAttMatchMask,ESortByName,dirEntries);
test_Value(r, r == KErrPermissionDenied);
dirNameBuf.Zero();
delete dirEntries;
//Private
dirNameBuf=KPrivatePath;
dirNameBuf[0]=(TText)gDriveToTest;
r=dir.Open(TheFs,dirNameBuf,KEntryAttNormal);
test_Value(r, r == KErrPermissionDenied);
dir.Close();
r=TheFs.GetDir(dirNameBuf,KEntryAttMatchMask,ESortByName,dirEntries);
test_Value(r, r == KErrPermissionDenied);
dirNameBuf.Zero();
delete dirEntries;
//Private/uid
TheFs.PrivatePath(dirNameBuf);
dirNameBuf.Insert(0,_L("?:"));
dirNameBuf[0]=(TText)gDriveToTest;
r=dir.Open(TheFs,dirNameBuf,KEntryAttNormal);
test_KErrNone(r);
dir.Close();
r=TheFs.GetDir(dirNameBuf,KEntryAttMatchMask,ESortByName,dirEntries);
test_KErrNone(r);
dirNameBuf.Zero();
delete dirEntries;
//Resource
dirNameBuf=KResourcePath;
dirNameBuf[0]=(TText)gDriveToTest;
r=dir.Open(TheFs,dirNameBuf,KEntryAttNormal);
test_KErrNone(r);
r=TheFs.GetDir(dirNameBuf,KEntryAttMatchMask,ESortByName,dirEntries);
test_KErrNone(r);
dir.Close();
delete dirEntries;
}
LOCAL_C void Test2()
//
// Test RFs::ReadFileSection() on UID reads
//
{
test.Next(_L("Use RFs::ReadFileSection() to read UIDs from files"));
TBuf8<sizeof(TCheckedUid)> uidBuf(sizeof(TCheckedUid));
TPtr uidPtr((TText*)uidBuf.Ptr(),sizeof(TCheckedUid),sizeof(TCheckedUid));
TInt r=TheFs.ReadFileSection(_L("\\F32-TST\\UIDCHK.BLG"),0,uidPtr,sizeof(TCheckedUid));
test_KErrNone(r);
TCheckedUid uid(uidBuf);
TUidType uidType=uid.UidType();
test(uidType.IsValid());
test(uidType[0]==TUid::Uid('U') && uidType[1]==TUid::Uid('I') && uidType[2]==TUid::Uid('D'));
r=TheFs.ReadFileSection(_L("\\F32-TST\\UIDCHK.MSG"),0,uidBuf,sizeof(TCheckedUid));
test_KErrNone(r);
uid.Set(uidBuf);
uidType=uid.UidType();
test(uidType.IsValid());
test(uidType[0]==TUid::Uid('X') && uidType[1]==TUid::Uid('Y') && uidType[2]==TUid::Uid('Z'));
// Test for Null File length
TBuf8<256> testDesN;
test.Next(_L("Check for null file name"));
r=TheFs.ReadFileSection(_L(""),0,testDesN,26);
test_Value(r, r == KErrBadName);
// Check the lentgh of descriptor.
TInt x = testDesN.Length();
test ( x == 0);
test.Next(_L("Check for non existing file"));
r=TheFs.ReadFileSection(_L("sdfsd.dfg"),0,testDesN,26);
test.Printf(_L("Return %d"),r);
test_Value(r, (r == KErrNotFound) || (r == KErrPathNotFound));
// Check the lentgh of descriptor.
x = testDesN.Length();
test ( x == 0);
r=TheFs.ReadFileSection(_L("\\F32-TST\\UIDCHK.DAT"),0,uidBuf,sizeof(TCheckedUid));
test_KErrNone(r);
uid.Set(uidBuf);
uidType=uid.UidType();
test(uidType.IsValid());
test(uidType[0]==TUid::Uid('D') && uidType[1]==TUid::Uid('A') && uidType[2]==TUid::Uid('T'));
}
static void CreateManyLargFiles(TInt aNumber)
//
// Make a directory with aNumber entries
//
{
RFile64 f;
TInt maxEntry=aNumber;
test.Printf(_L("Create a directory with %d entries\n"),aNumber);
TFileName sessionPath;
TInt r=TheFs.SessionPath(sessionPath);
test_KErrNone(r);
r=TheFs.MkDir(_L("\\F32-TST\\"));
test((r==KErrNone)||(r==KErrAlreadyExists));
r=TheFs.MkDir(_L("\\F32-TST\\BENCH_DELETE\\"));
test((r==KErrNone)||(r==KErrAlreadyExists));
TBuf8<8> WriteData =_L8("Wibbleuy");
for (TInt i=0; i<maxEntry; i++)
{
TFileName baseName=_L("\\F32-TST\\BENCH_DELETE\\FILE");
baseName.AppendNum(i);
r=f.Replace(TheFs,baseName,EFileWrite);
test_KErrNone(r);
r = f.SetSize(K3GB);
test_KErrNone(r);
r=f.Write((K3GB-30),WriteData);
test_KErrNone(r);
f.Flush();
f.Close();
}
test.Printf(_L("Test all entries have been created successfully\n"));
TBuf8<8> ReadData;
TInt64 Size=0;
for (TInt j=0; j<=maxEntry; j++)
{
TFileName baseName=_L("\\F32-TST\\BENCH_DELETE\\FILE");
baseName.AppendNum(j);
TInt r=f.Open(TheFs,baseName,EFileRead);
if (r!=KErrNone)
{
test_Value(r, r == KErrNotFound && j==maxEntry);
return;
}
ReadData.FillZ();
r=f.Read((K3GB-30),ReadData);
test_KErrNone(r);
test(f.Size(Size)==KErrNone);
test(K3GB == Size);
test(ReadData==WriteData);
f.Close();
}
}
TInt E32Main()
{
test.Title();
test.Start(_L("Test thrashing monitor"));
test_KErrNone(InitBenchmarks());
TInt actions = ParseCommandLine();
test_KErrNone(GetGlobalPolicies());
TUint cacheOriginalMin = 0;
TUint cacheOriginalMax = 0;
if (gDataPagingSupported)
{
test.Next(_L("Thrash test: change cache size to maximum 2Mb"));
TUint cacheCurrentSize = 0;
DPTest::CacheSize(cacheOriginalMin, cacheOriginalMax, cacheCurrentSize);
gMinCacheSize = 512;
gMaxCacheSize = 520;
test_KErrNone(DPTest::SetCacheSize(gMinCacheSize * gPageSize, gMaxCacheSize * gPageSize));
}
if (actions & EActionTest)
{
TBool flexibleMemoryModel = (MemModelAttributes() & EMemModelTypeMask) == EMemModelTypeFlexible;
if (flexibleMemoryModel)
TestThrashHal();
else
TestThrashHalNotSupported();
}
if (actions & EActionThrashing)
{
test.Next(_L("Extended thrashing tests"));
TestThrashing();
}
if (actions & EActionBenchmarks)
{
test.Next(_L("Benchmarking page replacement"));
TestDistributions();
BenchmarkReplacement();
}
if (gDataPagingSupported)
{
test.Next(_L("Thrash test: Reset cache size to normal"));
test_KErrNone(DPTest::SetCacheSize(cacheOriginalMin, cacheOriginalMax));
}
test.End();
return 0;
}
void static ClearSessionDirectory()
//
// Delete the contents of F32-TST
//
{
TParse sessionPath;
TInt r=TheFs.Parse(_L("\\F32-TST\\"),_L(""),sessionPath);
test_KErrNone(r);
RecursiveRmDir(sessionPath.FullName());
r=TheFs.MkDir(sessionPath.FullName());
test_KErrNone(r);
}
LOCAL_C void SeekToCluster(RFile& aFile,TInt aCluster1,TInt aCluster2)
//
// Seek to aCluster and check it is found correctly
//
{
TBuf8<508> seekBuf(508);
TInt r=aFile.Read(aCluster1*testBuf.MaxSize(),seekBuf);
test_KErrNone(r);
test(seekBuf[0]==(TUint8)aCluster1 && seekBuf[507]==(TUint8)aCluster1);
r=aFile.Read(aCluster2*testBuf.MaxSize(),seekBuf);
test_KErrNone(r);
test(seekBuf[0]==(TUint8)aCluster2 && seekBuf[507]==(TUint8)aCluster2);
}
void BenchmarkReplacement()
{
// Report block write and physical access settings
test.Next(_L("Report media physical access and preferred write size settings"));
TInt physAccessSupported = UserSvr::HalFunction(EHalGroupVM, EVMHalGetPhysicalAccessSupported, 0, 0);
test(physAccessSupported == 0 || physAccessSupported == 1);
if (physAccessSupported)
test.Printf(_L("Physical access supported\n"));
else
test.Printf(_L("Physical access not supported\n"));
TInt preferredWriteSize = UserSvr::HalFunction(EHalGroupVM, EVMHalGetPreferredDataWriteSize, 0, 0);
test(preferredWriteSize >= 0);
test.Printf(_L("Preferred write size %d pages\n"), 1 << preferredWriteSize);
for (TInt physAccess = 0 ; physAccess <= physAccessSupported ; ++physAccess)
{
test_KErrNone(UserSvr::HalFunction(EHalGroupVM, EVMHalSetUsePhysicalAccess, (TAny*)physAccess, 0));
test_Equal(physAccess, UserSvr::HalFunction(EHalGroupVM, EVMHalGetUsePhysicalAccess, 0, 0));
TInt writeSize = 0;
for (;;)
{
test_KErrNone(UserSvr::HalFunction(EHalGroupVM, EVMHalSetDataWriteSize, (TAny*)writeSize, 0));
TInt writeSizeSet = UserSvr::HalFunction(EHalGroupVM, EVMHalGetDataWriteSize, 0, 0);
test (writeSizeSet >= 0);
if (writeSizeSet != writeSize)
break; // stop loop when we reach limit of supported write size
TBuf<128> title;
title.AppendFormat(_L("Thrash test: single thread, normal random workload 2, phys access %d, write size %dKB"),
physAccess, 1 << (writeSize - 2));
ThrashTest(title, 1, ETrue, EWorkloadNormalRandom2, (2 * gMaxCacheSize) / 3, 2 * gMaxCacheSize, 0);
++writeSize;
}
}
test_KErrNone(UserSvr::HalFunction(EHalGroupVM, EVMHalSetUsePhysicalAccess, (TAny*)physAccessSupported, 0));
test_Equal(physAccessSupported, UserSvr::HalFunction(EHalGroupVM, EVMHalGetUsePhysicalAccess, 0, 0));
test_KErrNone(UserSvr::HalFunction(EHalGroupVM, EVMHalSetDataWriteSize, (TAny*)preferredWriteSize, 0));
test_Equal(preferredWriteSize, UserSvr::HalFunction(EHalGroupVM, EVMHalGetDataWriteSize, 0, 0));
ThrashTest(_L("Thrash test: single thread, normal random workload 1"),
1, ETrue, EWorkloadNormalRandom1, (2 * gMaxCacheSize) / 3, 2 * gMaxCacheSize, 0);
ThrashTest(_L("Thrash test: single thread, normal random workload 2"),
1, ETrue, EWorkloadNormalRandom2, (2 * gMaxCacheSize) / 3, 2 * gMaxCacheSize, 0);
ThrashTest(_L("Thrash test: single thread, uniform random workload"),
1, ETrue, EWorkloadUniformRandom, (2 * gMinCacheSize) / 3, (3 * gMaxCacheSize) / 2, 0);
}
void CreateTestDirectory(const TDesC& aSessionPath)
//
// Create directory for test
//
{
TParsePtrC path(aSessionPath);
test(path.DrivePresent()==EFalse);
TInt r=TheFs.SetSessionPath(aSessionPath);
test_KErrNone(r);
r=TheFs.SessionPath(gSessionPath);
test_KErrNone(r);
r=TheFs.MkDirAll(gSessionPath);
test_Value(r, r == KErrNone || r==KErrAlreadyExists);
}
static void TestFileReadCPU(TBool aMisalignedReadWrites = EFalse)
//
// Benchmark CPU utilisation for Read method
//
{
ClearSessionDirectory();
test.Next(_L("Benchmark Read method CPU Utilisation"));
test.Printf(_L("MisalignedReadWrites %d\n"), aMisalignedReadWrites);
TInt misalignedOffset = aMisalignedReadWrites ? 1 : 0;
// Create test data
test.Printf(_L("Creating test file..."));
DataBuf.SetLength(KMaxFileSize);
TInt r = File.Create(TheFs, _L("READCPUTEST"), EFileStream | EFileWriteDirectIO);
test_KErrNone(r);
File.Write(DataBuf);
test.Printf(_L("done\n"));
File.Close();
DoTestFileReadCPU(1+misalignedOffset);
DoTestFileReadCPU(2+misalignedOffset);
DoTestFileReadCPU(4+misalignedOffset);
DoTestFileReadCPU(8+misalignedOffset);
DoTestFileReadCPU(16+misalignedOffset);
DoTestFileReadCPU(32+misalignedOffset);
DoTestFileReadCPU(64+misalignedOffset);
DoTestFileReadCPU(128+misalignedOffset);
DoTestFileReadCPU(256+misalignedOffset);
DoTestFileReadCPU(512+misalignedOffset);
DoTestFileReadCPU(1024+misalignedOffset);
DoTestFileReadCPU(2 * 1024+misalignedOffset);
DoTestFileReadCPU(4 * 1024+misalignedOffset);
DoTestFileReadCPU(8 * 1024+misalignedOffset);
DoTestFileReadCPU(16 * 1024+misalignedOffset);
DoTestFileReadCPU(32 * 1024+misalignedOffset);
DoTestFileReadCPU(64 * 1024+misalignedOffset);
DoTestFileReadCPU(128 * 1024+misalignedOffset);
DoTestFileReadCPU(256 * 1024+misalignedOffset);
#ifndef __WINS__ // Block sizes are too large for the emulator
DoTestFileReadCPU(512 * 1024+misalignedOffset);
DoTestFileReadCPU(K1M+misalignedOffset);
#endif
r = TheFs.Delete(_L("READCPUTEST"));
test_KErrNone(r);
}
LOCAL_C void resourceRFiletest()
//
//
//
{
//RFile testing with session path set to //resource//
r=TheFs.SetSessionPath(restestname);
test_KErrNone(r);
r=file1.Temp(TheFs,restestname,fromTemp,EFileWrite);
test_Value(r, r == KErrPermissionDenied);
file1.Close();
r=file1.Create(TheFs,KFileRes,EFileWrite);
test_Value(r, r == KErrPermissionDenied);
file1.Close();
r=file1.Open(TheFs,KFileRes,EFileWrite);
test_Value(r, r == KErrPermissionDenied);
file1.Close();
r=file1.Open(TheFs,KFileRes,EFileRead|EFileShareReadersOnly);
test_Value(r, r == KErrNone || r==KErrPathNotFound);
file1.Close();
r=file1.Open(TheFs,KFileRes,EFileShareReadersOrWriters|EFileRead);
test_Value(r, r == KErrNone || r==KErrPathNotFound);
file1.Close();
r=file1.Open(TheFs,KFileRes,EFileShareReadersOrWriters|EFileWrite);
test_Value(r, r == KErrPermissionDenied);
file1.Close();
r=file1.Open(TheFs,KFileRes,EFileShareReadersOnly);
test_KErrNone(r);
r=file1.ChangeMode(EFileShareExclusive);
test_KErrNone(r);
//this operation is prevented as you can not open a file for write access in the resource directory
r=file1.Rename(KFileRes3);
test_Value(r, r == KErrPermissionDenied || r==KErrAccessDenied);
file1.Close();
r=file1.Replace(TheFs,KFileRes,EFileWrite);
test_Value(r, r == KErrPermissionDenied);
file1.Close();
}
void StartThreads( TUint aNumThreads, RThread* aThreads, TRequestStatus* aStatus,
TThreadFunction aThreadFunc, SPinThreadArgs& aThreadArgs)
{
for (TUint i = 0; i < aNumThreads; i++)
{
test_KErrNone(aThreads[i].Create(KNullDesC, aThreadFunc, KDefaultStackSize, NULL, &aThreadArgs));
aThreads[i].Logon(aStatus[i]);
TRequestStatus threadInitialised;
aThreads[i].Rendezvous(threadInitialised);
aThreads[i].Resume();
_T_PRINTF(_L("wait for child\n"));
User::WaitForRequest(threadInitialised);
test_KErrNone(threadInitialised.Int());
}
}
void FragmentMemoryFunc()
{
ChunkCommitEnd = 0;
TInt r;
while(KErrNone == (r = Chunk.Commit(ChunkCommitEnd,PageSize)) && !FragThreadStop)
{
ChunkCommitEnd += PageSize;
}
if (FragThreadStop)
return;
test_Equal(KErrNoMemory, r);
TUint freeBlocks = 0;
for ( TUint offset = 0;
(offset + FragData.iSize) < ChunkCommitEnd;
offset += FragData.iFrequency, freeBlocks++)
{
test_KErrNone(Chunk.Decommit(offset, FragData.iSize));
}
if (FragData.iDiscard && CacheSizeAdjustable && !FragThreadStop)
{
TUint minCacheSize = FreeRam();
TUint maxCacheSize = minCacheSize;
DPTest::SetCacheSize(minCacheSize, maxCacheSize);
if (OrigMinCacheSize <= maxCacheSize)
DPTest::SetCacheSize(OrigMinCacheSize, maxCacheSize);
}
}
//
// Thread to run the server code
//
TInt ServerThread(TAny*)
{
RTest test(_L("T_SCHEDRACE server"));
test.Title();
// UserSvr::FsRegisterThread();
test.Start(_L("Create and install ActiveScheduler"));
CActiveScheduler* pScheduler = new CActiveScheduler;
test_NotNull(pScheduler);
CActiveScheduler::Install(pScheduler);
test.Next(_L("Creating and starting Server"));
CTestServer* pServer = new CTestServer(&test);
test_NotNull(pServer);
test_KErrNone(pServer->Start(KServerName)); // Starting a CServer2 also Adds it to the ActiveScheduler
test.Next(_L("Rendezvous with main thread, then Start ActiveScheduler"));
RThread self;
self.Rendezvous(KErrNone);
test.Printf(_L(" There might be something going on beneath this window\n"));
CActiveScheduler::Start();
// This code is not reached until the active scheduler exits.
test.Next(_L("Destroy Server and ActiveScheduler"));
delete pServer;
delete pScheduler;
test.Close();
return (KErrNone);
}
TInt RunCodeThread(TAny* aParam)
{
TInt64 seed = Math::Random()*Math::Random();
SPinThreadArgs* args = (SPinThreadArgs*)aParam;
test_KErrNone(User::SetRealtimeState(args->iRealtimeState));
// Ensure the the parentThread has moved the page at least once
// before we start accessing it.
TRequestStatus status;
args->iParentThread.Rendezvous(status);
RThread::Rendezvous(KErrNone);
_R_PRINTF("wait for parent");
User::WaitForRequest(status);
_R_PRINTF("acesssing page");
FOREVER
{
TInt r = args->iTestFunc();
if (r != KArbitraryNumber)
return KErrGeneral;
Reschedule(seed);
if (ThreadDie)
break;
}
return KErrNone;
}
