/*

* Copyright (c) 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 "ut_logsremovestates.h"

#include "logsremovestates.h"

#include "logclient_stubs_helper.h"

#include "logsmodel.h"

#include <logcli.h>

#include <logview.h>

#include <QtTest/QtTest>

void UT_LogsRemoveStates::initTestCase()

{

    int rfsDummy = 0;

    mLogClient = CLogClient::NewL( *((RFs*)&rfsDummy) );

}

void UT_LogsRemoveStates::cleanupTestCase()

{

    delete mLogClient;

}

void UT_LogsRemoveStates::init()

{

    reset();

    mCurrentState = 0;

    mIndex = 0;

    mLogView = 0;

    mLogViewEvent = 0;

    mIsRecentView = true;

    mLogView = CLogViewRecent::NewL(*mLogClient);

    mLogViewEvent = 0;

    mDuplicatesView = CLogViewDuplicate::NewL(*mLogClient);

}

void UT_LogsRemoveStates::cleanup()

{

    delete mLogView;

    mLogView = 0;

    delete mLogViewEvent;

    mLogViewEvent = 0;

    delete mDuplicatesView;

    mDuplicatesView = 0;  

}

void UT_LogsRemoveStates::reset()

{

    mRemoveCompleted = false;

    mClearType = -1;

    mRemovedEvents.clear();

}

void UT_LogsRemoveStates::testClearAll()

{

    LogsRemoveStateClearAll state(*this, *this);

    mClearType = LogsModel::TypeLogsClearAll;

    QVERIFY( state.enterL() );

    QCOMPARE( LogClientStubsHelper::lastCalledFunc(), QString("ClearLog") );

    mClearType = LogsModel::TypeLogsClearMissed;

    QVERIFY( state.enterL() );

    QCOMPARE( LogClientStubsHelper::lastCalledFunc(), QString("ClearLogRecentList") );

    QVERIFY( !state.continueL() );

}

void UT_LogsRemoveStates::testInit()

{

    LogsRemoveStateInit state(*this, *this);

    // Nothing happens when no recent view exists

    mIsRecentView = false;

    QVERIFY( !state.enterL() );

    // Recent view exists and is getting initialized

    mIndex = 4;

    mIsRecentView = true;

    QVERIFY( state.enterL() );

    QCOMPARE( mIndex, 0 );

    QVERIFY( !state.continueL() );

}

void UT_LogsRemoveStates::testDelete()

{

    LogsRemoveStateDelete state(*this, *this);

    // Nothing to delete

    QVERIFY( !state.enterL() );

    // Delete several

    mRemovedEvents.append(1);

    mRemovedEvents.append(3);

    mRemovedEvents.append(4);

    QVERIFY( state.enterL() );

    QCOMPARE( state.mRemoveIndex, 1 );

    QVERIFY( state.continueL() );

    QCOMPARE( state.mRemoveIndex, 2 );

    QVERIFY( state.continueL() );

    QCOMPARE( state.mRemoveIndex, 3 );

    QVERIFY( !state.continueL() );

}

void UT_LogsRemoveStates::testDeleteDuplicates()

{

    LogsRemoveStateDeleteDuplicates state(*this, *this);

    // More than one id, duplicate deletion not supported

    mRemovedEvents.append(1);

    mRemovedEvents.append(3);

    QVERIFY( !state.enterL() );

    // Dbview iterator is not at correct location

    mRemovedEvents.clear();

    mRemovedEvents.append(99);

    const_cast<CLogEvent&>( mLogView->Event() ).SetId( 100 );

    QVERIFY( !state.enterL() );

    // No duplicates

    LogClientStubsHelper::setStubAsyncCallPossible(false);

    LogClientStubsHelper::setViewCount(0); // effective also for duplicates view

    const_cast<CLogEvent&>( mLogView->Event() ).SetId( 99 );

    QVERIFY( !state.enterL() );

    // Duplicates

    LogClientStubsHelper::setStubAsyncCallPossible(true);

    LogClientStubsHelper::setViewCount(3); // effective also for duplicates view

    QVERIFY( state.enterL() );

    QVERIFY( !state.mDeleting );

    QCOMPARE( state.mDeleteDuplicateIds.count(), 0 );

    QVERIFY( state.continueL() );

    QVERIFY( !state.mDeleting );

    QCOMPARE( state.mDeleteDuplicateIds.count(), 0 );

    QVERIFY( state.continueL() );

    QVERIFY( !state.mDeleting );

    QCOMPARE( state.mDeleteDuplicateIds.count(), 1 );

    QVERIFY( state.continueL() );

    QVERIFY( !state.mDeleting );

    QCOMPARE( state.mDeleteDuplicateIds.count(), 2 );

    QVERIFY( state.continueL() );

    QVERIFY( !state.mDeleting );

    QCOMPARE( state.mDeleteDuplicateIds.count(), 3 );

    QVERIFY( state.continueL() );

    QVERIFY( state.mDeleting );

    QCOMPARE( state.mDeleteDuplicateIds.count(), 2 );

    QVERIFY( state.continueL() );

    QVERIFY( state.mDeleting );

    QCOMPARE( state.mDeleteDuplicateIds.count(), 1 );

    QVERIFY( state.continueL() );

    QVERIFY( state.mDeleting );

    QCOMPARE( state.mDeleteDuplicateIds.count(), 0 );

    QVERIFY( !state.continueL() );

}

void UT_LogsRemoveStates::testDone()

{

    LogsRemoveStateDone state(*this, *this);

    QVERIFY( !mRemoveCompleted );

    QVERIFY( !state.enterL() );

    QVERIFY( mRemoveCompleted );

}

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

// From LogsStateBaseContext

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

//

void UT_LogsRemoveStates::setCurrentState(const LogsStateBase& state)

{

    mCurrentState = &state;

}

CLogView& UT_LogsRemoveStates::logView()

{

    if ( mIsRecentView ){

        return *mLogView;

    }

    return *mLogViewEvent;

}

CLogViewDuplicate& UT_LogsRemoveStates::duplicatesView()

{

    return *mDuplicatesView;

}

int& UT_LogsRemoveStates::index()

{

    return mIndex;

}

TRequestStatus& UT_LogsRemoveStates::reqStatus()

{

    return mReqStatus;

}

int UT_LogsRemoveStates::currentEventId()

{

    if ( !mRemovedEvents.isEmpty() ){

        return mRemovedEvents.at(0);

    }

    return mCurrentEventId;

}

CLogClient& UT_LogsRemoveStates::logClient()

{

    return *mLogClient;

}

bool UT_LogsRemoveStates::isRecentView()

{

    return mIsRecentView;

}

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

// From LogsRemoveStateContext

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

//

LogsRemoveObserver& UT_LogsRemoveStates::observer()

{

    return *this;

}

QList<int>& UT_LogsRemoveStates::removedEvents()

{

    return mRemovedEvents;

}

int UT_LogsRemoveStates::clearType()

{

    return mClearType;

}

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

// From LogsRemoveObserver

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

//

void UT_LogsRemoveStates::removeCompleted()

{

    mRemoveCompleted = true;

}

void UT_LogsRemoveStates::logsRemoveErrorOccured(int err)

{

    mError = err;

}