// 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\t_handshare.cpp

// 

//

#define	__E32TEST_EXTENSION__

#include <f32file.h>

#include <e32test.h>

#include "t_server.h"

#include "handshare.h"

GLDEF_D RTest test(_L("T_HANDSHARE"));

LOCAL_D TInt drivenum;

// test of (deprecated) RFile::Adopt()

//

// Request an open file (read only)

//

GLDEF_C void RequestFileDeprecatedAdopt()

	{

	test.Next(_L("RFile::Adopt()"));

	TInt r;

	RFileHandleSharer handsvr;

	do

		{

		r=handsvr.Connect();

		}

		while(r==KErrNotFound);

	test_KErrNone(r);

	r=handsvr.SetTestDrive(drivenum);

	test_KErrNone(r);

	TInt ssh;

	RFs fs1;

	TInt fsh = handsvr.GetFileHandle(ssh, EFileRead);

	r = fs1.SetReturnedHandle(fsh);

	test_KErrNone(r);

	RFile file;

	r=file.Adopt(fs1,ssh);

	test_KErrNone(r);

	TBuf8<100> rbuf;

	r=file.Read(0,rbuf);

	test_KErrNone(r);

	r=rbuf.CompareF(KTestData1());

	test_KErrNone(r);

	r=file.Write(KTestData());

	test_Value(r, r==KErrAccessDenied);

	r=file.ChangeMode(EFileWrite);

	test_Value(r, r==KErrArgument);

	r=file.Rename(_L("\\newname.txt"));

	test_Value(r, r==KErrPermissionDenied || r==KErrAccessDenied);

	file.Close();

	fsh = handsvr.GetFileHandle(ssh, EFileRead);

	r = fs1.SetReturnedHandle(fsh);

	test_KErrNone(r);

	// Adopt a bad sub-session handle

	r=file.Adopt(fs1, KNullHandle);

	test_Value(r, r==KErrBadHandle);

	r=file.Adopt(fs1, -1);

	test_Value(r, r==KErrBadHandle);

	handsvr.Close();

	file.Close();

	RDebug::Print(_L("End Of Tests"));

	fs1.Close();

	}

// Cloning tests

GLDEF_C void Duplicate()

	{

	test.Next(_L("RFile::Duplicate()"));

	RFs fs;

	TInt r=fs.Connect();

	test_KErrNone(r);

	// Check the number of open file handles

	TInt resCount = fs.ResourceCount();

	test_Value(resCount, resCount == 0);

	// create a file & fill it with data	

	RFile file1;

	r=file1.Replace(fs,KCliFileName,EFileWrite);

	test_KErrNone(r);

	r=file1.Write(KTestData());

	test_KErrNone(r);

	file1.Close();

	// open the file for read

	r = file1.Open(fs,KCliFileName,EFileRead);

	test_KErrNone(r);

	TBuf8<100> rbuf;

	r = file1.Read(0,rbuf);

	test_KErrNone(r);

	r=rbuf.CompareF(KTestData);

	test_KErrNone(r);

	// clone the file

	RFile file2;

	r = file2.Duplicate(file1);

	test_Value(r, r==0);

	// make sure file positions are the same

	TInt pos1 = 0;

	r = file1.Seek(ESeekCurrent, pos1);

	test_KErrNone(r);

	TInt pos2 = 0;

	r = file2.Seek(ESeekCurrent, pos2);

	test_KErrNone(r);

	test_Value(pos1, pos1 == pos2);

	// change the position on the duplcated file handle & 

	// verify that the original file handle's position is unchanged

	TInt oldPos1 = pos1;

	const TInt newPos2 = 5;

	pos2 = newPos2;

	r = file2.Seek(ESeekStart, pos2);

	test_KErrNone(r);

	pos1 = 0;

	r = file1.Seek(ESeekCurrent, pos1);

	test_KErrNone(r);

	test_Value(pos1, pos1 == oldPos1);

	pos2 = 0;

	r = file2.Seek(ESeekCurrent, pos2);

	test_KErrNone(r);

	test_Value(pos2, pos2 == newPos2);

	test_Value(pos1, pos1 != pos2);

	// close the parent file and check we can still use the duplicated one.

	file1.Close();

	// Check the number of open file handles - should be 1 (the duplicated one)

	resCount = fs.ResourceCount();

	test_Value(resCount, resCount == 1);

	fs.Close();

	rbuf.FillZ();

	// reset to pos 0

	pos2 = 0;

	r = file2.Seek(ESeekStart, pos2);

	test_KErrNone(r);

	r=file2.Read(0,rbuf);

	test_KErrNone(r);

	r=rbuf.CompareF(KTestData);

	test_KErrNone(r);

	file2.Close();

	// start again - this time we're going to close the duplicated file first

	// and check we can still use the parent file

	r = fs.Connect();

	test_KErrNone(r);

	// Make a note of the number of open resources

	fs.ResourceCountMarkStart();

	// open the file for read

	r = file1.Open(fs,KCliFileName,EFileRead);

	test_KErrNone(r);

	// clone the file & check we can read it

	r = file2.Duplicate(file1, EOwnerThread);

	test_Value(r, r==0);

	rbuf.FillZ();

	r = file2.Read(0,rbuf);

	test_KErrNone(r);

	r=rbuf.CompareF(KTestData);

	test_KErrNone(r);

	// close the duplicated file and check we can still use the parent one.

	file2.Close();

	rbuf.FillZ();

	// check we can read the parent file

	r=file1.Read(0,rbuf);

	test_KErrNone(r);

	r=rbuf.CompareF(KTestData);

	test_KErrNone(r);

	// close the parent

	file1.Close();

	// Check the number of open file handles

	fs.ResourceCountMarkEnd();

	resCount = fs.ResourceCount();

	test_Value(resCount, resCount == 0);

	fs.Close();

	}

// Request an open file (write mode) from the server

// using RFile::AdoptFromServer()

GLDEF_C void RequestFileWrite()

	{

	TInt r;

	RFileHandleSharer handsvr;

	do

		{

		r=handsvr.Connect();

		}

	while(r==KErrNotFound);

	test_KErrNone(r);

	r=handsvr.SetTestDrive(drivenum);

	test_KErrNone(r);

	TInt ssh;

	TInt fsh = handsvr.GetFileHandle2(ssh, EFileWrite);

	test (fsh >= 0);

	// Closing the handle to the server ensures the server has closed it's

	// RFs and RFile handles - this provides a means of testing whether we 

	// can still adopt the RFile even if the server has closed it's one.

	handsvr.Sync(); // make sure server has finished doing what it's doing

	handsvr.Close();

	// adopt the file handle from FHServer

	test.Next(_L("RFile::AdoptFromServer()"));

	RFile file;

	r=file.AdoptFromServer(fsh, ssh);

	test_KErrNone(r);

	TBuf8<100> rbuf;

	r=file.Read(0,rbuf);

	test_KErrNone(r);

	// server should write KTestData1 ("Server Write Server Write") to file

	r=rbuf.CompareF(KTestData1);

	test_KErrNone(r);

	// reset to pos 0

	TInt pos = 0;

	r = file.Seek(ESeekStart, pos);

	test_KErrNone(r);

	// overwrite with KTestData ("Client Write Client Write") to file

	r=file.Write(KTestData());

	test_KErrNone(r);

	rbuf.FillZ();

	r=file.Read(0,rbuf);

	test_KErrNone(r);

	r=rbuf.CompareF(KTestData);

	test_KErrNone(r);

// !!! Disable platform security tests until we get the new APIs

//	r=file.Rename(_L("\\newname.txt"));

//	test_Value(r, r==KErrPermissionDenied);

	test.Next(_L("RFile::Name()"));

	// retrieve the file name from the server

	TFileName name;

	r = file.Name(name);

	test_KErrNone(r);

	r = name.Compare(KSvrFileName());

	test_Value(r, r==0);

	test.Next(_L("RFile::Duplicate()"));

	RFile file2;

	r = file2.Duplicate(file);

	test_Value(r, r==0);

	TInt pos1 = 0;

	r = file.Seek(ESeekCurrent, pos1);

	test_KErrNone(r);

	TInt pos2 = 0;

	r = file2.Seek(ESeekCurrent, pos2);

	test_KErrNone(r);

	test_Value(pos1, pos1 == pos2);

	// close the parent file and check we can still use the duplicated one.

	file.Close();

	rbuf.FillZ();

	// reset to pos 0

	pos2 = 0;

	r = file2.Seek(ESeekStart, pos2);

	test_KErrNone(r);

	r=file2.Read(0,rbuf);

	test_KErrNone(r);

	r=rbuf.CompareF(KTestData);

	test_KErrNone(r);

	file2.Close();

	}

// Request a test file & test what we can do with it

// i.e CFileMan::Copy, RFile::Rename() and RFs:Delete()

//

void RequestFileTest()

	{

	TInt r;

	RFs fs;

	r=fs.Connect();

	test_KErrNone(r);

	r=fs.ShareProtected();

	test_KErrNone(r);

	// define a filename in our private path

	TPath newPath;

	fs.PrivatePath(newPath);

	TFileName newFileName;

	newFileName = newPath;

	newFileName.Append(_L("newname.txt"));

	r=fs.CreatePrivatePath(drivenum);

	test_KErrNone(r);

	r=fs.SetSessionToPrivate(drivenum);

	RFileHandleSharer handsvr;

	do

		{

		r=handsvr.Connect();

		}

	while(r==KErrNotFound);

	test_KErrNone(r);

	r=handsvr.SetTestDrive(drivenum);

	test_KErrNone(r);

	// Next verify that we can copy a file retrieved from the server

	// using CFileMan::Copy()

	test.Next(_L("CFileMan::Copy()"));

	TInt ssh;

	TInt fsh = handsvr.GetFileHandle2(ssh, EFileRead);

	test (fsh >= 0);

	RFile file;

	r=file.AdoptFromServer(fsh, ssh);

	test_KErrNone(r);

	CFileMan* fileMan = NULL;

	TRAP(r, fileMan = CFileMan::NewL(fs));

	test_Value(r, r ==  KErrNone && fileMan != NULL);

	// copy to file, overwrite 

	r = fileMan->Copy(file, newFileName, CFileMan::EOverWrite);

	test_KErrNone(r);

	// copy to file, don't overwrite 

	r = fileMan->Copy(file, newFileName, 0);	

	test_Value(r, r ==  KErrAlreadyExists);

	// copy to file, overwrite

	r = fileMan->Copy(file, newFileName, CFileMan::EOverWrite);

	test_KErrNone(r);

	// copy to path

	r = fileMan->Copy(file, newPath, CFileMan::EOverWrite);	

	test_KErrNone(r);

	// copy to file, overwrite, asynchnonous

	TRequestStatus status(KRequestPending);

	r = fileMan->Copy(file, newFileName, CFileMan::EOverWrite, status);

	test_KErrNone(r);

	User::WaitForRequest(status);

	test_KErrNone(status.Int());

	// Negative tests...

	TPath newLongPath;

	TInt len;

	// copy to very long but valid path (no filename) which will overflow

	// when the filename is appended to it

	newLongPath = newPath;

	for (len=newLongPath.Length(); len< KMaxPath -4; len = newLongPath.Length())

		newLongPath.Append(_L("x\\"));

	r = fileMan->Copy(file, newLongPath, CFileMan::EOverWrite);	

	test_Value(r, r ==  KErrBadName);

	// copy to very long but valid path (no filename) which will overflow

	// when drive letter is pre-pended to it

	newLongPath = newPath;

	for (len=newLongPath.Length(); len< KMaxPath -2; len = newLongPath.Length())

		newLongPath.Append(_L("x\\"));

	r = fileMan->Copy(file, newLongPath, CFileMan::EOverWrite);	

	test_Value(r, r ==  KErrBadName);

	// copy to very long but valid path and filename which will overflow

	// when drive letter is pre-pended to it

	newLongPath.Append(_L("y"));

	r = fileMan->Copy(file, newLongPath, CFileMan::EOverWrite);	

	test_Value(r, r ==  KErrBadName);

	// copy to badly formed path 

	newLongPath = newPath;

	newLongPath.Append(_L("\\y"));

	r = fileMan->Copy(file, newLongPath, CFileMan::EOverWrite);	

	test_Value(r, r ==  KErrBadName);

	// copy to correctly formed path which doesn't exist

	newLongPath = newPath;

	newLongPath.Append(_L("x\\y\\z"));

	r = fileMan->Copy(file, newLongPath, CFileMan::EOverWrite);	

	test_Value(r, r ==  KErrPathNotFound);

	delete fileMan; fileMan = NULL;

	file.Close();

	// First verify that we CANNOT rename a file retrieved from the server

	// that has not been opened in EFileShareExclusive mode

	test.Next(_L("negative test of RFile::Rename()"));

	fsh = handsvr.GetFileHandle2(ssh, TFileMode(EFileShareAny | EFileWrite));

	test (fsh >= 0);

	// adopt the file handle from FHServer

	r=file.AdoptFromServer(fsh, ssh);

	test_KErrNone(r);

	r=file.Rename(_L("newname.txt"));

	test_Value(r, r==KErrPermissionDenied || r==KErrAccessDenied);

	// delete the file before we try to rename anything to it

	r = fs.Delete(newFileName);

	test_Value(r, r ==  KErrNone || r == KErrNotFound);

	r=file.Rename(newFileName);

	test_Value(r, r==KErrPermissionDenied || r==KErrAccessDenied);

	file.Close();

	// Next verify that we CAN rename a file retrieved from the server

	// that HAS been opened in EFileShareExclusive mode

	test.Next(_L("RFile::Rename()"));

	fsh = handsvr.GetFileHandle2(ssh, EFileWrite);

	test (fsh >= 0);

	r=file.AdoptFromServer(fsh, ssh);

	test_KErrNone(r);

	// delete the file before we try to rename anything to it

	r = fs.Delete(newFileName);

	test_Value(r, r ==  KErrNone || r == KErrNotFound);

	r=file.Rename(newFileName);

	test_KErrNone(r);

	file.Close();

	// Next verify that we can delete the file (which should now 

	// have been moved to our private directory)

	test.Next(_L("RFs::Delete()"));

	r = fs.Delete(newFileName);

	test_KErrNone(r);

	handsvr.Close();

	fs.Close();

	}

//