/*

* 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 <PsetContainer.h>

#include <mpsetcliobserver.h>

#include <psetwrappertypes.h>

#include <PsetCli.h>

#include <psuiconstants.h>

#include "ut_psetcliwrapper.h"

#include "testutilities.h"

#define private public

#include "psetcliwrapper.h"

#include "psetcliwrapper_p.h"

class CliObserver : public MPsetCliObserver

{

    void SetEngineContact( MPsetCli* aEngine )

    {

        Q_UNUSED(aEngine);

    }

    void HandleCliRequestingL( TBool aOngoing, 

        TBool aInterrupted )

    {

        Q_UNUSED(aOngoing);

        Q_UNUSED(aInterrupted);

    }

    void CliInformationL( TPsuiCli aType )

    {

        Q_UNUSED(aType);

    }

    void HandleCliStatusL( TUint8 aBsc[KPSetNumberOfBsc], TPsuiCli aMode )

    {

        Q_UNUSED(aBsc);

        Q_UNUSED(aMode);

    }

    void HandleCnapStatusL( TInt aStatus )

    {

        Q_UNUSED(aStatus);

    }

    void HandleCliErrorL( TInt aError )

    {

        Q_UNUSED(aError);

    }

};

void SimulateLeaveL()

{

    User::Leave(KErrGeneral);

}

/*!

  UT_PSetCliWrapper::UT_PSetCliWrapper

 */

UT_PSetCliWrapper::UT_PSetCliWrapper()

    :

    m_numOfLeaveSimulations(0),

    m_psetContainerMock(NULL),

    m_wrapper(NULL),

    m_cliMock(NULL)

{

}

/*!

  UT_PSetCliWrapper::~UT_PSetCliWrapper

 */

UT_PSetCliWrapper::~UT_PSetCliWrapper()

{

    delete m_psetContainerMock;

    delete m_wrapper;

    m_cliMock = NULL;

}

/*!

  UT_PSetCliWrapper::init

 */

void UT_PSetCliWrapper::init()

{

    initialize();

    m_numOfLeaveSimulations = 0;

    m_psetContainerMock = new CPsetContainer();

    RMobilePhone dummyHandle;

    CliObserver dummyObserver;

    QT_TRAP_THROWING(m_cliMock = 

        CPsetCli::NewL(dummyHandle, dummyObserver));

    expect("CPsetContainer::CreateCliObjectL").returns(m_cliMock);

    // wrapper takes ownership of callDivertingMock during successfull

    // construction.

    QScopedPointer<CPsetCli> cliMockPtr(m_cliMock);

    m_wrapper = new PSetCliWrapper(*m_psetContainerMock, NULL);

    cliMockPtr.take();

}

/*!

  UT_PSetCliWrapper::cleanup

 */

void UT_PSetCliWrapper::cleanup()

{

    reset();

    delete m_psetContainerMock;

    m_psetContainerMock = NULL;

    delete m_wrapper;

    m_wrapper = NULL;

    m_cliMock = NULL;

}

/*!

  UT_PSetCliWrapper::t_construction

 */

void UT_PSetCliWrapper::t_construction()

{

    if (qstrcmp(QTest::currentTestFunction(), "t_exceptionSafety") != 0) {

        expect("CPsetContainer::CreateCliObjectL").

            willOnce(invokeWithoutArguments(SimulateLeaveL));

        PSetCliWrapper *wrapper = NULL;

        EXPECT_EXCEPTION(

            wrapper = new PSetCliWrapper(*m_psetContainerMock, NULL);

        )

        delete wrapper;

        QVERIFY(verify());

    }

}

/*!

  UT_PSetCliWrapper::t_getColpMode

 */

void UT_PSetCliWrapper::t_getColpMode()

{

    expect("CPsetCli::GetColpModeL").

        willOnce(invokeWithoutArguments(this, &SimulateLeaveAtMockMethodCallL));

    EXPECT_EXCEPTION(

        m_wrapper->getColpMode();

    )

    QVERIFY(1 == m_numOfLeaveSimulations);

    QVERIFY(true == verify());

}

/*!

  UT_PSetCliWrapper::t_getClipMode

 */

void UT_PSetCliWrapper::t_getClipMode()

{

    expect("CPsetCli::GetClipModeL").

        willOnce(invokeWithoutArguments(this, &SimulateLeaveAtMockMethodCallL));

    EXPECT_EXCEPTION(

        m_wrapper->getClipMode();

    )

    QVERIFY(1 == m_numOfLeaveSimulations);

    QVERIFY(true == verify());

}

/*!

  UT_PSetCliWrapper::t_getClirMode

 */

void UT_PSetCliWrapper::t_getClirMode()

{

    expect("CPsetCli::GetClirModeL").

        willOnce(invokeWithoutArguments(this, &SimulateLeaveAtMockMethodCallL));

    EXPECT_EXCEPTION(

        m_wrapper->getClirMode();

    )

    QVERIFY(1 == m_numOfLeaveSimulations);

    QVERIFY(true == verify());

}

/*!

  UT_PSetCliWrapper::t_getColrMode

 */

void UT_PSetCliWrapper::t_getColrMode()

{

    expect("CPsetCli::GetColrModeL").

        willOnce(invokeWithoutArguments(this, &SimulateLeaveAtMockMethodCallL));

    EXPECT_EXCEPTION(

        m_wrapper->getColrMode();

    )

    QVERIFY(1 == m_numOfLeaveSimulations);

    QVERIFY(true == verify());

}

/*!

  UT_PSetCliWrapper::t_getCnap

 */

void UT_PSetCliWrapper::t_getCnap()

{

    expect("CPsetCli::GetCnapL").

        willOnce(invokeWithoutArguments(this, &SimulateLeaveAtMockMethodCallL));

    EXPECT_EXCEPTION(

        m_wrapper->getCnap();

    )

    QVERIFY(1 == m_numOfLeaveSimulations);

    QVERIFY(true == verify());

}

/*!

  UT_PSetCliWrapper::t_cancelAll

 */

void UT_PSetCliWrapper::t_cancelAll()

{

    expect("CPsetCli::CancelAll");

    m_wrapper->cancelAll();

    QVERIFY(true == verify());

}

/*!

  UT_PSetCliWrapper::t_handleCliRequesting

 */

void UT_PSetCliWrapper::t_handleCliRequesting()

{

    QSignalSpy spy(m_wrapper, SIGNAL(handleCliRequesting(bool, bool)));

    TBool isOngoing = ETrue;

    TBool isInterrupted = ETrue;

    QT_TRAP_THROWING(

        m_wrapper->m_privateImpl->HandleCliRequestingL(isOngoing, isInterrupted));

    const int expectednumOfSignalEmissions = 1;

    const int expectedNumOfSignalArguments = 2;

    QCOMPARE(spy.count(), expectednumOfSignalEmissions);

    const QList<QVariant> &arguments = spy.at(0);

    QVERIFY(expectedNumOfSignalArguments == arguments.count());

    QVERIFY(ETrue == arguments.at(0).toBool());

    QVERIFY(ETrue == arguments.at(1).toBool());

}

/*!

  UT_PSetCliWrapper::t_cliInformation

 */

Q_DECLARE_METATYPE(PsCallLineIdentity)

void UT_PSetCliWrapper::t_cliInformation()

{

    qRegisterMetaType<PsCallLineIdentity>("PsCallLineIdentity");

    QSignalSpy spy(m_wrapper, SIGNAL(cliInformation(PsCallLineIdentity)));

    QT_TRAP_THROWING(m_wrapper->m_privateImpl->CliInformationL(EPsuiClirOn));

    const int expectednumOfSignalEmissions = 1;

    const int expectedNumOfSignalArguments = 1;

    QCOMPARE(spy.count(), expectednumOfSignalEmissions);

    const QList<QVariant> &arguments = spy.at(0);

    QVERIFY(expectedNumOfSignalArguments == arguments.count());

    QVERIFY(ClirOn == arguments.at(0).value<PsCallLineIdentity>());

}

/*!

  UT_PSetCliWrapper::t_handleCliStatus

 */

Q_DECLARE_METATYPE(unsigned char *)

void UT_PSetCliWrapper::t_handleCliStatus()

{

    qRegisterMetaType<unsigned char *>("unsigned char *");

    QSignalSpy spy(m_wrapper, 

        SIGNAL(handleCliStatus(unsigned char *, int, PsCallLineIdentity)));

    TUint8 bscList[KPSetNumberOfBsc] = { EAllTele };

    QT_TRAP_THROWING(

        m_wrapper->m_privateImpl->HandleCliStatusL(bscList, EPsuiClirOn));

    const int expectednumOfSignalEmissions = 1;

    const int expectedNumOfSignalArguments = 3;

    QCOMPARE(spy.count(), expectednumOfSignalEmissions);

    const QList<QVariant> &arguments = spy.at(0);

    QVERIFY(expectedNumOfSignalArguments == arguments.count());

    QVERIFY(EAllTele == arguments.at(0).value<unsigned char *>()[0]);

    QVERIFY(KPSetNumberOfBsc == arguments.at(1).toInt());

    QVERIFY(ClirOn == arguments.at(2).value<PsCallLineIdentity>());

}

/*!

  UT_PSetCliWrapper::t_handleCnapStatus

 */

void UT_PSetCliWrapper::t_handleCnapStatus()

{

    QSignalSpy spy(m_wrapper, SIGNAL(handleCnapStatus(int)));

    const int status = 1;

    QT_TRAP_THROWING(m_wrapper->m_privateImpl->HandleCnapStatusL(status));

    const int expectednumOfSignalEmissions = 1;

    const int expectedNumOfSignalArguments = 1;

    QCOMPARE(spy.count(), expectednumOfSignalEmissions);

    const QList<QVariant> &arguments = spy.at(0);

    QVERIFY(expectedNumOfSignalArguments == arguments.count());

    QVERIFY(status == arguments.at(0).toInt());

}

/*!

  UT_PSetCliWrapper::t_handleCliError

 */

void UT_PSetCliWrapper::t_handleCliError()

{

    QSignalSpy spy(m_wrapper, SIGNAL(handleCliError(int)));

    const int expectedErrorCode = KErrGeneral;

    QT_TRAP_THROWING(m_wrapper->m_privateImpl->HandleCliErrorL(expectedErrorCode));

    const int expectednumOfSignalEmissions = 1;

    const int expectedNumOfSignalArguments = 1;

    QCOMPARE(spy.count(), expectednumOfSignalEmissions);

    const QList<QVariant> &arguments = spy.at(0);

    QVERIFY(expectedNumOfSignalArguments == arguments.count());

    QVERIFY(expectedErrorCode == arguments.at(0).toInt());

}

/*!

  UT_PSetCliWrapper::t_setEngineContact

 */

void UT_PSetCliWrapper::t_setEngineContact()

{

    // dummy test as no real implementation for the method currently

    m_wrapper->m_privateImpl->SetEngineContact(NULL);

}

/*!

  UT_PSetCliWrapper::t_exceptionSafety

 */

void UT_PSetCliWrapper::t_exceptionSafety()

{

    cleanup();

    OomTestExecuter::runAllTests(*this, "t_exceptionSafety");

}

void UT_PSetCliWrapper::SimulateLeaveAtMockMethodCallL()

{

    m_numOfLeaveSimulations++;

    User::Leave( KErrGeneral );

}

QTEST_MAIN_S60(UT_PSetCliWrapper)