// 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, April 1996
// Tests descriptor arrays
// 
//

#include <e32test.h>
#include <badesca.h>

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

class TestDesca
	{
public:
	void MainTestL(CDesCArray* aDescA);
	void ComparisonTest(CDesCArray* aDescA1,CDesCArray* aDescA2);
	void FoldTestL(CDesCArray* aDescA);
	void MixableTestL();
	void DoMixableTest(MDesCArray* aDescA);
	void InSequenceTestL(CDesCArray* aDescA);
    };

/**
@SYMTestCaseID          SYSLIB-BAFL-CT-0408
@SYMTestCaseDesc        Tests for folded and non-folded find
@SYMTestPriority        Medium
@SYMTestActions         Tests by appending few descriptors and find the position for the target.
@SYMTestExpectedResults Tests must not fail
@SYMREQ                 REQ0000
*/
void TestDesca::FoldTestL(CDesCArray* aDescA)
	{
	test.Next(_L(" @SYMTestCaseID:SYSLIB-BAFL-CT-0408 Test folded and non-folded find "));
	TPtrC target=_L("abcdefg");
	aDescA->AppendL(target);
	aDescA->AppendL(_L("aBcDeFg"));
	aDescA->InsertL(0,_L("ABCDEFG"));
	test(aDescA->Count()==3);
	TInt pos=(-1);
    aDescA->Find(target,pos);
    test(pos==0);
    aDescA->Find(target,pos,ECmpNormal);
    test(pos==1);
	test.Next(_L("Test reset"));
	aDescA->Reset();
	test(!aDescA->Count());
	}

/**
@SYMTestCaseID          SYSLIB-BAFL-CT-0409
@SYMTestCaseDesc        CDesCArray class functionality test
@SYMTestPriority        Medium
@SYMTestActions         Add month names to the descriptor array and tests with the find.
@SYMTestExpectedResults Tests must not fail
@SYMREQ                 REQ0000
*/
void TestDesca::MainTestL(CDesCArray* aDescA)
	{
    TMonthName name;
    test.Next(_L(" @SYMTestCaseID:SYSLIB-BAFL-CT-0409 Add 12 month names "));
    for (TInt ii=0; ii<12; ii++)
        {
        name.Set((TMonth)ii);
        aDescA->AppendL(name);
        }
    test.Next(_L("Check 12 names exist"));
    test(aDescA->Count()==12);
    test.Next(_L("Print the 12 names"));
    for (TInt jj=0; jj<12; jj++)
        test.Printf((*aDescA)[jj]);
    test.Printf(_L("\r\n"));
    test.Next(_L("Find"));
    for (TInt kk=3; kk<12; kk+=3)
        {
        name.Set((TMonth)kk);
        TInt pos=0;
        aDescA->Find(name,pos);
        test(pos==kk);
        }
    test.Next(_L("Delete"));
    aDescA->Delete(2);
    aDescA->Delete(4);
    aDescA->Delete(6);
    test(aDescA->Count()==9);
    test((*aDescA)[6]==name);
    test.Next(_L("Sort"));
    aDescA->Sort();
    test(aDescA->Count()==9);
    for (TInt ll=0; ll<9; ll++)
        test.Printf((*aDescA)[ll]);
    test.Printf(_L("\r\n"));
	test.End();
    }

/**
@SYMTestCaseID          SYSLIB-BAFL-CT-0410
@SYMTestCaseDesc        Comparision of two CDesCArray objects test
@SYMTestPriority        Medium
@SYMTestActions         Check if two descriptor arrays are equal.
@SYMTestExpectedResults Tests must not fail
@SYMREQ                 REQ0000
*/
void TestDesca::ComparisonTest(CDesCArray* aDescA1,CDesCArray* aDescA2)
	{
	test.Start(_L(" @SYMTestCaseID:SYSLIB-BAFL-CT-0410 Test comparisons "));
    TInt count=aDescA1->Count();
    test(aDescA2->Count()==count);
    for (TInt ii=0; ii<count; ii++)
        test((*aDescA1)[ii]==(*aDescA2)[ii]);
    test.End();
    }

/**
@SYMTestCaseID          SYSLIB-BAFL-CT-0411
@SYMTestCaseDesc        MDesCArray class functionality test
@SYMTestPriority        Medium
@SYMTestActions         Checks for the existence of 12 names
@SYMTestExpectedResults Tests must not fail
@SYMREQ                 REQ0000
*/
void TestDesca::DoMixableTest(MDesCArray* aDescA)
	{
    test.Next(_L(" @SYMTestCaseID:SYSLIB-BAFL-CT-0411 Check 12 names exist "));
    test(aDescA->MdcaCount()==12);
    test.Next(_L("Print the 12 names"));
    for (TInt jj=0; jj<12; jj++)
        test.Printf(aDescA->MdcaPoint(jj));
    test.Printf(_L("\r\n"));
	delete(aDescA);
    }

/**
@SYMTestCaseID          SYSLIB-BAFL-CT-0412
@SYMTestCaseDesc        Tests for CDesCArray sequences
@SYMTestPriority        Medium
@SYMTestActions         Checks for the sequence of the literals.
@SYMTestExpectedResults Tests must not fail
@SYMREQ                 REQ0000
*/
void TestDesca::InSequenceTestL(CDesCArray* aDescA)
	{
    test.Next(_L(" @SYMTestCaseID:SYSLIB-BAFL-CT-0412 In Sequence Tests "));
	aDescA->Reset();
	TPtrC hello(_S("Hello"));
	TPtrC bye(_S("Bye"));
	TPtrC world(_S("World"));
	TPtrC middle(_S("middle"));
	TPtrC extra(_S("extra"));
	TBuf<32> buffer;
	TInt pos;
	aDescA->AppendL(hello);
	aDescA->AppendL(bye);
	aDescA->AppendL(world);
	aDescA->AppendL(middle);
    test(aDescA->MdcaPoint(0)==hello);
    test(aDescA->MdcaPoint(2)==world);
	//
	aDescA->Sort(ECmpFolded);
	buffer=aDescA->MdcaPoint(2);
    test(buffer==middle);
	test(aDescA->Find(middle,pos,ECmpFolded)==KErrNone);
	test(pos==2);
	test(aDescA->FindIsq(middle,pos,ECmpFolded)==KErrNone);
	test(pos==2);
	test(aDescA->FindIsq(middle,pos,ECmpNormal)==KErrNone); // !! should this fail for non-sorted array??
//	test(pos==??);
	pos=aDescA->InsertIsqL(extra,ECmpFolded);
	test(pos==1);
	TRAP(pos,aDescA->InsertIsqL(extra,ECmpFolded));
	test(pos==KErrAlreadyExists);
	pos=aDescA->InsertIsqAllowDuplicatesL(extra,ECmpFolded);
	test(pos==2);
	aDescA->Delete(pos--);
	aDescA->Delete(pos);
	test(aDescA->MdcaCount()==4);
	//
	//	Different sort order because of case
	aDescA->Sort(ECmpNormal);
	buffer=aDescA->MdcaPoint(2);
    test(buffer==world);
	test(aDescA->Find(world,pos,ECmpNormal)==KErrNone);
	test(pos==2);
	test(aDescA->FindIsq(world,pos,ECmpNormal)==KErrNone);
	test(pos==2);
    }

class CMonthNameArray : public CArrayFixFlat<TMonthName>, public MDesCArray
	{
public:
	CMonthNameArray() :CArrayFixFlat<TMonthName>(4) { }
private:
	TInt MdcaCount() const { return(Count()); }
	TPtrC MdcaPoint(TInt aIndex) const { return((*this)[aIndex]); }
	};

/**
@SYMTestCaseID          SYSLIB-BAFL-CT-0413
@SYMTestCaseDesc        Tests for mixability
@SYMTestPriority        Medium
@SYMTestActions         Tests the mix of setting and appending of month names to the descriptor array
@SYMTestExpectedResults Tests must not fail
@SYMREQ                 REQ0000
*/
void TestDesca::MixableTestL()
	{
	test.Start(_L(" @SYMTestCaseID:SYSLIB-BAFL-CT-0413 Test mixability "));
	CMonthNameArray* array=new(ELeave) CMonthNameArray;
    TMonthName name;
    test.Next(_L("Add 12 month names"));
    for (TInt ii=0; ii<12; ii++)
        {
        name.Set((TMonth)ii);
        array->AppendL(name);
        }
	DoMixableTest(array);
	test.End();
	}

/**
@SYMTestCaseID          SYSLIB-BAFL-CT-0414
@SYMTestCaseDesc        Descriptor arrays tests
@SYMTestPriority        Medium
@SYMTestActions         Executes all the CDesCArray tests
@SYMTestExpectedResults Tests must not fail
@SYMREQ                 REQ0000
*/
void DoTestsL()
    {
	TestDesca t;
	test.Next(_L(" @SYMTestCaseID:SYSLIB-BAFL-CT-0414 Test CDesCArrayFlat "));
    CDesCArrayFlat* descFlatArray=new(ELeave) CDesCArrayFlat(4);
	TRAPD(errCode, t.FoldTestL(descFlatArray));
	test(errCode==KErrNone);
	TRAP(errCode, t.MainTestL(descFlatArray));
	test(errCode==KErrNone);
	test.Start(_L("Test CDesCArraySeg"));
    CDesCArraySeg* descSegArray=new(ELeave) CDesCArraySeg(3);
	TRAP(errCode, t.FoldTestL(descSegArray));
	test(errCode==KErrNone);
	TRAP(errCode, t.MainTestL(descSegArray));
	test(errCode==KErrNone);
    t.ComparisonTest(descFlatArray,descSegArray);
	TRAP(errCode, t.InSequenceTestL(descSegArray));
	test(errCode==KErrNone);
	TRAP(errCode, t.InSequenceTestL(descFlatArray));
	test(errCode==KErrNone);
    delete(descFlatArray);
    delete(descSegArray);
	t.MixableTestL();
    }

GLDEF_C TInt E32Main()
	{
    __UHEAP_MARK;
    CTrapCleanup *cleanup=CTrapCleanup::New();
	test.Title();
	test.Start(_L(" Testing descriptor arrays "));
    TRAPD(err,DoTestsL());
    test(err==KErrNone);
	test.End();
    test.Close();
    delete cleanup;
    __UHEAP_MARKEND;
	return(0);
    }