/*

* Copyright (c) 2006-2006 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:   Thumbnail availability filter task unit tests.

*

*/

//  CLASS HEADER

#include "ut_cglxtnfilteravailabletask.h"

//  EXTERNAL INCLUDES

#include <EUnitMacros.h>

#include <EUnitDecorators.h>

#include <fbs.h>

#include <Ecom\ECom.h>

//  INTERNAL INCLUDES

#include "glxtnfilteravailabletask.h"

#include "dummytaskmanager.h"

const TUint KGlxMediaIdWithThumbnail = 1;

const TUint KGlxMediaIdWithoutThumbnail = 2;

const TInt KTestSizeWidth = 320;

const TInt KTestSizeHeight = 240;

// ---------------------------------------------------------------------------

// CONSTRUCTION

UT_CGlxtnFilterAvailableTask* UT_CGlxtnFilterAvailableTask::NewL()

    {

    UT_CGlxtnFilterAvailableTask* self = UT_CGlxtnFilterAvailableTask::NewLC();

    CleanupStack::Pop();

    return self;

    }

UT_CGlxtnFilterAvailableTask* UT_CGlxtnFilterAvailableTask::NewLC()

    {

    UT_CGlxtnFilterAvailableTask* self = new( ELeave ) UT_CGlxtnFilterAvailableTask();

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

// Destructor (virtual by CBase)

UT_CGlxtnFilterAvailableTask::~UT_CGlxtnFilterAvailableTask()

    {

    }

// Default constructor

UT_CGlxtnFilterAvailableTask::UT_CGlxtnFilterAvailableTask()

    {

    }

// Second phase construct

void UT_CGlxtnFilterAvailableTask::ConstructL()

    {

    // The ConstructL from the base class CEUnitTestSuiteClass must be called.

    // It generates the test case table.

    CEUnitTestSuiteClass::ConstructL();

    }

//  METHODS

void UT_CGlxtnFilterAvailableTask::ThumbnailFetchComplete(

    const TGlxMediaId& /*aItemId*/, TGlxThumbnailQuality /*aQuality*/, TInt /*aErrorCode*/)

    {

    EUNIT_FAIL_TEST("ThumbnailFetchComplete() called");

    }

void UT_CGlxtnFilterAvailableTask::ThumbnailDeletionComplete(

                                const TGlxMediaId& /*aItemId*/, TInt /*aErrorCode*/)

    {

    EUNIT_FAIL_TEST("ThumbnailDeletionComplete() called");

    }

void UT_CGlxtnFilterAvailableTask::FilterAvailableComplete(

                        const RArray<TGlxMediaId>& aIdArray, TInt aErrorCode )

    {

    EUNIT_ASSERT( KErrNotFound == aIdArray.Find(

                                    TGlxMediaId(KGlxMediaIdWithThumbnail)) );

    EUNIT_ASSERT( KErrNotFound != aIdArray.Find(

                                    TGlxMediaId(KGlxMediaIdWithoutThumbnail)) );

    iError = aErrorCode;

    }

void UT_CGlxtnFilterAvailableTask::FetchFileInfoL(CGlxtnFileInfo* /*aInfo*/,

                        const TGlxMediaId& /*aItemId*/, TRequestStatus* aStatus)

    {

    *aStatus = KRequestPending;

    User::RequestComplete(aStatus, KErrNone);

    }

void UT_CGlxtnFilterAvailableTask::CancelFetchUri(const TGlxMediaId& /*aItemId*/)

    {

    }

MGlxtnThumbnailStorage* UT_CGlxtnFilterAvailableTask::ThumbnailStorage()

    {

    return this;

    }

void UT_CGlxtnFilterAvailableTask::LoadThumbnailDataL(HBufC8*& /*aData*/, TGlxImageDataFormat& /*aFormat*/,

            const TGlxMediaId& /*aId*/, const CGlxtnFileInfo& /*aFileInfo*/,

            const TSize& /*aSize*/, TRequestStatus* /*aStatus*/)

    {

    EUNIT_FAIL_TEST("FilterAvailableComplete() called");

    }

void UT_CGlxtnFilterAvailableTask::SaveThumbnailDataL(const TDesC8& /*aData*/,

            TGlxImageDataFormat /*aFormat*/, const TGlxMediaId& /*aId*/,

            const CGlxtnFileInfo& /*aFileInfo*/, const TSize& /*aSize*/,

            TRequestStatus* /*aStatus*/)

    {

    EUNIT_FAIL_TEST("FilterAvailableComplete() called");

    }

void UT_CGlxtnFilterAvailableTask::DeleteThumbnailsL(const TGlxMediaId& /*aId*/,

            const CGlxtnFileInfo& /*aFileInfo*/, TRequestStatus* /*aStatus*/)

    {

    EUNIT_FAIL_TEST("FilterAvailableComplete() called");

    }

void UT_CGlxtnFilterAvailableTask::CleanupThumbnailsL(TRequestStatus* /*aStatus*/)

    {

    EUNIT_FAIL_TEST("FilterAvailableComplete() called");

    }

void UT_CGlxtnFilterAvailableTask::IsThumbnailAvailableL(const TGlxMediaId& aId,

            const CGlxtnFileInfo& /*aFileInfo*/,

            const TSize& aSize, TRequestStatus* aStatus)

    {

    TInt result = (KGlxMediaIdWithThumbnail == aId.Value())

                    ? KGlxThumbnailAvailable : KGlxThumbnailNotAvailable;

    EUNIT_ASSERT_EQUALS( aSize, iSize );

    *aStatus = KRequestPending;

    User::RequestComplete(aStatus, result);

    }

void UT_CGlxtnFilterAvailableTask::StorageCancel()

    {

    }

void UT_CGlxtnFilterAvailableTask::NotifyBackgroundError(

            const TGlxMediaId& /*aId*/, TInt /*aError*/)

    {

    EUNIT_FAIL_TEST("NotifyBackgroundError() called");

    }

void UT_CGlxtnFilterAvailableTask::SetupL()

    {

    iSize.SetSize(KTestSizeWidth, KTestSizeHeight);

    RArray<TGlxMediaId> array;

    CleanupClosePushL(array);

    array.AppendL(TGlxMediaId(KGlxMediaIdWithThumbnail));

    array.AppendL(TGlxMediaId(KGlxMediaIdWithoutThumbnail));

    iFilterAvailableTask = CGlxtnFilterAvailableTask::NewL(array.Array(),

                                                            iSize, *this);

    CleanupStack::PopAndDestroy(&array);

    }

void UT_CGlxtnFilterAvailableTask::Teardown()

    {

    delete iFilterAvailableTask;

    }

void UT_CGlxtnFilterAvailableTask::UT_CGlxtnFilterAvailableTask_ConstructL()

    {

    // Check the task was correctly constructed

    EUNIT_ASSERT( NULL != iFilterAvailableTask );

    EUNIT_ASSERT_EQUALS( iFilterAvailableTask->Id().Value(), KGlxtnTaskIdFilterAvailable );

    EUNIT_ASSERT_EQUALS( iFilterAvailableTask->Storage(), this );

    }

void UT_CGlxtnFilterAvailableTask::UT_CGlxtnFilterAvailableTask_FilterL()

    {

    CDummyTaskManager* tm = new (ELeave) CDummyTaskManager(iFilterAvailableTask);

    CleanupStack::PushL(tm);

    tm->StartTaskL();

    User::LeaveIfError(iError);

    CleanupStack::PopAndDestroy(tm);

    }

//  TEST TABLE

EUNIT_BEGIN_TEST_TABLE(

    UT_CGlxtnFilterAvailableTask,

    "Unit tests for CGlxtnFilterAvailableTask.",

    "UNIT" )

EUNIT_TEST(

    "Test construction of CGlxtnFilterAvailableTask",

    "CGlxtnFilterAvailableTask",

    "NewL",

    "FUNCTIONALITY",

    SetupL, UT_CGlxtnFilterAvailableTask_ConstructL, Teardown)

EUNIT_TEST(

    "Test filtering of ID array",

    "CGlxtnFilterAvailableTask",

    "StartL",

    "FUNCTIONALITY",

    SetupL, UT_CGlxtnFilterAvailableTask_FilterL, Teardown)

EUNIT_ALLOC_TEST(

    "Test alloc failures",

    "CGlxtnFilterAvailableTask",

    "StartL",

    "ERRORHANDLING",

    SetupL, UT_CGlxtnFilterAvailableTask_FilterL, Teardown)

EUNIT_END_TEST_TABLE

//  END OF FILE