/*!

* 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:  Unit tests for PhoneUIQtView.

*

*/

#include <QtTest/QtTest>

#include <QtGui>

#include <QVariant>

#include <QKeyEvent>

#include <QTimer>

#include <QShortcutEvent>

#include <QSignalSpy>

#include <hbapplication.h>

#include <hbmainwindow.h>

#include <hbinstance.h>

#include <hbmainwindow.h>

#include <bubblemanagerif.h>

#define protected public

#define private public

#include "phoneuiqtview.h"

#undef public

#include "phoneaction.h"

#include <hbtoolbar.h>

#include <hbvolumesliderpopup.h>

#include <hbaction.h>

#include <dialpad.h>

#include <hblineedit.h>

#include "xqserviceutil.h"

#include "phoneaction.h"

//CONSTANTS

static const int KMAXVOLUME = 10;

static const int KMINVOLUME = 0;

static const int KVOLUMECOMMAND = 5;

bool m_qtimer_stop_called;

QString m_networkName;

#define PHONE_QT_VIEW_TEST_MAIN(TestObject) \

int main(int argc, char *argv[]) \

{ \

    HbApplication app(argc, argv); \

    TestObject tc; \

    QResource::registerResource("../hbcore.rcc"); \

    int ret = QTest::qExec(&tc, argc, argv); \

    /* Core dump if HbIconLoader instance is not destroyed before the application instance. */ \

    /* HbIconLoader uses QCoreApplication::aboutToQuit() signal to destroy itself. */ \

    /* app.exec() where the signal is normally emitted is not called here. */ \

    /* So, invoking the signal explicitly. */ \

    QMetaObject::invokeMethod(&app, "aboutToQuit", Qt::DirectConnection); \

    return ret; \

}

class TestPhoneUIQtView : public QObject

{

    Q_OBJECT

public:

    TestPhoneUIQtView ();

    ~TestPhoneUIQtView ();

public slots:

    void initTestCase ();

    void cleanupTestCase (); 

    void init ();

    void cleanup ();

private slots:

    void testAddBubbleCommand ();

    void testHideToolbar ();

    void testShowToolbar ();

    void testAddToolbarActions ();

    void testSetVolumeSliderValue ();

    void testRemoveVolumeSlider ();

    void testVolumeSliderValue ();

    void testVolumeSliderChanged ();

    void testParticipantListAction ();

    void testSetExpandAction ();

    void testPhoneAction ();

    void testSetOrientation ();

    void testBackButtonClicked();

    void testShowDialpad();

    void testDialpadText();

    void testSetMenuActions();

    void testLongEndKeyPressEventOutsideTelephony();

    void testNetworkNameChanged();

    void testCaptureKey();

    void testRestrictedMode();

private:

    int createCallHeader();

private:

    PhoneUIQtView *m_view; // class under test

    HbMainWindow *m_main_window;

};

void QTimer::stop()

{

    m_qtimer_stop_called = true;   

}

TestPhoneUIQtView::TestPhoneUIQtView ()

{    

}

TestPhoneUIQtView::~TestPhoneUIQtView ()

{

}

void TestPhoneUIQtView::initTestCase ()

{	

    m_main_window = new HbMainWindow();

    m_view = new PhoneUIQtView(*m_main_window);

    QCOMPARE(m_networkName, QString("Unit test network"));

}

void TestPhoneUIQtView::cleanupTestCase ()

{

    delete m_view;

}

void TestPhoneUIQtView::init ()

{

    m_qtimer_stop_called = false;

}

void TestPhoneUIQtView::cleanup ()

{

}

void TestPhoneUIQtView::testAddBubbleCommand ()

{

    m_view->bubbleManager ().startChanges ();

    int bubbleId = createCallHeader();

    int bubbleId2 = createCallHeader();

    PhoneAction action1;

    action1.setText("Command 1");

    action1.setCommand(1);

    action1.setActionRole(PhoneAction::None);

    PhoneAction action2;

    action2.setText("Command 2");

    action2.setCommand(2);

    action2.setActionRole(PhoneAction::Accept);

    PhoneAction action3;

    action3.setText("Command 3");

    action3.setCommand(3);

    action3.setActionRole(PhoneAction::Decline);

    m_view->addBubbleCommand (bubbleId, action1);

    m_view->addBubbleCommand (bubbleId, action2);

    m_view->addBubbleCommand (bubbleId2, action3);

    m_view->bubbleManager ().endChanges ();

    m_view->bubbleManager ().startChanges ();

    m_view->clearBubbleCommands (bubbleId);

    m_view->clearBubbleCommands (bubbleId2);

    m_view->clearBubbleCommands (bubbleId2);

    m_view->bubbleManager ().endChanges ();

}

void TestPhoneUIQtView::testHideToolbar ()

{

    m_view->hideToolbar ();

    QCOMPARE (m_hideCalled, true);	

}

void TestPhoneUIQtView::testShowToolbar ()

{

    m_view->showToolbar ();

    QCOMPARE (m_showCalled, true);

}

void TestPhoneUIQtView::testAddToolbarActions ()

{

    m_actions.clear();

    HbIcon icon ("foo.jpg");

    PhoneAction *testAction = new PhoneAction ();

    testAction->setIcon(icon);

    testAction->setText("foo");

    testAction->setCommand(20);

    QList<PhoneAction*> actions;

    actions.append(testAction);

    m_view->setToolbarActions(actions);

    QCOMPARE (m_action->icon(), icon);

    QCOMPARE(true, m_toolBarUpdateCalled);

    m_view->setToolbarActions(actions);

    m_toolBarUpdateCalled = false;

    PhoneAction *testAction2 = new PhoneAction ();

    testAction2->setIcon(icon);

    testAction2->setText("foo2");

    testAction2->setCommand(21);

    actions.append(testAction2);

    m_view->setToolbarActions(actions);

    QCOMPARE(true, m_toolBarUpdateCalled);

    actions.removeOne(testAction2);

    m_toolBarUpdateCalled = false;

    m_view->setToolbarActions(actions);

    QCOMPARE(true, m_toolBarUpdateCalled);

    actions.clear();

    delete testAction;

    delete testAction2;

}

void TestPhoneUIQtView::testSetVolumeSliderValue ()

{

    m_view->setVolumeSliderValue (1, KVOLUMECOMMAND, KMAXVOLUME, KMINVOLUME);

    QCOMPARE (m_volumeSliderContructorCalled, true);

    QCOMPARE (m_sliderRangeMin, KMINVOLUME);

    QCOMPARE (m_sliderRangeMax, KMAXVOLUME);

    QCOMPARE (m_volumeSliderSetTimeoutCalled, true);

    QCOMPARE (m_sliderTimeout, 10000);

    QCOMPARE (m_volumeSliderSetValueCalled, true);

    QCOMPARE (m_sliderValue, 1);

    QCOMPARE (m_volumeSliderShowCalled, true);

    // reset values

    m_volumeSliderContructorCalled = false;

    m_volumeSliderSetValueCalled = false;

    m_sliderRangeMin = -1;

    m_sliderRangeMax = -1;

    m_volumeSliderSetTimeoutCalled = false;

    m_sliderTimeout = -1;

    m_volumeSliderSetValueCalled = false;

    m_sliderValue = -1;

    m_volumeSliderShowCalled = false;

    // The second call shouldn't create a new instance

    m_view->setVolumeSliderValue (2, KVOLUMECOMMAND, KMAXVOLUME, KMINVOLUME);

    QCOMPARE (m_volumeSliderContructorCalled, false);

    QCOMPARE (m_sliderRangeMin, KMINVOLUME);

    QCOMPARE (m_sliderRangeMax, KMAXVOLUME);

    QCOMPARE (m_volumeSliderSetTimeoutCalled, false);

    QCOMPARE (m_sliderTimeout, -1);

    QCOMPARE (m_volumeSliderSetValueCalled, true);

    QCOMPARE (m_sliderValue, 2);

    QCOMPARE (m_volumeSliderShowCalled, false);

}

void TestPhoneUIQtView::testRemoveVolumeSlider ()

{

    m_view->setVolumeSliderValue (1, KVOLUMECOMMAND, KMAXVOLUME, KMINVOLUME);

    m_view->removeVolumeSlider ();

    QCOMPARE (m_volumeSliderHideCalled, true);

}

void TestPhoneUIQtView::testVolumeSliderValue ()

{

    m_sliderValue = -1;

    int value = m_view->volumeSliderValue ();

    QCOMPARE (m_sliderValue, -1);

    m_view->setVolumeSliderValue (3, KVOLUMECOMMAND, KMAXVOLUME, KMINVOLUME);

    value = m_view->volumeSliderValue ();

    QCOMPARE (m_volumeSliderValueCalled, true);

    QCOMPARE (value, 3);

}

void TestPhoneUIQtView::testVolumeSliderChanged ()

{

    m_view->setVolumeSliderValue (3, KVOLUMECOMMAND, KMAXVOLUME, KMINVOLUME);

    QSignalSpy spy (m_view, SIGNAL(command(int)));

    m_view->volumeSliderChanged (1);

    QCOMPARE (spy.count(), 1);

    int command = qvariant_cast<int>(spy.at (0).at (0));

    QCOMPARE (command, (int)KVOLUMECOMMAND);

}

void TestPhoneUIQtView::testParticipantListAction ()

{

    m_view->bubbleManager ().startChanges ();

    m_view->addParticipantListAction (1,"Command 1", HbIcon ());

    m_view->addParticipantListAction (2,"Command 2", HbIcon ());

    m_view->bubbleManager ().endChanges ();

    m_view->bubbleManager ().startChanges ();

    m_view->clearParticipantListActions ();

    m_view->clearParticipantListActions ();

    m_view->bubbleManager ().endChanges ();

}

void TestPhoneUIQtView::testSetExpandAction ()

{

    m_view->bubbleManager ().startChanges ();

    int bubbleId = createCallHeader();

    int bubbleId2 = createCallHeader();

    m_view->setExpandAction(bubbleId, 1);

    m_view->setExpandAction(bubbleId2, 2);

    m_view->bubbleManager ().endChanges ();

    m_view->bubbleManager ().startChanges ();

    m_view->removeExpandAction(bubbleId);

    m_view->removeExpandAction(bubbleId2);

    m_view->bubbleManager().removeCallHeader(bubbleId);

    m_view->bubbleManager().removeCallHeader(bubbleId2);

    m_view->bubbleManager ().endChanges ();

}

void TestPhoneUIQtView::testPhoneAction ()

{

    PhoneAction *action = new PhoneAction ();

    QString string("Action");

    action->setText(string);

    HbIcon icon;

    action->setIcon(icon);

    int commandId(1);

    action->setCommand(commandId);

    action->setDisabled(true);

    QCOMPARE( string, action->text() );

    QCOMPARE( icon, action->icon() );

    QCOMPARE( commandId, action->command() );

    QCOMPARE( true, action->isDisabled() );

    delete action;

}

void TestPhoneUIQtView::testSetOrientation ()

{

    m_setOrientationCalled = false;

    m_view->handleOrientationChange(Qt::Vertical);

    QVERIFY( false == m_setOrientationCalled );

    m_view->handleOrientationChange(Qt::Horizontal);

    QVERIFY( true == m_setOrientationCalled );

}

void TestPhoneUIQtView::testBackButtonClicked()

{

    // not possible to mock xqservice because it is in \epoc32\include

    // calling backButtonClicked would send this test background.

    // m_view->backButtonClicked();

}

void TestPhoneUIQtView::testShowDialpad()

{

    m_view->hideDialpad();

    m_view->showDialpad();

    m_view->showDialpad();

    QVERIFY(true == m_view->isDialpadVisible());

    m_view->hideDialpad();

}

void TestPhoneUIQtView::testDialpadText()

{

    m_view->showDialpad();

    m_view->clearDialpad();

    QVERIFY(QString("") == m_view->dialpadText());

    m_view->clearAndHideDialpad();

}

void TestPhoneUIQtView::testSetMenuActions()

{

    QList<PhoneAction*> actions;

    m_view->setMenuActions(actions);

    PhoneAction* phoneAction = new PhoneAction; 

    phoneAction->setText(QString("test"));

    phoneAction->setCommand(1);

    actions.append(phoneAction);

    m_view->setMenuActions(actions);

    qDeleteAll(actions);

    actions.clear();

    m_view->setMenuActions(actions);

}

//Private methods

int TestPhoneUIQtView::createCallHeader ()

{

    int bubble = m_view->bubbleManager().createCallHeader ();

    return bubble;

}

void TestPhoneUIQtView::testLongEndKeyPressEventOutsideTelephony()

{

    /*QSignalSpy spy(m_view, SIGNAL(endKeyLongPress()));

    QKeyEvent* event = new QKeyEvent(QEvent::ShortcutOverride, Qt::Key_No, Qt::NoModifier);

    bool returnValue = m_view->eventFilter(new QObject(), event);

    QVERIFY(returnValue == true);

    QCOMPARE(spy.count(), 1);*/

}

void TestPhoneUIQtView::testNetworkNameChanged()

{

    // Title is changed for GmsMode

    m_view->networkNameChanged(QSystemNetworkInfo::GsmMode, QString("test"));

    QCOMPARE(m_networkName, QString("test"));

    // Title is changed for WcdmaMode

    m_view->networkNameChanged(QSystemNetworkInfo::WcdmaMode, QString("test2"));

    QCOMPARE(m_networkName, QString("test2"));

    // Other modes shouldn't affect the title

    m_view->networkNameChanged(QSystemNetworkInfo::CdmaMode, QString("another operator"));

    QCOMPARE(m_networkName, QString("test2"));

}

void TestPhoneUIQtView::testCaptureKey()

{

    m_view->captureKey( Qt::Key_No, true );

    m_view->captureKey( Qt::Key_No, true );	

    m_view->captureKey( Qt::Key_Yes, false );

    m_view->captureKey( Qt::Key_No, false );

    m_view->captureKey( Qt::Key_No, false );		

}

void TestPhoneUIQtView::testRestrictedMode()

{

    qRegisterMetaType<QKeyEvent*>("QKeyEvent*");

    QKeyEvent yesDown(QEvent::KeyPress, Qt::Key_Yes, Qt::NoModifier);

    QKeyEvent yesUp(QEvent::KeyRelease, Qt::Key_Yes, Qt::NoModifier);

    QKeyEvent oneDown(QEvent::KeyPress, Qt::Key_1, Qt::NoModifier);

    QKeyEvent oneUp(QEvent::KeyRelease, Qt::Key_1, Qt::NoModifier);

    QSignalSpy downSpy(m_view, SIGNAL(keyPressed(QKeyEvent*)));

    QSignalSpy upSpy(m_view, SIGNAL(keyReleased(QKeyEvent*)));

    m_view->setRestrictedMode(true);

    m_view->m_dialpad->editor().setText("1"); // emits signal

    QCOMPARE(m_view->m_dialpad->isCallButtonEnabled(), false);

    m_view->eventFilter(0, &oneDown);

    m_view->eventFilter(0, &oneUp);

    m_view->eventFilter(0, &yesDown);

    m_view->eventFilter(0, &yesUp);

    QCOMPARE(downSpy.count(), 1); // Only Key_1 is passed

    QCOMPARE(upSpy.count(), 1); // Only Key_1 is passed

    QCOMPARE(m_view->m_dialpad->isCallButtonEnabled(), false);

    QCOMPARE(m_view->m_backAction->isEnabled(), false);

    // Test backbutton

    m_view->setBackButtonVisible(true);

    QCOMPARE(m_view->m_backAction->isEnabled(), false);

    // Test return to normal mode

    downSpy.clear();

    upSpy.clear();

    m_view->setRestrictedMode(false);

    m_view->m_dialpad->editor().setText("1"); // emits signal

    QCOMPARE(m_view->m_dialpad->isCallButtonEnabled(), true);

    m_view->eventFilter(0, &oneDown);

    m_view->eventFilter(0, &oneUp);

    m_view->eventFilter(0, &yesDown);

    m_view->eventFilter(0, &yesUp);

    QCOMPARE(downSpy.count(), 2);

    QCOMPARE(upSpy.count(), 2);

    QCOMPARE(m_view->m_dialpad->isCallButtonEnabled(), true);

    QCOMPARE(m_view->m_backAction->isEnabled(), true);

}

void HbView::setTitle (const QString &title)

{

    m_networkName = title;

}

PHONE_QT_VIEW_TEST_MAIN(TestPhoneUIQtView)

Q_DECLARE_METATYPE(QKeyEvent *)

#include "unit_tests.moc"