cellular/telephonysettings/xqbindings/psetwrapper/tsrc/ut_psetcallwaitingwrapper/ut_psetcallwaitingwrapper.cpp
/*
* 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)