/*

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

#include <PsetContainer.h>

#include <mpsetcallwaitingobs.h>

#include "ut_psetcallwaitingwrapper.h"

#include "testutilities.h"

#define private public

#include "psetcallwaitingwrapper.h"

#include "psetcallwaitingwrapper_p.h"

class WaitingObserver : public MPsetCallWaitingObserver

{

    void HandleCallWaitingGetStatusL( 

        const MPsetCallWaiting::TGetCallWaitingStatus aStatus, 

        TUint8 aBsc[KPSetNumberOfBsc])

    {

        Q_UNUSED(aStatus);

        Q_UNUSED(aBsc);

    }

    void HandleCallWaitingChangedL( 

        const MPsetCallWaiting::TSetCallWaiting aSetting, 

        const TInt aResult)

    {

        Q_UNUSED(aSetting);

        Q_UNUSED(aResult);

    }

    void HandleCWRequestingL(

        TBool aOngoing, 

        TBool aInterrupted)

    {

        Q_UNUSED(aOngoing);

        Q_UNUSED(aInterrupted);

    }

    void HandleCWErrorL(

        TInt aReason)

    {

        Q_UNUSED(aReason);

    }

    void SetEngineContact(

        MPsetCallWaiting& aEngineContact)

    {

        Q_UNUSED(aEngineContact);

    }

};

void SimulateLeaveL()

{

    User::Leave(KErrGeneral);

}

/*!

  UT_PSetCallWaitingWrapper::UT_PSetCallWaitingWrapper

 */

UT_PSetCallWaitingWrapper::UT_PSetCallWaitingWrapper()

    :

    m_numOfLeaveSimulations(0),

    m_psetContainerMock(NULL),

    m_psetCallWaitingMock(NULL),

    m_wrapper(NULL)

{

}

/*!

  UT_PSetCallWaitingWrapper::~UT_PSetCallWaitingWrapper

 */

UT_PSetCallWaitingWrapper::~UT_PSetCallWaitingWrapper()

{

    delete m_psetContainerMock;

    m_psetCallWaitingMock = NULL;

    delete m_wrapper;

}

/*!

  UT_PSetCallWaitingWrapper::init

 */

void UT_PSetCallWaitingWrapper::init()

{

    initialize();

    m_numOfLeaveSimulations = 0;

    m_psetContainerMock = new CPsetContainer();

    RMobilePhone dummyHandle;

    WaitingObserver dummyObserver;

    QT_TRAP_THROWING(m_psetCallWaitingMock = 

        CPsetCallWaiting::NewL(dummyHandle, dummyObserver));

    expect("CPsetContainer::CreateCWObjectL").returns(m_psetCallWaitingMock);

    // wrapper takes ownership of callDivertingMock during successful 

    // construction

    QScopedPointer<CPsetCallWaiting> callWaitingMockPtr(m_psetCallWaitingMock);

    m_wrapper = new PSetCallWaitingWrapper(*m_psetContainerMock, NULL);

    callWaitingMockPtr.take();

}

/*!

  UT_PSetCallWaitingWrapper::cleanup

 */

void UT_PSetCallWaitingWrapper::cleanup()

{

    reset();

    delete m_psetContainerMock;

    m_psetContainerMock = NULL;

    m_psetCallWaitingMock = NULL;

    delete m_wrapper;

    m_wrapper = NULL;

}

/*!

  UT_PSetCallWaitingWrapper::t_construction

 */

void UT_PSetCallWaitingWrapper::t_construction()

{

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

        expect("CPsetContainer::CreateCWObjectL").

            willOnce(invokeWithoutArguments(SimulateLeaveL));

        PSetCallWaitingWrapper *wrapper = NULL;

        EXPECT_EXCEPTION(

            wrapper = new PSetCallWaitingWrapper(*m_psetContainerMock, NULL);

        )

        delete wrapper;

        QVERIFY(verify());

    }

}

/*!

  UT_PSetCallWaitingWrapper::t_setCallWaiting

 */

void UT_PSetCallWaitingWrapper::t_setCallWaiting()

{

    TBasicServiceGroups basicServiceGroup = EAllTele;

    expect("CPsetCallWaiting::SetCallWaitingL").

        with(MPsetCallWaiting::EActivateCallWaiting, basicServiceGroup);

    expect("CPsetCallWaiting::SetCallWaitingL").

        with(MPsetCallWaiting::EDeactivateCallWaiting, basicServiceGroup);

    int invalidEnumeration = -1; 

    expect("CPsetCallWaiting::SetCallWaitingL").

        with(static_cast<MPsetCallWaiting::TSetCallWaiting>(invalidEnumeration), basicServiceGroup).

        willOnce(invokeWithoutArguments(this, &SimulateLeaveAtMockMethodCallL));

    m_wrapper->setCallWaiting(

        PSetCallWaitingWrapper::ActivateCallWaiting,

        basicServiceGroup);

    m_wrapper->setCallWaiting(

        PSetCallWaitingWrapper::DeactivateCallWaiting,

        basicServiceGroup);

    EXPECT_EXCEPTION(

        m_wrapper->setCallWaiting(

            static_cast<PSetCallWaitingWrapper::PsCallWaitingCommand>(invalidEnumeration),

            basicServiceGroup);

    )

    QVERIFY(1 == m_numOfLeaveSimulations);

    QVERIFY(true == verify());

}

/*!

  UT_PSetCallWaitingWrapper::t_getCallWaitingStatus

 */

void UT_PSetCallWaitingWrapper::t_getCallWaitingStatus()

{

    expect("CPsetCallWaiting::GetCallWaitingStatusL").

        willOnce(invoke(this, &SimulateLeaveAtMockMethodCallL));

    EXPECT_EXCEPTION(

        m_wrapper->getCallWaitingStatus();

    )

    QVERIFY(true == verify());

}

/*!

  UT_PSetCallWaitingWrapper::t_cancelProcess

 */

void UT_PSetCallWaitingWrapper::t_cancelProcess()

{

    expect("CPsetCallWaiting::CancelProcess");

    m_wrapper->cancelProcess();

    QVERIFY(true == verify());

}

/*!

  UT_PSetCallWaitingWrapper::t_handleCallWaitingGetStatus

 */

Q_DECLARE_METATYPE(PSetCallWaitingWrapper::PsCallWaitingStatus)

Q_DECLARE_METATYPE(QList<unsigned char>)

void UT_PSetCallWaitingWrapper::t_handleCallWaitingGetStatus()

{

    qRegisterMetaType<PSetCallWaitingWrapper::PsCallWaitingStatus>

        ("PSetCallWaitingWrapper::PsCallWaitingStatus");

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

    QSignalSpy spy(m_wrapper, SIGNAL(handleCallWaitingGetStatus(

        PSetCallWaitingWrapper::PsCallWaitingStatus, const QList<unsigned char> &)));

    MPsetCallWaiting::TGetCallWaitingStatus status =

        MPsetCallWaiting::EStatusActive; 

    TUint8 bscList[KPSetNumberOfBsc];

    bscList[0] = EAllTele;

    bscList[1] = KPSetUnusedValue;

    QT_TRAP_THROWING(

        m_wrapper->m_privateImpl->HandleCallWaitingGetStatusL(status, bscList));

    status = MPsetCallWaiting::EStatusDisabled;

    QT_TRAP_THROWING(

        m_wrapper->m_privateImpl->HandleCallWaitingGetStatusL(status, bscList));

    status = MPsetCallWaiting::EStatusNotAvailable;

    QT_TRAP_THROWING(

        m_wrapper->m_privateImpl->HandleCallWaitingGetStatusL(status, bscList));

    status = MPsetCallWaiting::EStatusNotProvisioned;

    QT_TRAP_THROWING(

        m_wrapper->m_privateImpl->HandleCallWaitingGetStatusL(status, bscList));

    status = MPsetCallWaiting::EStatusUnknown;

    QT_TRAP_THROWING(

        m_wrapper->m_privateImpl->HandleCallWaitingGetStatusL(status, bscList));

    const int expectedNumOfSignalEmissions = 5;

    QCOMPARE(spy.count(), expectedNumOfSignalEmissions);

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

    QVERIFY(PSetCallWaitingWrapper::StatusActive == 

        arguments.at(0).value<PSetCallWaitingWrapper::PsCallWaitingStatus>());

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

    QVERIFY(PSetCallWaitingWrapper::StatusDisabled == 

        spy.at(1).at(0).value<PSetCallWaitingWrapper::PsCallWaitingStatus>());

    QVERIFY(EAllTele == spy.at(1).at(1).value<QList<unsigned char> >()[0]);

    QVERIFY(PSetCallWaitingWrapper::StatusNotAvailable == 

        spy.at(2).at(0).value<PSetCallWaitingWrapper::PsCallWaitingStatus>());

    QVERIFY(EAllTele == spy.at(2).at(1).value<QList<unsigned char> >()[0]);

    QVERIFY(PSetCallWaitingWrapper::StatusNotProvisioned == 

        spy.at(3).at(0).value<PSetCallWaitingWrapper::PsCallWaitingStatus>());

    QVERIFY(EAllTele == spy.at(3).at(1).value<QList<unsigned char> >()[0]);

    QVERIFY(PSetCallWaitingWrapper::StatusUnknown == 

        spy.at(4).at(0).value<PSetCallWaitingWrapper::PsCallWaitingStatus>());

    QVERIFY(EAllTele == spy.at(4).at(1).value<QList<unsigned char> >()[0]);

}

/*!

  UT_PSetCallWaitingWrapper::t_handleCallWaitingChanged

 */

Q_DECLARE_METATYPE(PSetCallWaitingWrapper::PsCallWaitingCommand)

void UT_PSetCallWaitingWrapper::t_handleCallWaitingChanged()

{

    qRegisterMetaType<PSetCallWaitingWrapper::PsCallWaitingCommand>

        ("PSetCallWaitingWrapper::PsCallWaitingCommand");

    QSignalSpy spy(m_wrapper, SIGNAL(handleCallWaitingChanged(

        PSetCallWaitingWrapper::PsCallWaitingCommand, int)));

    QT_TRAP_THROWING(

        m_wrapper->m_privateImpl->HandleCallWaitingChangedL(

            MPsetCallWaiting::EActivateCallWaiting, KErrNone));

    QT_TRAP_THROWING(

        m_wrapper->m_privateImpl->HandleCallWaitingChangedL(

            MPsetCallWaiting::EDeactivateCallWaiting, KErrNone));

    const int expectedNumOfSignalEmissions = 2;

    QCOMPARE(spy.count(), expectedNumOfSignalEmissions);

    QVERIFY(PSetCallWaitingWrapper::ActivateCallWaiting == 

        spy.at(0).at(0).value<PSetCallWaitingWrapper::PsCallWaitingCommand>());

    QVERIFY(KErrNone == spy.at(0).at(1).toInt());

    QVERIFY(PSetCallWaitingWrapper::DeactivateCallWaiting == 

        spy.at(1).at(0).value<PSetCallWaitingWrapper::PsCallWaitingCommand>());

    QVERIFY(KErrNone == spy.at(1).at(1).toInt());

}

/*!

  UT_PSetCallWaitingWrapper::t_handleCallWaitingRequesting

 */

void UT_PSetCallWaitingWrapper::t_handleCallWaitingRequesting()

{

    QSignalSpy spy(m_wrapper, 

        SIGNAL(handleCallWaitingRequesting(bool, bool)));

    QT_TRAP_THROWING(

        m_wrapper->m_privateImpl->HandleCWRequestingL(ETrue, ETrue));

    QCOMPARE(spy.count(), 1);

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

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

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

}

/*!

  UT_PSetCallWaitingWrapper::t_handleCallWaitingError

 */

void UT_PSetCallWaitingWrapper::t_handleCallWaitingError()

{

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

    QT_TRAP_THROWING(m_wrapper->m_privateImpl->HandleCWErrorL(KErrGeneral));

    QCOMPARE(spy.count(), 1);

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

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

}

/*!

  UT_PSetCallWaitingWrapper::t_setEngineContact

 */

void UT_PSetCallWaitingWrapper::t_setEngineContact()

{

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

    m_wrapper->m_privateImpl->SetEngineContact(

        reinterpret_cast<MPsetCallWaiting&>(*this));

}

/*!

  UT_PSetCallWaitingWrapper::t_exceptionSafety

 */

void UT_PSetCallWaitingWrapper::t_exceptionSafety()

{

    cleanup();

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

}

void UT_PSetCallWaitingWrapper::SimulateLeaveAtMockMethodCallL()

{

    m_numOfLeaveSimulations++;

    User::Leave( KErrGeneral );

}

QTEST_MAIN_S60(UT_PSetCallWaitingWrapper)