--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/kerneltest/f32test/demandpaging/t_denyclamp.cpp	Mon Oct 19 15:55:17 2009 +0100
@@ -0,0 +1,356 @@
+// Copyright (c) 2006-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\demandpaging\t_denyclamp.cpp
+// This test suite has a reduced set of the tests in T_CLAMP, to verify
+// the behaviour when file clamping is attempted by an invalid user.
+// 002 GetDriveLetters() Assign the first drive that matches the required criteria
+// 003 Test1() Basic clamp operation
+// 004 Test2() Invalid clamp requests
+// 005 Test4() Clamp tests for non-writable file system
+// 006 Test5() Clamp requests on non-clamping file systems
+// This file has a reduced set of tests present in T_CLAMP, to verify
+// the behaviour when file clamping is attempted by an invalid user
+// 
+//
+
+//! @SYMTestCaseID			KBASE-T_DENYCLAMP-0329
+//! @SYMTestType			UT
+//! @SYMPREQ				PREQ1110
+//! @SYMTestCaseDesc		Demand Paging File Clamp tests (Deny)
+//! @SYMTestActions			001 Starting T_DENYCLAMP ...
+//! @SYMTestExpectedResults All tests should pass.
+//! @SYMTestPriority        High
+//! @SYMTestStatus          Implemented
+
+#include <e32test.h>
+RTest test(_L("T_DENYCLAMP"));
+
+#if defined(_DEBUG) || defined(_DEBUG_RELEASE)
+
+#include <f32file.h>
+#include <f32dbg.h>
+RFs TheFs;
+
+_LIT(KFATName,"FAT");
+//_LIT(KFAT32Name,"FAT32");
+_LIT(KROFSName,"ROFS");
+_LIT(KLFFSName,"LFFS");
+_LIT(KCOMPName,"COMPOSITE"); // Z: name if Composite File System
+//#ifdef __WINS__
+//_LIT(KROMName,"WIN32");	// Clamping is not supported for non-composite filing system on Z:
+//#else
+_LIT(KROMName,"ROM");		 // Z: name if ROMFS (on hardware, not emulator)
+//#endif
+
+TChar NandFatDrv='?';
+TChar RofsDrv='?';
+TChar LffsDrv='?';
+TChar CompDrv='?';
+
+
+LOCAL_C void Test1()
+	{
+// Basic clamp operation
+	test.Next(_L("T_DENYCLAMP - Test1()"));
+
+	TBuf<256> fileName;	
+	TBuf<256> buf(_L("buffer for file used"));
+
+	fileName = _L("clampFile.tst");
+	RFile testFile;
+	TInt r=testFile.Replace(TheFs,fileName,EFileWrite);
+	test(r==KErrNone);
+	TPtrC8 pBuf((TUint8*)&buf);
+	testFile.Write(pBuf);
+	testFile.Flush();
+
+	// Attempt to clamp file should be rejected
+	RFileClamp handle;
+	r=handle.Clamp(testFile);
+	test(r==KErrPermissionDenied);
+
+	// Attempt to unclamp a file should be rejected
+	// Using an invalid-content cookie is OK - the request should
+	// be rejected before the content is examined
+	handle.iCookie[0]=MAKE_TINT64(-1,-1);
+	handle.iCookie[1]=0;
+	r=handle.Close(TheFs);
+	test (r==KErrPermissionDenied);
+
+	// Tidy up
+	testFile.Close();
+	r=TheFs.Delete(_L("clampFile.tst"));
+	test (r==KErrNone);
+	}
+
+
+LOCAL_C void Test2()
+	{
+// Invalid clamp requests
+	test.Next(_L("T_DENYCLAMP - Test2()"));
+	
+	// Test attempt to clamp empty file is rejected
+	RFileClamp handle2;
+	TBuf<256> file2Name;	
+	file2Name = _L("clampFile2.tst");
+	RFile testFile2;
+	TInt r=testFile2.Replace(TheFs,file2Name,EFileWrite);
+	test(r==KErrNone);
+	r=handle2.Clamp(testFile2);
+	test(r==KErrPermissionDenied);
+
+
+	// Try to unclamp non-existant file
+	// Using a invalid-content cookie is OK - the request should
+	// be rejected before the content is examined
+	handle2.iCookie[0] = MAKE_TINT64(-1,-1); // iCookie[0] holds the unique ID
+	handle2.iCookie[1] = MAKE_TINT64(-1,-1);
+	r=handle2.Close(TheFs);
+	test (r==KErrPermissionDenied);
+
+	// Tidy up
+	testFile2.Close();
+	r=TheFs.Delete(_L("clampFile2.tst"));
+	test (r==KErrNone);
+	}
+
+
+LOCAL_C void Test4(TDesC& aRoot)
+	{
+// Clamp tests for non-writable file system
+	test.Next(_L("T_DENYCLAMP - Test4()"));
+
+	TBuf<256> pathName;	
+#ifdef __WINS__
+	if((aRoot[0]=='Z')||(aRoot[0]=='z'))
+		pathName=_L("clean.txt");
+	else
+		pathName=_L("root.txt");
+#else
+	if((aRoot[0]=='Z')||(aRoot[0]=='z'))
+		pathName=_L("UnicodeData.txt");
+	else
+		pathName=_L("\\Test\\clamp.txt");	// For (non-composite) ROFS drive
+#endif
+	RFile testFile;
+	TInt r=testFile.Open(TheFs, pathName, EFileRead);
+	test(r==KErrNone);
+
+	// Attempt to clamp file
+	RFileClamp handle;
+	r=handle.Clamp(testFile);
+	test(r==KErrPermissionDenied);
+
+	// Unclamp file
+	// Using an invalid-content cookie is OK - the request should
+	// be rejected before the content is examined
+	handle.iCookie[0]=MAKE_TINT64(-1,-1);
+	handle.iCookie[1]=0;
+	r=handle.Close(TheFs);
+	test (r==KErrPermissionDenied);
+
+	testFile.Close();
+	}
+
+
+LOCAL_C void Test5()
+	{
+// Clamp requests on non-clamping file systems
+	test.Next(_L("T_DENYCLAMP - Test5()"));
+
+	TBuf<256> unsuppFile;	
+	unsuppFile = _L("unsuppFile.tst");
+	RFile testFile;
+	TInt r=testFile.Replace(TheFs,unsuppFile,EFileWrite);
+	test(r==KErrNone);
+
+	// Try to clamp a file on a file system that does
+	// not support clamping
+	RFileClamp handle;
+	r=handle.Clamp(testFile);
+	test(r==KErrPermissionDenied);
+
+	// Tidy up
+	testFile.Close();
+	r=TheFs.Delete(_L("unsuppFile.tst"));
+	test (r==KErrNone);
+	}	
+
+
+LOCAL_C void GetDriveLetters()
+	{
+// Assign the first drive that matches the required criteria
+	test.Next(_L("T_DENYCLAMP - GetDriveLetters()"));
+
+	TDriveList driveList;
+	TDriveInfo driveInfo;
+	TInt r=TheFs.DriveList(driveList);
+	test(r==KErrNone);
+	TInt drvNum;
+	TBool drivesFound = EFalse;
+	for(drvNum=0; (drvNum<KMaxDrives) && !drivesFound; drvNum++)
+		{
+		TChar drvLetter='?';
+		TFileName fileSystem;
+		if(!driveList[drvNum])
+			continue;
+		test(TheFs.Drive(driveInfo, drvNum) == KErrNone);
+		test(TheFs.DriveToChar(drvNum,drvLetter) == KErrNone);
+		r=TheFs.FileSystemName(fileSystem,drvNum);
+		fileSystem.UpperCase();
+		test((r==KErrNone)||(r==KErrNotFound));
+		// Check for FAT on NAND
+		if(NandFatDrv=='?')
+			{
+			if((driveInfo.iType==EMediaNANDFlash) && (fileSystem.Compare(KFATName)==0))
+				NandFatDrv=drvLetter;
+			}
+		// Check for ROFS
+		if(RofsDrv=='?')
+			{
+			if((driveInfo.iType==EMediaNANDFlash) && (fileSystem.Compare(KROFSName)==0))
+				RofsDrv=drvLetter;
+			}
+		// Check for LFFS
+		if(LffsDrv=='?')
+			{
+			if((driveInfo.iType==EMediaFlash) && (fileSystem.Compare(KLFFSName)==0))
+				LffsDrv=drvLetter;
+			}
+		// Check for CompFSys
+		if(CompDrv=='?')
+			{
+			if((driveInfo.iType==EMediaRom) && ((fileSystem.Compare(KROMName)==0)||(fileSystem.Compare(KCOMPName)==0)))
+				CompDrv=drvLetter;
+			}
+		drivesFound=((NandFatDrv!='?')&&(RofsDrv!='?')&&(LffsDrv!='?')&&(CompDrv!='?'));
+		}
+	if(NandFatDrv!='?')
+		test((NandFatDrv!=RofsDrv)&&(NandFatDrv!=LffsDrv)&&(NandFatDrv!=CompDrv));
+	if(RofsDrv!='?')
+		test((RofsDrv!=LffsDrv)&&(RofsDrv!=CompDrv));
+	if(LffsDrv!='?')
+		test(LffsDrv!=CompDrv);
+
+	RDebug::Printf("T_DENYCLAMP: FAT drive=%C, ROFS drive=%C, LFFS drive=%C, ROM-COMP drive=%C \n",(TText)NandFatDrv,(TText)RofsDrv,(TText)LffsDrv,(TText)CompDrv);
+	return;
+	}
+
+
+//
+// E32Main
+//
+
+TInt E32Main()
+	{
+	TInt r;
+	test.Title();
+	test.Start(_L("Starting T_DENYCLAMP ..."));
+	test(TheFs.Connect()==KErrNone);
+
+	GetDriveLetters();
+	TBuf<256> pathName;	
+
+	//************************************************************************
+	//
+	// Test on FAT (writable file system)
+	//
+	//************************************************************************
+	if(NandFatDrv!='?')
+		{
+		pathName=_L("?:\\CLAMP-TST\\");	// FAT on NAND
+		pathName[0]=(TText)NandFatDrv;
+		r=TheFs.MkDirAll(pathName);
+		test(r==KErrNone || r== KErrAlreadyExists);
+		TheFs.SetSessionPath(pathName);
+		test.Printf( _L("T_DENYCLAMP: testing FAT drive on %C\n"),(TText)NandFatDrv);
+
+		Test1();		// Basic clamp operation
+		Test2();		// Invalid clamp requests
+//		Test3(pathName);// Denied FS requests when files are clamped - invalid for T_DENYCLAMP
+
+		r=TheFs.RmDir(pathName);
+		test(r==KErrNone);
+		}
+	else
+		test.Printf( _L("T_DENYCLAMP: FAT drive not tested\n"));
+
+	//************************************************************************
+	//
+	// Test on ROFS (non-writable file system) 
+	//
+	//************************************************************************
+	if(RofsDrv!='?')
+		{
+		pathName=_L("?:\\");
+		pathName[0]=(TText)RofsDrv;
+		TheFs.SetSessionPath(pathName);
+		test.Printf( _L("T_DENYCLAMP: testing ROFS drive on %C\n"),(TText)RofsDrv);
+
+		Test4(pathName);	// Clamp tests for non-writable file system
+		}
+	else
+		test.Printf( _L("T_DENYCLAMP: ROFS drive not tested\n"));
+
+	//************************************************************************
+	//
+	// Test on Z: - Composite File System, or ROMFS (non-writable file system)
+	//
+	//************************************************************************
+	if(CompDrv!='?')
+		{
+		pathName=_L("?:\\TEST\\");
+		pathName[0]=(TText)CompDrv;
+		TheFs.SetSessionPath(pathName);
+		test.Printf( _L("T_DENYCLAMP: testing Z drive (on %C)\n"),(TText)CompDrv);
+
+		Test4(pathName);	// Clamp tests for non-writable file system
+		}
+	else
+		test.Printf( _L("T_DENYCLAMP: Z drive not tested\n"));
+
+	//************************************************************************
+	//
+	// Test on LFFS (non-clampable file system)
+	//
+	//************************************************************************
+	if(LffsDrv!='?')
+		{
+		TBuf<256> unsuppPath;	
+		unsuppPath=_L("?:\\CLAMP-TST\\");
+		unsuppPath[0]=(TText)LffsDrv;
+		r=TheFs.MkDirAll(unsuppPath);
+		test(r==KErrNone || r== KErrAlreadyExists);
+		TheFs.SetSessionPath(unsuppPath);
+		test.Printf( _L("T_DENYCLAMP: testing LFFS drive on %C\n"),(TText)LffsDrv);
+
+		Test5();		// Clamp requests on non-clamping file systems
+		}
+	else
+		test.Printf( _L("T_DENYCLAMP: LFFS drive not tested\n"));
+
+	test.End();
+	return 0;
+	}
+
+#else
+
+TInt E32Main()
+	{
+	test.Title();
+	test.Start(_L("Test does not run on UREL builds."));
+	test.End();
+	return 0;
+	}
+#endif