// Copyright (c) 1998-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:

//

#include <e32test.h>

#include <s32mem.h>

//

// CTestStreamDictionary

// The only reason this class to be used here is to 

// get an access to CStreamDictionary::iArray (private data member). 

//

class CTestStreamDictionary : public CStreamDictionary

	{

public:

	struct TEntry 

	    {

	    TUid uid;

	    TStreamId id;

	    };

public:

	static CTestStreamDictionary* NewL();

	CTestStreamDictionary();

	TUid Uid(TInt aInt) 

	    { 

	    return (*iCheat)[aInt].uid; 

	    }

	TStreamId StreamId(TInt aInt) 

	    { 

	    return (*iCheat)[aInt].id; 

	    }

	TInt Count() 

	    { 

	    return iCheat->Count(); 

	    }

private:

	CArrayFixSeg<TEntry>* iCheat;

	};

CTestStreamDictionary* CTestStreamDictionary::NewL()

	{

	CTestStreamDictionary* thing=new(ELeave) CTestStreamDictionary();

	return thing;

	}

CTestStreamDictionary::CTestStreamDictionary()

	: iCheat((CArrayFixSeg<TEntry>*)&iCheat-1) //Now iCheat points to the base class' private data member: 

	                                           //CStreamDictionary::iArray.

                                               //This way it is possible to call iArray's methods (even though it is private).

	{

	}

//

// Test code

//

const TInt KTestExpandSize=0x20;

static RTest TheTest(_L("t_stordict"));

// some uid-stream pairs to use for testing

const TUid testUid1={1};

static TStreamId testStreamId1=TStreamId(1);

//

const TUid testUid2={57};

static TStreamId testStreamId2=TStreamId(57);

//

const TUid testUid3={99999};

static TStreamId testStreamId3=TStreamId(425);

//

//Put test data files to be deleted at the end here!

void DeleteDataFiles()

    {

    }

//Tests macros and functions.

//If (!aValue) then the test will be panicked, the test data files will be deleted.

static void Check(TInt aValue, TInt aLine)

    {

    if(!aValue)

        {

        DeleteDataFiles();

        TheTest(EFalse, aLine);

        }

    }

//If (aValue != aExpected) then the test will be panicked, the test data files will be deleted.

static void Check(TInt aValue, TInt aExpected, TInt aLine)

    {

    if(aValue != aExpected)

        {

        RDebug::Print(_L("*** Expected error: %d, got: %d\r\n"), aExpected, aValue);

        DeleteDataFiles();

        TheTest(EFalse, aLine);

        }

    }

//Use these to test conditions.

#define TEST(arg) ::Check((arg), __LINE__)

#define TEST2(aValue, aExpected) ::Check(aValue, aExpected, __LINE__)

/**

@SYMTestCaseID          SYSLIB-STORE-CT-1201

@SYMTestCaseDesc	    Tests for copy operations on dictionary files

@SYMTestPriority 	    High

@SYMTestActions  	    Attempt for copying two classes using memory based streams.

@SYMTestExpectedResults Test must not fail

@SYMREQ                 REQ0000

*/

template <class T1,class T2>

void testCopyL(T1& aCopy,const T2& anOriginal)

	{

	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-STORE-CT-1201 "));

	CBufSeg* buf=0;

	TRAPD(r,buf=CBufSeg::NewL(KTestExpandSize));

    TEST2(r, KErrNone);

//

// Write anOriginal out to the buffer.

//

	RBufWriteStream out;

	out.Append(*buf);

	TRAP(r,out<<anOriginal);

	TEST2(r, KErrNone);

	TRAP(r,out.CommitL());

    TEST2(r, KErrNone);

//

// Read anOriginal in from the buffer.

//

	RBufReadStream in(*buf);

	TRAP(r,in>>aCopy);

    TEST2(r, KErrNone);

//

// See if it's consumed the lot.

//

	TUint8 b;

	TEST2(in.Source()->ReadL(&b,1), 0);

//

	delete buf;

	}

/**

@SYMTestCaseID          SYSLIB-STORE-CT-1202

@SYMTestCaseDesc	    Tests if two dictionary files are equal

@SYMTestPriority 	    High

@SYMTestActions  	    Tests if count of entries,UID and streamID's are equal

@SYMTestExpectedResults Test must not fail

@SYMREQ                 REQ0000

*/

void testIsEqual(CTestStreamDictionary* aCopy,CTestStreamDictionary* aOrig)

	{

	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-STORE-CT-1202 "));

	TInt origCount=aOrig->Count();

	TEST(origCount==aCopy->Count());

	//

	for (TInt i=0 ; i<origCount ; i++)

		{

		TEST(aOrig->Uid(i)==aCopy->Uid(i));

		TEST(aOrig->StreamId(i)==aCopy->StreamId(i));

		}

	}

/**

@SYMTestCaseID          SYSLIB-STORE-CT-1203

@SYMTestCaseDesc	    Tests for simple operations on a dictionary file

@SYMTestPriority 	    High

@SYMTestActions  	    Tests for assign,re-assigning,removing entries from the file

@SYMTestExpectedResults Test must not fail

@SYMREQ                 REQ0000

*/

LOCAL_C void simpleTestsL()

	{

	CTestStreamDictionary* dic=CTestStreamDictionary::NewL();

	// attempt finding and removing with an empty dictionary

	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-STORE-CT-1203 Manipulating an empty dictionary "));

	TEST2(dic->Count(), 0);

	TEST(dic->At(testUid1)==KNullStreamId);

	dic->Remove(testUid1);

	TEST2(dic->Count(), 0);

	TEST(dic->IsNull());

	//

	// assign an entry

	TheTest.Next(_L("Assigning entries and manipulating them"));

	TRAPD(ret,dic->AssignL(testUid1,testStreamId1));

	TEST2(ret, KErrNone);

	TEST2(dic->Count(), 1);

	TEST(!dic->IsNull());

	TEST(dic->At(testUid1)==testStreamId1);

	//

	// assign another entry

	TRAP(ret,dic->AssignL(testUid2,testStreamId2));

	TEST2(ret, KErrNone);

	TEST2(dic->Count(), 2);

	TEST(dic->At(testUid2)==testStreamId2);

	//

	// re-assign uid1

	TRAP(ret,dic->AssignL(testUid1,testStreamId3));

	TEST2(ret, KErrNone);

	TEST2(dic->Count(), 2);

	TEST(dic->At(testUid1)==testStreamId3);

	//

	// test finding and removing a non-existant entry from a non-empty dictionary

	TEST(dic->At(testUid3)==KNullStreamId);

	dic->Remove(testUid3);

	TEST2(dic->Count(), 2);

	//

	// test removing an entry

	dic->Remove(testUid1);

	TEST2(dic->Count(), 1);

	TEST(dic->At(testUid1)==KNullStreamId);

	TEST(dic->At(testUid2)==testStreamId2);

	TEST(!dic->IsNull());

	//

	// test removing the other entry

	dic->Remove(testUid2);

	TEST2(dic->Count(), 0);

	TEST(dic->IsNull());

	TEST(dic->At(testUid1)==KNullStreamId);

	TEST(dic->At(testUid2)==KNullStreamId);

	//

	delete dic;

	}

/**

@SYMTestCaseID          SYSLIB-STORE-CT-1204

@SYMTestCaseDesc	    Streaming dictionary files tests

@SYMTestPriority 	    High

@SYMTestActions  	    Tests for copying an empty dictionary and dictionary containing different sets of entries

                        Tests for equality of two dictionary files and test the copied file.

@SYMTestExpectedResults Test must not fail

@SYMREQ                 REQ0000

*/

LOCAL_C void streamingTestsL()

	{

	CTestStreamDictionary* orig=CTestStreamDictionary::NewL();

	CTestStreamDictionary* copy=CTestStreamDictionary::NewL();

	//

	// copy an empty dictionary

	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-STORE-CT-1204 Streaming an empty dictionary "));

	TEST(orig->IsNull());

	testCopyL(*copy,*orig);

	TEST(copy->IsNull());

	//

	// copy a dictionary containing a range of entries

	TheTest.Next(_L("Streaming a dictionary containing entries"));

	TRAPD(ret,orig->AssignL(testUid1,testStreamId1));

	TRAP(ret,orig->AssignL(testUid2,testStreamId2));

	TRAP(ret,orig->AssignL(testUid3,testStreamId3));

	testCopyL(*copy,*orig);

	testIsEqual(copy,orig);

	TEST(!copy->IsNull());

	//

	delete orig;

	delete copy;

	}

void DoTestL()

    {

    simpleTestsL();

    streamingTestsL();

    }

TInt E32Main()

	{

    __UHEAP_MARK;

    TheTest.Title();

    CTrapCleanup* trapCleanup = CTrapCleanup::New();

    TheTest(trapCleanup != NULL);

	TheTest.Start(_L("Testing CStreamDictionary..."));

	TRAPD(err, DoTestL());

    TEST2(err, KErrNone);

    DeleteDataFiles();

    TheTest.End();

    TheTest.Close();

    delete trapCleanup;

    __UHEAP_MARKEND;

	return KErrNone;

	}