// Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "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:

// Started by DWW, October 1996

// Tests cliboard

// 

//

#include <e32test.h>

#include <baclipb.h>

#include <bautils.h>

#include <f32file.h>

#include <s32strm.h>

#include <s32stor.h>

#include <s32file.h>

LOCAL_D RTest test(_L("T_CLIPB"));

const TUid KClipboardFileUid={268435515};

const TUid KUidNameClipboardType={77001};

const TUid KUidAddressClipboardType={77002};

const TUid KUidNumberClipboardType={77003};

const TUid KUidTestType={77004};

const TPtrC KClipboardFileCDrive=_L("C:\\System\\Data\\ClpBoard.cbd");

const TPtrC KClipboardFileDDrive=_L("D:\\System\\Data\\ClpBoard.cbd");

const TPtrC KClipboardFileEDrive=_L("E:\\System\\Data\\ClpBoard.cbd");

/**

 * NOTE :- On order to run this test in WINS, there must exist a mapping for the drives

 * used above. So in Epoc32\Data add the following lines to epoc.ini...

 *

 * _epoc_drive_d \epoc32\wins\d

 * _epoc_drive_e \epoc32\wins\e

 *

 * only needed for drive D & E as there is a mapping for drive C.

 * Plus make sure that the the above directories (\epoc32\wins\d & e) exist.

 */

class TClBase

	{

public:

	virtual void CopyToClipboardL(CStreamStore& aStore,CStreamDictionary& aDictionary) const=0;

	virtual TBool PasteFromClipboardL(CStreamStore& aStore,CStreamDictionary& aDictionary)=0;

	void CopyL();

	TBool PasteL();

	TBool PasteWithoutClipboardL();

private:

	void DoCopyL(RFs& aFsSession);

	TBool DoPasteL(RFs& aFsSession);

	};

void TClBase::CopyL()

	{

	RFs fsSession;

	User::LeaveIfError(fsSession.Connect());

	TRAPD(err,DoCopyL(fsSession));

	fsSession.Close();

	User::LeaveIfError(err);

	}

void TClBase::DoCopyL(RFs& aFsSession)

	{

	CClipboard* cb=CClipboard::NewForWritingLC(aFsSession);

	CopyToClipboardL(cb->Store(),cb->StreamDictionary());

	cb->CommitL();

	CleanupStack::PopAndDestroy();

	}

TBool TClBase::PasteL()

	{

	RFs fsSession;

	User::LeaveIfError(fsSession.Connect());

	TBool res=EFalse;

	TRAPD(err,res=DoPasteL(fsSession));

	fsSession.Close();

	User::LeaveIfError(err);

	return(res);

	}

TBool TClBase::DoPasteL(RFs& aFsSession)

	{

	CClipboard* cb=CClipboard::NewForReadingLC(aFsSession);

	TBool res=PasteFromClipboardL(cb->Store(),cb->StreamDictionary());

	CleanupStack::PopAndDestroy();

	return(res);

	}

class TClName : public TClBase

	{

public:

	void CopyToClipboardL(CStreamStore& aStore,CStreamDictionary& aDictionary) const;

	TBool PasteFromClipboardL(CStreamStore& aStore,CStreamDictionary& aDictionary);

public:

	TBuf<4> iName;

	};

class TClNameWithAddress : public TClName

	{

	void CopyToClipboardL(CStreamStore& aStore,CStreamDictionary& aDictionary) const;

	TBool PasteFromClipboardL(CStreamStore& aStore,CStreamDictionary& aDictionary);

public:

	TBuf<10> iAddress;

	};

class TClNameWithNumber : public TClName

	{

	void CopyToClipboardL(CStreamStore& aStore,CStreamDictionary& aDictionary) const;

	TBool PasteFromClipboardL(CStreamStore& aStore,CStreamDictionary& aDictionary);

public:

	TInt32 iNumber;

	};

class TClInteger : public TClBase

	{

public:

	void CopyToClipboardL(CStreamStore& aStore,CStreamDictionary& aDictionary) const;

	TBool PasteFromClipboardL(CStreamStore& aStore,CStreamDictionary& aDictionary);

public:

	TInt32 iInteger;

	};

void TClName::CopyToClipboardL(CStreamStore& aStore,CStreamDictionary& aDictionary) const

	{

	RStoreWriteStream stream;

	TStreamId streamId=stream.CreateLC(aStore);

	stream<<iName;

	CleanupStack::PopAndDestroy();

	aDictionary.AssignL(KUidNameClipboardType,streamId);

	}

TBool TClName::PasteFromClipboardL(CStreamStore& aStore,CStreamDictionary& aDictionary)

	{

	TStreamId streamId=aDictionary.At(KUidNameClipboardType);

	if (streamId==KNullStreamId)

		return(EFalse);

	RStoreReadStream stream;

	stream.OpenLC(aStore,streamId);

	stream>>iName;

	CleanupStack::PopAndDestroy();

	return(ETrue);

	}

void TClNameWithAddress::CopyToClipboardL(CStreamStore& aStore,CStreamDictionary& aDictionary) const

	{

	TClName::CopyToClipboardL(aStore,aDictionary);

	RStoreWriteStream stream;

	TStreamId streamId=stream.CreateLC(aStore);

	stream<<iAddress;

	CleanupStack::PopAndDestroy();

	aDictionary.AssignL(KUidAddressClipboardType,streamId);

	}

TBool TClNameWithAddress::PasteFromClipboardL(CStreamStore& aStore,CStreamDictionary& aDictionary)

	{

	TBool namePasted=TClName::PasteFromClipboardL(aStore,aDictionary);

	TStreamId streamId=aDictionary.At(KUidAddressClipboardType);

	if (streamId==KNullStreamId)

		return(namePasted);

	RStoreReadStream stream;

	stream.OpenLC(aStore,streamId);

	stream>>iAddress;

	CleanupStack::PopAndDestroy();

	return(ETrue);

	}

void TClNameWithNumber::CopyToClipboardL(CStreamStore& aStore,CStreamDictionary& aDictionary) const

	{

	TClName::CopyToClipboardL(aStore,aDictionary);

	RStoreWriteStream stream;

	TStreamId streamId=stream.CreateLC(aStore);

	stream<<iNumber;

	CleanupStack::PopAndDestroy();

	aDictionary.AssignL(KUidNumberClipboardType,streamId);

	}

TBool TClNameWithNumber::PasteFromClipboardL(CStreamStore& aStore,CStreamDictionary& aDictionary)

	{

	TBool namePasted=TClName::PasteFromClipboardL(aStore,aDictionary);

	TStreamId streamId=aDictionary.At(KUidNumberClipboardType);

	if (streamId==KNullStreamId)

		return(namePasted);

	RStoreReadStream stream;

	stream.OpenLC(aStore,streamId);

	stream>>iNumber;

	CleanupStack::PopAndDestroy();

	return(ETrue);

	}

void TClInteger::CopyToClipboardL(CStreamStore& aStore,CStreamDictionary& aDictionary) const

	{

	RStoreWriteStream stream;

	TStreamId streamId=stream.CreateLC(aStore);

	stream<<iInteger;

	CleanupStack::PopAndDestroy();

	aDictionary.AssignL(KUidNumberClipboardType,streamId);

	}

TBool TClInteger::PasteFromClipboardL(CStreamStore& aStore,CStreamDictionary& aDictionary)

	{

	TStreamId streamId=aDictionary.At(KUidNumberClipboardType);

	if (streamId==KNullStreamId)

		return(EFalse);

	RStoreReadStream stream;

	stream.OpenLC(aStore,streamId);

	stream>>iInteger;

	CleanupStack::PopAndDestroy();

	return(ETrue);

	}

/**

@SYMTestCaseID          SYSLIB-BAFL-CT-0404

@SYMTestCaseDesc        Tests the  CClipboard::Store(),StreamDictionary functions

@SYMTestPriority        High

@SYMTestActions         Tests the clipboard's file store with various cases(no file,file in use,corrupt file,non-store file)

@SYMTestExpectedResults Tests must not fail

@SYMREQ                 REQ0000

*/

void TestErrorHandling(const TDesC& aTestPath)

	{

	test.Next(_L(" @SYMTestCaseID:SYSLIB-BAFL-CT-0404 "));

	TPtrC KClipboardFile(aTestPath);

	RFs fs;

	test (fs.Connect()==KErrNone);

//

	test.Next(_L("No clipboard file"));

	fs.Delete(KClipboardFile);

	test (CClipboard::Clear(fs)==KErrNone);

	CClipboard* cb=NULL;

	TRAPD(err,cb=CClipboard::NewForReadingL(fs));

	test (err==KErrNone);

	test (&cb->Store()==NULL);

	test (&cb->StreamDictionary()!=NULL);

	test (cb->StreamDictionary().IsNull());

	delete cb;

//

	test.Next(_L("In use"));

	RFile file;

	test (file.Create(fs,KClipboardFile,EFileRead|EFileWrite)==KErrNone);

	TRAP(err,cb=CClipboard::NewForReadingL(fs));

	test (err==KErrNone);

	test (&cb->Store()==NULL);

	test (&cb->StreamDictionary()!=NULL);

	test (cb->StreamDictionary().IsNull());

	delete cb;

//

	test.Next(_L("Clear while in use"));

	test (CClipboard::Clear(fs)==KErrInUse);

//

	test.Next(_L("Bogus clipboard file"));

	file.Close();

	TRAP(err,cb=CClipboard::NewForReadingL(fs));

	test (err==KErrNone);

	test (&cb->Store()==NULL);

	test (&cb->StreamDictionary()!=NULL);

	test (cb->StreamDictionary().IsNull());

	delete cb;

//

	test.Next(_L("Non-store file"));

	test (file.Replace(fs,KClipboardFile,EFileRead|EFileWrite)==KErrNone);

	test (file.Write(_L8("some data which does not make this a file store"))==KErrNone);

	file.Close();

	TRAP(err,cb=CClipboard::NewForReadingL(fs));

	test (err==KErrNone);

	test (&cb->Store()==NULL);

	test (&cb->StreamDictionary()!=NULL);

	test (cb->StreamDictionary().IsNull());

	delete cb;

//

	test.Next(_L("Wrong type file"));

	CFileStore* store=CDirectFileStore::ReplaceLC(fs,KClipboardFile,EFileRead|EFileWrite);

	store->SetTypeL(TUidType(KDirectFileStoreLayoutUid,KUidTestType));

	store->CommitL();

	CleanupStack::PopAndDestroy();

	TRAP(err,cb=CClipboard::NewForReadingL(fs));

	test (err==KErrNone);

	test (&cb->Store()==NULL);

	test (&cb->StreamDictionary()!=NULL);

	test (cb->StreamDictionary().IsNull());

	delete cb;

//

	test.Next(_L("Corrupted clipboard"));

	store=CDirectFileStore::ReplaceLC(fs,KClipboardFile,EFileRead|EFileWrite);

	store->SetTypeL(TUidType(KDirectFileStoreLayoutUid,KClipboardFileUid));

	store->CommitL();

	CleanupStack::PopAndDestroy();

	TRAP(err,cb=CClipboard::NewForReadingL(fs));

	test (err==KErrNone);

	test (&cb->Store()==NULL);

	test (&cb->StreamDictionary()!=NULL);

	test (cb->StreamDictionary().IsNull());

	delete cb;

//

	test.Next(_L("Clear clipboard"));

	test (CClipboard::Clear(fs)==KErrNone);

	TRAP(err,cb=CClipboard::NewForReadingL(fs));

	test (err==KErrNone);

	test (&cb->Store()==NULL);

	test (&cb->StreamDictionary()!=NULL);

	test (cb->StreamDictionary().IsNull());

	delete cb;

//

#if defined(_DEBUG)

	test.Next(_L("Out of memory failure"));

//

	cb=CClipboard::NewForWritingLC(fs);

	RStoreWriteStream stream;

	TStreamId testId=stream.CreateLC(cb->Store());

	stream.WriteInt32L(0);

	stream.CommitL();

	CleanupStack::PopAndDestroy();

	cb->StreamDictionary().AssignL(KUidTestType,testId);

	cb->CommitL();

	CleanupStack::PopAndDestroy();

//

	__UHEAP_MARK;

	for (TInt ii=0;;++ii)

		{

		__UHEAP_FAILNEXT(ii);

		TRAP(err,cb=CClipboard::NewForReadingL(fs));

		if (err==KErrNone)

			break;

		test(err==KErrNoMemory);

		__UHEAP_CHECK(0);

		}

	__UHEAP_RESET;

	test (&cb->Store()!=NULL);

	test (cb->StreamDictionary().At(KUidTestType)==testId);

	delete cb;

	__UHEAP_MARKEND;

//

#endif

//

	test.Next(_L("Fail to commit clipboard"));

	TRAP(err,cb=CClipboard::NewForWritingLC(fs);CleanupStack::Pop());

	test (err==KErrNone);

	delete cb;

	test (!BaflUtils::FileExists(fs,KClipboardFile));

//

	fs.Close();

	}

/**

@SYMTestCaseID          SYSLIB-BAFL-CT-0405

@SYMTestCaseDesc        Tests the CClipboard::NewForWritingLC,NewForReadingL

@SYMTestPriority        High

@SYMTestActions         Tests for copy and paste operations on TClName,TClNameWithAddress,TClInteger,TClNameWithNumber

@SYMTestExpectedResults Tests must not fail

@SYMREQ                 REQ0000

*/

void DoTestsOnDrive(const TDesC& aDrivePath)

    {

	test.Start(_L(" @SYMTestCaseID:SYSLIB-BAFL-CT-0405 Test single paste "));

	TClName n1,n2;

	n1.iName=_L("Fred");

	n2.iName=_L("Dino");

	n1.CopyL();

	TClNameWithAddress na1,na2;

	test(na1.PasteL());

	n2.CopyL();

	test(na2.PasteL());

	test(na1.iName==_L("Fred"));

	test(na2.iName==_L("Dino"));

	na1.iAddress=_L("Bedrock");

	test.Next(_L("Test double paste"));

	na1.CopyL();

	test(na2.PasteL());

	test(na2.iAddress==_L("Bedrock"));

	test(na2.iName==_L("Fred"));

	test.Next(_L("Test paste failure if type not present"));

	TClInteger i1,i2;

	test(!i1.PasteL());

	test.Next(_L("Test selecting the right data type"));

	TClNameWithNumber nn1,nn2;

	nn1.iNumber=36363;

	test(nn1.PasteL());

	test(nn1.iNumber==36363);

	test(nn1.iName==_L("Fred"));

	nn1.iName=_L("Wilm");

	nn1.CopyL();

	test(i2.PasteL());

	test(i2.iInteger==36363);

	test(n1.PasteL());

	test(n1.iName==_L("Wilm"));

	test(nn2.PasteL());

	test(nn2.iName==_L("Wilm"));

	test(nn2.iNumber==36363);

//

	TestErrorHandling(aDrivePath);

	test.End();

    }

void DoTests()

	{

	// Tests for the HAL attribute ClipboardDrive set in the device.

	// C Drive

	DoTestsOnDrive(KClipboardFileCDrive);

	}

GLDEF_C TInt E32Main()

	{

    __UHEAP_MARK;

    CTrapCleanup *cleanup=CTrapCleanup::New();

	test.Title();

	test.Start(_L("Testing CClipboard "));

    TRAPD(err,DoTests());

    test(err==KErrNone);

	test.End();

    test.Close();

    delete cleanup;

    __UHEAP_MARKEND;

	return(0);

    }