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


// CLASS UNDER TEST
#include <aiutility.h>
#include <aicontentmodel.h>

#include "MT_AiContentItemArrayIterator.h"
#include <digia/eunit/eunitmacros.h>

const TInt KNonExistentItemId = -1;
_LIT(KNonExistentItemCid, "NonExistentCid");



// CONSTRUCTION
MT_AiContentItemArrayIterator* MT_AiContentItemArrayIterator::NewL()
    {
    MT_AiContentItemArrayIterator* self = MT_AiContentItemArrayIterator::NewLC();
    CleanupStack::Pop( self );
    return self;
    }

MT_AiContentItemArrayIterator* MT_AiContentItemArrayIterator::NewLC()
    {
    MT_AiContentItemArrayIterator* self = new( ELeave ) MT_AiContentItemArrayIterator();
    CleanupStack::PushL( self );
    self->ConstructL();
    return self;
    }

// Destructor (virtual by CBase)
MT_AiContentItemArrayIterator::~MT_AiContentItemArrayIterator()
    {
#if _BullseyeCoverage
    cov_write();
#endif
    }

// Default constructor
MT_AiContentItemArrayIterator::MT_AiContentItemArrayIterator()
    {
    }

// Second phase construct
void MT_AiContentItemArrayIterator::ConstructL()
    {
    // The ConstructL from the base class CEUnitTestSuiteClass must be called.
    // It generates the test case table.
    CEUnitTestSuiteClass::ConstructL();
    }

//  METHODS



void MT_AiContentItemArrayIterator::SetupL(  )
    {
    }

void MT_AiContentItemArrayIterator::Teardown(  )
    {
    }

void MT_AiContentItemArrayIterator::TestEmptyL(  )
    {
    MAiContentItemIterator* iter = NULL;
    // Test that Release(NULL) does not crash
    Release(iter);
    
    // Test that the iterator works correctly with an empty (NULL) array
    iter = AiUtility::CreateContentItemArrayIteratorL(NULL, 0);
    CleanupReleasePushL(iter);

    // Make two passes through the iterator to test also Reset
    for (TInt round = 1; round <= 2; ++round)
        {
        EUNIT_ASSERT( !iter->HasNext() );
        EUNIT_ASSERT_SPECIFIC_LEAVE( iter->NextL(), KErrOverflow );
        EUNIT_ASSERT_SPECIFIC_LEAVE( iter->ItemL(0), KErrNotFound );
        EUNIT_ASSERT_SPECIFIC_LEAVE( iter->ItemL(KNullDesC), KErrNotFound );
        iter->Reset();
        }

    CleanupStack::PopAndDestroy(iter);
    
    // Array with negative count should work as an empty array
    iter = AiUtility::CreateContentItemArrayIteratorL(NULL, -1);
    CleanupReleasePushL(iter);

    // Make two passes through the iterator to test also Reset
    for (TInt round = 1; round <= 2; ++round)
        {
        EUNIT_ASSERT( !iter->HasNext() );
        EUNIT_ASSERT_SPECIFIC_LEAVE( iter->NextL(), KErrOverflow );
        EUNIT_ASSERT_SPECIFIC_LEAVE( iter->ItemL(0), KErrNotFound );
        EUNIT_ASSERT_SPECIFIC_LEAVE( iter->ItemL(KNullDesC), KErrNotFound );
        iter->Reset();
        }

    CleanupStack::PopAndDestroy(iter);
    }

TBool operator==(const TAiContentItem& aLhs, const TAiContentItem& aRhs)
    {
    // Use pointer comparison as CAiContentItemArrayIterator iterates through
    // the original items
    return (&aLhs == &aRhs);
    }

void DoTestOneL
        ( const TAiContentItem& aRefItem, MAiContentItemIterator& aIter )
    {
    // Make two passes through the iterator to test also Reset
    for (TInt pass = 1; pass <= 2; ++pass)
        {
        EUNIT_ASSERT( aIter.HasNext() );
        EUNIT_ASSERT_EQUALS( aRefItem, aIter.NextL() );
        EUNIT_ASSERT( !aIter.HasNext() );

        EUNIT_ASSERT_SPECIFIC_LEAVE( aIter.NextL(), KErrOverflow );
        EUNIT_ASSERT_SPECIFIC_LEAVE( aIter.ItemL(KNonExistentItemId), KErrNotFound );
        EUNIT_ASSERT_SPECIFIC_LEAVE( aIter.ItemL(KNonExistentItemCid), KErrNotFound );

        EUNIT_ASSERT_EQUALS( aRefItem, aIter.ItemL(aRefItem.id) );
        EUNIT_ASSERT_EQUALS( aRefItem, aIter.ItemL(ContentCid(aRefItem)) );

        EUNIT_ASSERT_SPECIFIC_LEAVE( aIter.ItemL(KNonExistentItemId), KErrNotFound );
        EUNIT_ASSERT_SPECIFIC_LEAVE( aIter.ItemL(KNonExistentItemCid), KErrNotFound );

        aIter.Reset();
        }
    }

void MT_AiContentItemArrayIterator::TestOneL(  )
    {
    const TInt KTestId = 42;
    static const wchar_t KTestCid[] = L"testcid";
    static const char KTestType[] = "testtype";
    static const TAiContentItem KOneItem[] = { { KTestId, KTestCid, KTestType } };
    
    // Test iterator created with NewL
    MAiContentItemIterator* iter =
        AiUtility::CreateContentItemArrayIteratorL(KOneItem, 1);
    CleanupReleasePushL(iter);
    DoTestOneL( KOneItem[0], *iter );
    CleanupStack::PopAndDestroy(iter);
    
    // Test iterator created with create template helper
    iter = AiUtility::CreateContentItemArrayIteratorL(KOneItem);
    CleanupReleasePushL(iter);
    DoTestOneL( KOneItem[0], *iter );
    CleanupStack::PopAndDestroy(iter);
    }

void DoTestManyL
        ( const TAiContentItem& aRefItem, MAiContentItemIterator& aIter, TInt aCount )
    {
    // Make two passes through the iterator to test also Reset
    for (TInt pass = 1; pass <= 2; ++pass)
        {
        TBool refItemIndex = -1;
        for ( TInt count = 0; count < aCount; ++count )
            {
            EUNIT_ASSERT( aIter.HasNext() );
            if (aIter.NextL() == aRefItem)
                {
                refItemIndex = count;
                }
            }
        EUNIT_ASSERT( refItemIndex >= 0 );
        EUNIT_ASSERT( !aIter.HasNext() );
        
        EUNIT_ASSERT_SPECIFIC_LEAVE( aIter.NextL(), KErrOverflow );
        EUNIT_ASSERT_SPECIFIC_LEAVE( aIter.ItemL(KNonExistentItemId), KErrNotFound );
        EUNIT_ASSERT_SPECIFIC_LEAVE( aIter.ItemL(KNonExistentItemCid), KErrNotFound );
        
        EUNIT_ASSERT_EQUALS( aRefItem, aIter.ItemL(aRefItem.id) );
        EUNIT_ASSERT_EQUALS( aRefItem, aIter.ItemL(ContentCid(aRefItem)) );

        EUNIT_ASSERT_SPECIFIC_LEAVE( aIter.ItemL(KNonExistentItemId), KErrNotFound );
        EUNIT_ASSERT_SPECIFIC_LEAVE( aIter.ItemL(KNonExistentItemCid), KErrNotFound );

        aIter.Reset();
        }
    }

void MT_AiContentItemArrayIterator::TestManyL(  )
    {
    const TInt KTestId1 = 42;
    static const wchar_t KTestCid1[] = L"testcid1";
    static const char KTestType1[] = "testtype1";
    const TInt KTestId2 = 53;
    static const wchar_t KTestCid2[] = L"testcid2";
    static const char KTestType2[] = "testtype2";
    static const TAiContentItem KTwoItems[] = 
        { 
        { KTestId1, KTestCid1, KTestType1 },
        { KTestId2, KTestCid2, KTestType2 } 
        };
    
    // Test iterator created with NewL
    MAiContentItemIterator* iter =
        AiUtility::CreateContentItemArrayIteratorL(KTwoItems, 2);
    CleanupReleasePushL(iter);
    DoTestManyL( KTwoItems[0], *iter, 2 );
    DoTestManyL( KTwoItems[1], *iter, 2 );
    CleanupStack::PopAndDestroy(iter);
    
    // Test iterator created with template helper
    iter = AiUtility::CreateContentItemArrayIteratorL(KTwoItems);
    CleanupReleasePushL(iter);
    DoTestManyL( KTwoItems[0], *iter, 2 );
    DoTestManyL( KTwoItems[1], *iter, 2 );
    CleanupStack::PopAndDestroy(iter);
    }

//  TEST TABLE

EUNIT_BEGIN_TEST_TABLE(
    MT_AiContentItemArrayIterator,
    "Unit test suite for MAiContentItemIterator implementation returned from AiUtility::CreateContentItemArrayIteratorL",
    "CAiContentItemArrayIterator" )

EUNIT_TEST(
    "Test empty (NULL) array",
    "MAiContentItemIterator",
    "All",
    "FUNCTIONALITY",
    SetupL, TestEmptyL, Teardown)

EUNIT_TEST(
    "Test array with one item",
    "MAiContentItemIterator",
    "All",
    "FUNCTIONALITY",
    SetupL, TestOneL, Teardown)

EUNIT_TEST(
    "Test array with multiple items",
    "MAiContentItemIteratore",
    "All",
    "FUNCTIONALITY",
    SetupL, TestManyL, Teardown)

EUNIT_END_TEST_TABLE

//  END OF FILE