自学教程：C++ test_KErrNone函数代码示例

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 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;	}

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);	}

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);}

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;	}