MCL/sf/os/kernelhwsrv: comparison kerneltest/f32test/server/t

equal deleted inserted replaced

-:c1f20ce4abcf
+:3e88ff8f41d5
 #include <e32svr.h>
 #include <f32dbg.h>
 #include "t_server.h"
 #include <e32twin.h>
 #include <e32rom.h>
-#include <u32hal.h>
 //----------------------------------------------------------------------------------------------
 //! @SYMTestCaseID      PBASE-T_FILECACHE-0189
 //! @SYMTestType        UT
 	}
 void PrintFileCacheConfig(TFileCacheConfig& aFileCacheConfig, TBool aDisplay = ETrue)
 	{
 	TInt r = controlIo(TheFs,gDrive, KControlIoFileCacheConfig, aFileCacheConfig);
-	test_KErrNone(r);
+	test (r == KErrNone);
 	if (!aDisplay)
 		return;
 	test.Printf(_L("File cache:\nDrive %c\nFlags %08X\nFileCacheReadAsync %d\nFairSchedulingLen %d\nCacheSize %d\nMaxReadAheadLen %d\nClosedFileKeepAliveTime %d\nDirtyDataFlushTime %d"),
 		aFileCacheConfig.iDrive + 'A',
 				TestBufferFail(aBuffer, pos, aLength);
 			}
 		}
 	}
-TInt FreeRam()
-	{
-	// wait for any async cleanup in the supervisor to finish first...
-	UserSvr::HalFunction(EHalGroupKernel, EKernelHalSupervisorBarrier, 0, 0);
-	TMemoryInfoV1Buf meminfo;
-	UserHal::MemoryInfo(meminfo);
-	return meminfo().iFreeRamInBytes;
-	}
-void LowMemoryTest()
-	{
-	TInt fileSize = 0;
-	const TInt KWriteLen = 128*1024;
-	test.Next(_L("Test appending to a file with low memory"));
-	gBufPtr.SetLength(KBufSize);
-	RFile f;
-	TFileName testFile   = _L("TEST.BIN");
-	TInt r = f.Replace(TheFs, testFile, EFileWrite | EFileWriteBuffered);
-	test_KErrNone(r);
-	TInt pos = 0;
-	TPtrC8 writePtr;
-	writePtr.Set(gBufPtr.MidTPtr(pos, KWriteLen));
-	r = f.Write(pos, writePtr);
-	test_KErrNone(r);
-	pos+= writePtr.Length();
-	r = f.Size(fileSize);
-	test_KErrNone(r);
-	test_Equal(fileSize,pos);
-	TUint freeRam = FreeRam();
-	const TInt KPageSize=4096;
-	freeRam = (freeRam + KPageSize -1) & ~(KPageSize-1);
-	test.Printf(_L("FreeRam = %d"), freeRam);
-	RChunk chunk;
-	TChunkCreateInfo chunkInfo;
-	chunkInfo.SetDisconnected(0, 0, freeRam);
-	chunkInfo.SetPaging(TChunkCreateInfo::EUnpaged);
-	test_KErrNone(chunk.Create(chunkInfo));
-	test.Printf(_L("Gobbling all of memory..."));
-	TUint commitEnd;
-	for (commitEnd = 0; commitEnd < freeRam; commitEnd += KPageSize)
-		{
-		r = chunk.Commit(commitEnd,KPageSize);
-		if (r != KErrNone)
-			break;
-		}
-	test.Printf(_L("commitEnd %d, r %d"), commitEnd, r);
-	test_Value(r, r == KErrNoMemory || r == KErrNone);
-	test.Printf(_L("FreeRam = %d"), FreeRam());
-	pos-= KSegmentSize;
-	writePtr.Set(gBufPtr.MidTPtr(pos, KWriteLen));
-	test.Printf(_L("Writing to file..."));
-	// now we have gobbled all or most of memory, the next write can fail
-	// if it does keep decommitting memory until it succeeds and then test that the file size is correct
-	commitEnd = 0;
-	do {
-		r = f.Write(pos, writePtr);
-		test_Value(r, r == KErrNoMemory || r == KErrNone);
-		if (r == KErrNoMemory)
-			{
-			chunk.Decommit(commitEnd,KPageSize);
-			commitEnd += KPageSize;
-			}
-		}
-	while (r == KErrNoMemory);
-	pos+= writePtr.Length();
-	test.Printf(_L("Gsetting size of file ..."));
-	r = f.Size(fileSize);
-	test_KErrNone(r);
-	test_Equal(fileSize,pos);
-	test.Printf(_L("Closing file ..."));
-	f.Close();
-	test.Printf(_L("Closing chunk ..."));
-	chunk.Close();
-	test.Printf(_L("FreeRam = %d"), FreeRam());
-	}
 LOCAL_C void UnitTests()
 //
 // Test read file handling.
 //
 #if defined(_DEBUG) || defined(_DEBUG_RELEASE)
 	TBool simulatelockFailureMode;
 	TFileCacheStats fileCacheStats;
 	r = controlIo(TheFs, gDrive, KControlIoFileCacheStats, fileCacheStats);
-	test_KErrNone(r);
+	test (r == KErrNone);
 	test.Printf(_L("Number of files on closed queue=%d\n"),fileCacheStats.iFilesOnClosedQueue);
 	test(fileCacheStats.iFilesOnClosedQueue == 0);
 #endif
 #if defined(_DEBUG) || defined(_DEBUG_RELEASE)
 	// turn OFF lock failure mode
 	simulatelockFailureMode = EFalse;
 	r = controlIo(TheFs, gDrive, KControlIoSimulateLockFailureMode, simulatelockFailureMode);
-	test_KErrNone(r);
+	test (r == KErrNone);
 #endif
 	TFileName testFile   = _L("TEST.BIN");
 	//**********************************
 #if defined(_DEBUG) || defined(_DEBUG_RELEASE)
 	TInt uncachedBytesRead;
 	TInt uncachedPacketsRead;
 #endif
-	LowMemoryTest();
 	// create an empty file, so that any writes overlapping segemt boundaries
 	// need a read first
 	// create a test file using directIO and then re-open it in buffered mode,
 	// so that any writes overlapping segemt boundaries need a read first
 	r = f.Replace(TheFs, testFile, EFileWrite | EFileWriteDirectIO);
 	test.Printf(_L("Flushing close queue to empty cache...\n"));
 	r = TheFs.ControlIo(gDrive, KControlIoFlushClosedFiles);
 	test_KErrNone(r);
 	r = f.Replace(TheFs, testFile, EFileReadBuffered | EFileWrite | EFileWriteBuffered);
-	test_KErrNone(r);
-	r = f.SetSize(gFileCacheConfig.iCacheSize);
 	test_KErrNone(r);
 	RTimer timer;
 	timer.CreateLocal();
 	TRequestStatus reqStat;
 	r = f.Open(TheFs, testFile, EFileRead | EFileReadBuffered | EFileWrite);
 	test_KErrNone(r);
 	TInt size;
 	r = f.Size(size);
-	test_KErrNone(r);
+	test (r == KErrNone);
 	test (size = KBufSize);
 	readPtr.Set(gBuf->Des());
 #if defined(_DEBUG) || defined(_DEBUG_RELEASE)
 	// Allocate full cachelines - so we can enable hole testing
 	TBool allocateAllSegmentsInCacheLine = ETrue;
 	r = controlIo(TheFs, gDrive, KControlIoAllocateMaxSegments, allocateAllSegmentsInCacheLine);
-	test_KErrNone(r);
+	test (r == KErrNone);
 	PrintFileCacheStats(fileCacheStats, EFalse);
 	TInt holesDetected = fileCacheStats.iHoleCount;
 	TInt lockFailures = fileCacheStats.iCommitFailureCount + fileCacheStats.iLockFailureCount;
 #endif
 		test(fileCacheStats.iHoleCount > holesDetected);
 		}
 	// Don't allocate full cachelines any more
 	allocateAllSegmentsInCacheLine = EFalse;
 	r = controlIo(TheFs, gDrive, KControlIoAllocateMaxSegments, allocateAllSegmentsInCacheLine);
-	test_KErrNone(r);
+	test (r == KErrNone);
 #endif
 	gBufPtr.FillZ();
 	f.Close();
 #if defined(_DEBUG) || defined(_DEBUG_RELEASE)
 	r = controlIo(TheFs, gDrive, KControlIoFileCacheStats, fileCacheStats);
-	test_KErrNone(r);
+	test (r == KErrNone);
 	test.Printf(_L("Number of files on closed queue=%d\n"),fileCacheStats.iFilesOnClosedQueue);
 	test(fileCacheStats.iFilesOnClosedQueue == 1);
 #endif
 	//
 		TestBuffer(gBufPtr, pos, len);
 		test_KErrNone(r);
 #if defined(_DEBUG) || defined(_DEBUG_RELEASE)
 		r = controlIo(TheFs, gDrive, KControlIoFileCacheStats, fileCacheStats);
-		test_KErrNone(r);
+		test (r == KErrNone);
 		test.Printf(_L("Number of files on closed queue=%d\n"),fileCacheStats.iFilesOnClosedQueue);
 		test(fileCacheStats.iFilesOnClosedQueue == 0);
 #endif
 		f.Close();
 		test.Next(_L("close & verify file is back on close queue"));
 #if defined(_DEBUG) || defined(_DEBUG_RELEASE)
 		r = controlIo(TheFs, gDrive, KControlIoFileCacheStats, fileCacheStats);
-		test_KErrNone(r);
+		test (r == KErrNone);
 		test.Printf(_L("Number of files on closed queue=%d\n"),fileCacheStats.iFilesOnClosedQueue);
 		test(fileCacheStats.iFilesOnClosedQueue == 1);
 #endif
 		if (testNum == ETestCloseQueueEmptyAfterDelete)
 			f.Close();
 			}
 	#if defined(_DEBUG) || defined(_DEBUG_RELEASE)
 		r = controlIo(TheFs, gDrive, KControlIoFileCacheStats, fileCacheStats);
-		test_KErrNone(r);
+		test (r == KErrNone);
 		test.Printf(_L("Number of files on closed queue=%d\n"),fileCacheStats.iFilesOnClosedQueue);
 		test(fileCacheStats.iFilesOnClosedQueue == 0);
 	#endif
 		}
 #if defined(_DEBUG) || defined(_DEBUG_RELEASE)
 	// turn lock failure mode back ON (if enabled)
 	simulatelockFailureMode = ETrue;
 	r = controlIo(TheFs, gDrive, KControlIoSimulateLockFailureMode, simulatelockFailureMode);
-	test_KErrNone(r);
+	test (r == KErrNone);
 #endif
 	//**************************************************************
 	// Test opening a file with a silly open mode flags combinations
 	//**************************************************************
 	const TInt KWriteLen = KSegmentSize+1;
 	writePtr.Set(gBuf->Des().Ptr(), KWriteLen);
 #if defined(_DEBUG) || defined(_DEBUG_RELEASE)
 	r = controlIo(TheFs, gDrive, KControlIoFileCacheStats, fileCacheStats);
-	test_KErrNone(r);
+	test (r == KErrNone);
 	test.Printf(_L("Number of Write-throughs with dirty data=%d\n"),fileCacheStats.iWriteThroughWithDirtyDataCount);
 	TInt writeThroughWithDirtyDataCountOld = fileCacheStats.iWriteThroughWithDirtyDataCount;
 	TInt writeThroughWithDirtyDataCountNew = writeThroughWithDirtyDataCountOld;
 #endif
 	TInt fileSize = 0;
 	for (TInt i=0; i<4; i++)
 		{
 		fileSize = 0;
 		r = f.SetSize(fileSize);
-		test_KErrNone(r);
+		test (r == KErrNone);
 		for (pos = 0; pos < KMaxFileSize; )
 			{
 			r = f.Write(pos, writePtr);
 			if (r != KErrNone)
 				{
 				test.Printf(_L("Iter #%d, write pos %d size %d, Write() returned %d"), i, pos, fileSize, r);
 				r = f.Flush();
 				test.Printf(_L("Flush returned %d"), r);
 				test(0);
 				}
-			test_KErrNone(r);
+			test(r == KErrNone);
 			pos+= writePtr.Length();
 			r = f.Size(fileSize);
-			test_KErrNone(r);
+			test (r == KErrNone);
 			if (fileSize != pos)
 				{
 				test.Printf(_L("Iter #%d, write pos %d != size %d"), i, pos, fileSize);
 				r = f.Flush();
 				test.Printf(_L("Flush returned %d"), r);
 				}
 			test (fileSize == pos);
 #if defined(_DEBUG) || defined(_DEBUG_RELEASE)
 			r = controlIo(TheFs, gDrive, KControlIoFileCacheStats, fileCacheStats);
-			test_KErrNone(r);
+			test (r == KErrNone);
 			writeThroughWithDirtyDataCountNew = fileCacheStats.iWriteThroughWithDirtyDataCount;
 			if (writeThroughWithDirtyDataCountNew > writeThroughWithDirtyDataCountOld)
 				{
 				test.Printf(_L("Iter #%d, write pos %d size %d"), i, pos, fileSize);
 				test.Printf(_L("Number of Write-throughs with dirty data=%d\n"),fileCacheStats.iWriteThroughWithDirtyDataCount);
 	TDesC& fileName = *(TDesC*) aFileName;
 	RFs fs;
 	TInt r = fs.Connect();
-	test_KErrNone(r);
+	test (r==KErrNone);
 	r = fs.SetSessionPath(gSessionPath);
-	test_KErrNone(r);
+	test (r==KErrNone);
 	RFile file;
 	r = file.Open(fs, fileName, EFileRead | EFileReadBuffered | EFileShareReadersOrWriters);
 	test_KErrNone(r);
 	TInt maxWriteCount=KMaxFileSize/aWriteBlockSize;
 	TInt loopCount=0;
 	RFile file;
 	TInt r = file.Replace(TheFs,_L("WRITETST"),EFileStream | aFileMode);
-	test_KErrNone(r);
+	test (r == KErrNone);
 	TTime startTime;
 	TTime endTime;
 	RTimer timer;
 	{
 	TestsInit();
 	TVolumeInfo volInfo;
 	TInt r = TheFs.Volume(volInfo, gDrive);
-	test_KErrNone(r);
+	test (r == KErrNone);
 	TFullName extName;
 	r = TheFs.ExtensionName(extName,gDrive, 0);
 	if (r == KErrNone)
 		{
 		{
 #if defined(_DEBUG) || defined(_DEBUG_RELEASE)
 		// turn OFF lock failure mode
 		TBool simulatelockFailureMode = EFalse;
 		r = controlIo(TheFs, gDrive, KControlIoSimulateLockFailureMode, simulatelockFailureMode);
-		test_KErrNone(r);
+		test (r == KErrNone);
 #endif
 		TestFileRead(EFileReadDirectIO);
 		if (gDriveCacheFlags & (EFileCacheReadEnabled | EFileCacheReadOn))
 			{
 #if defined(_DEBUG) || defined(_DEBUG_RELEASE)
 		// turn lock failure mode back ON (if enabled)
 		simulatelockFailureMode = ETrue;
 		r = controlIo(TheFs, gDrive, KControlIoSimulateLockFailureMode, simulatelockFailureMode);
-		test_KErrNone(r);
+		test (r == KErrNone);
 #endif
 		}	// if (gRunPerformanceTests)
 	TestsEnd();
 	}
 	if (gWriteCacheFlags)
 		{
 		test.Printf(_L("Writing DriveCacheFlags for drive %C = %08X\n"), (TInt) gDriveToTest, gDriveCacheFlags);
 		r = controlIo(TheFs,gDrive, KControlIoFileCacheFlagsWrite, gDriveCacheFlags);
-		test_KErrNone(r);
+		test (r == KErrNone);
 		}
 #endif
 	if (gRunTests)
 		{

branch	RCL_3
changeset 44	3e88ff8f41d5
parent 43	c1f20ce4abcf