/*

* Copyright (c) 2010 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 test for satappmainhandler

*

*/

#include <QTimer>

#include "ut_satapptoneprovider.h"

#include "satapptoneprovider.h"

#include "satappaction.h"

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

// Ut_SatAppToneProvider::Ut_SatAppToneProvider

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

//

Ut_SatAppToneProvider::Ut_SatAppToneProvider(QObject *parent):QObject(parent) 

{

}

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

// Ut_SatAppToneProvider::testCreateProvider

// 

// Connects to test object signal and verifies received data.

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

void Ut_SatAppToneProvider::testCreateProvider_data()

{

    QTest::addColumn<bool>("timer");

    QTest::newRow("t01") << false;

    QTest::newRow("t01") << true;

}

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

// Ut_SatAppToneProvider::testCreateProvider

// 

// Connects to test object signal and verifies received data.

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

void Ut_SatAppToneProvider::testCreateProvider()

{

    QFETCH(bool, timer);

    ToneProviderTest test;

    if(timer){

        test.ConstructTimer(false);

    }

    QVERIFY(test.mTone); 

}

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

// Ut_SatAppToneProvider::testClearScreen

// 

// Connects to test object signal and verifies received data.

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

void Ut_SatAppToneProvider::testClearScreen()

{

    ToneProviderTest test;

    test.mTone->clearScreen();

    QVERIFY(!test.isMessageBoxShown());

    QVERIFY(!test.isTimerActive());

}

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

// Ut_SatAppToneProvider::testPlayTone_data

// 

// Connects to test object signal and verifies received data.

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

void Ut_SatAppToneProvider::testPlayTone_data()

{

    QTest::addColumn<QString>("text");

    QTest::addColumn<int>("tone");

    QTest::addColumn<int>("duration");

    QTest::addColumn<int>("exp_result");

    QTest::newRow("t01") << "Standard" << 0x01 << 0 << 0x32; // exp result changed

    QTest::newRow("t02") << "Standard" << 0x02 << 100 << 0;

    QTest::newRow("t03") << "Standard" << 0x03 << 1000 << 0;

    QTest::newRow("t04") << "Standard" << 0x04 << 0 << 0;

    QTest::newRow("t05") << "Standard" << 0x05 << 100 << 0;

    QTest::newRow("t06") << "Standard" << 0x07 << 1000 << 0;

    QTest::newRow("t07") << "" << 0x07 << 100 << 0;

    QTest::newRow("t08") << "" << 0x08 << 500 << 0;

    QTest::newRow("t09") << "" << 0x09 << 1000 << 0x32; // exp result changed

    QTest::newRow("t10") << "User" << 0x13 << 1000 << 0;

    QTest::newRow("t11") << "User" << 0x14 << 500 << 0;

    QTest::newRow("t12") << "Illegal" << 0x99 << 100 << 0x32;

}

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

// Ut_SatAppToneProvider::testPlayTone

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

void Ut_SatAppToneProvider::testPlayTone()

{

    QFETCH(QString, text);

    QFETCH(int, tone);

    QFETCH(int, duration);

    QFETCH(int, exp_result);

    ToneProviderTest test;

    TSatUiResponse resp(ESatSuccess);

    SatAppAction action(ESatPlayToneAction);

    action.set(KeyToneId,tone);

    action.set(KeyDuration,duration);

    action.set(KeyText,text);

    test.mTone->playTone(action);

    action.waitUntilCompleted();

    resp = action.response();

    QCOMPARE((int)resp, exp_result);

}

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

// Ut_SatAppToneProvider::testplayStandardTone_data

// 

// Connects to test object signal and verifies received data.

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

void Ut_SatAppToneProvider::testplayDoubleTone_data()

{

    QTest::addColumn<QString>("text");

    QTest::addColumn<int>("tone");

    QTest::addColumn<int>("duration");

    QTest::addColumn<bool>("timer");

    QTest::addColumn<bool>("active");

    QTest::newRow("t01") << "Standard" << 0x10 << 0 << false << false;

    QTest::newRow("t02") << "Standard" << 0x10 << 0 << true << true;

    QTest::newRow("t03") << "Standard" << 0x10 << 0 << true << false;

    QTest::newRow("t04") << "Standard" << 0x13 << 0 << false << false;

    QTest::newRow("t04") << "Standard" << 0x14 << 0 << true << true;

    QTest::newRow("t04") << "" << 0x13 << 0 << true << false;

}

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

// Ut_SatAppToneProvider::testplayStandardTone

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

void Ut_SatAppToneProvider::testplayDoubleTone()

{

    QFETCH(QString, text);

    QFETCH(int, tone);

    QFETCH(int, duration);

    QFETCH(bool, timer);

    QFETCH(bool, active);

    ToneProviderTest test;

    TSatUiResponse resp(ESatSuccess);

    if(timer){

        test.ConstructTimer(active);

    }

    SatAppAction action(ESatPlayToneAction);

    action.set(KeyToneId,tone);

    action.set(KeyDuration,duration);

    action.set(KeyText,text);

    test.mTone->playTone(action);

    action.waitUntilCompleted();

    resp = action.response();

}

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

// Ut_SatAppToneProvider::testPlayToneAndClearScreen

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

void Ut_SatAppToneProvider::testPlayToneAndClearScreen()

{

    ToneProviderTest test;

    // timer for clearing screen after 1 sec.

    QTimer::singleShot(1000, test.mTone, SLOT(clearScreen()));

    // start playing

    TSatUiResponse result(ESatFailure);

    SatAppAction action(ESatPlayToneAction);

    action.set(KeyToneId,0x01);

    action.set(KeyDuration,3000);

    action.set(KeyText,QString("play"));

    test.mTone->playTone(action);

    action.waitUntilCompleted();

    result = action.response();

//    QCOMPARE(result, ESatSuccessToneNotPlayed); TODO:which?

    QCOMPARE(result, ESatSuccess);

}

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

// Ut_SatAppToneProvider::testMatoPlayComplete_data

// 

// Connects to test object signal and verifies received data.

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

void Ut_SatAppToneProvider::testMatoPrepareComplete_data()

{

    QTest::addColumn<int>("error");

    QTest::addColumn<bool>("tone");

    QTest::newRow("error_0") << 0 << true;

    QTest::newRow("error_-1") << -1 << false;

    QTest::newRow("error_-2") << 0 << false;

}

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

// Ut_SatAppToneProvider::testMatoPlayComplete

// 

// Connects to test object signal and verifies received data.

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

void Ut_SatAppToneProvider::testMatoPrepareComplete()

{

    QFETCH(int, error);

    QFETCH(bool, tone);

    ToneProviderTest test;

    if(tone)

        test.ConstructAudioTone();

    test.mTone->MatoPrepareComplete(error);

    test.DestroyAudioTone();

}

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

//// Ut_SatAppToneProvider::testMatoPlayComplete_data

//// 

//// Connects to test object signal and verifies received data.

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

//void Ut_SatAppToneProvider::testMatoPlayComplete_data()

//{

//    QTest::addColumn<int>("error");

//    QTest::addColumn<bool>("tone");

//    QTest::newRow("error_0") << 0 << true;

//    QTest::newRow("error_-1") << -1 << false;

//    QTest::newRow("error_-2") << 0 << false;

//}

//

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

//// Ut_SatAppToneProvider::testMatoPlayComplete

//// 

//// Connects to test object signal and verifies received data.

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

//void Ut_SatAppToneProvider::testMatoPlayComplete()

//{

//    QFETCH(int, error);

//    QFETCH(bool, tone);

//    ToneProviderTest test;

//

//    if(tone)

//        test.ConstructAudioTone();

//

//    test.mTone->MatoPrepareComplete(error);

//    test.mTone->MatoPlayComplete(error);

//    

//    test.DestroyAudioTone();

//}

//

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

//// Ut_SatAppToneProvider::testMapcPlayComplete_data

//// 

//// Connects to test object signal and verifies received data.

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

//void Ut_SatAppToneProvider::testMapcPlayComplete_data()

//{

//    QTest::addColumn<bool>("player");

//    QTest::newRow("t_true") << true;

//    QTest::newRow("t_false") << false;

//}

//

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

//// Ut_SatAppToneProvider::testMapcPlayComplete

//// 

//// Connects to test object signal and verifies received data.

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

//void Ut_SatAppToneProvider::testMapcPlayComplete()

//{

//    QFETCH(bool, player);

//    TInt error = 0;

//    ToneProviderTest test;

//    

//    if(player)

//        test.ConstructAudioPlayer();

//    

//    test.mTone->MapcPlayComplete(error);

//    

//    test.DestroyAudioPlayer();

//}

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

// Ut_SatAppToneProvider::testMapcInitComplete_data

// 

// Connects to test object signal and verifies received data.

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

void Ut_SatAppToneProvider::testMapcInitComplete_data()

{

    QTest::addColumn<int>("error");

    QTest::addColumn<bool>("player");

    QTest::newRow("error_0") << 0 << false;

    QTest::newRow("error_-6") << -6 << true;

    QTest::newRow("error_-6") << -6 << false;

}

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

// Ut_SatAppToneProvider::testMapcInitComplete

// 

// Connects to test object signal and verifies received data.

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

void Ut_SatAppToneProvider::testMapcInitComplete()

{

    QFETCH(int, error);

    QFETCH(bool, player);

    ToneProviderTest test;

    if(player)

        test.ConstructAudioPlayer();

    test.mTone->MapcInitComplete(error, 0);

    test.DestroyAudioPlayer();

}

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

// Ut_SatAppToneProvider::testRecognizeTone_data

// 

// Connects to test object signal and verifies received data.

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

void Ut_SatAppToneProvider::testRecognizeTone_data()

{

    QTest::addColumn<int>("tone");

    QTest::addColumn<int>("duration");

    QTest::newRow("t01") << -1 << 0;

    QTest::newRow("t01") << -1 << 1;

    QTest::newRow("t01") << 0x01 << 0;

    QTest::newRow("t01") << 0x01 << 1;

    QTest::newRow("t01") << 0x02 << 0;

    QTest::newRow("t01") << 0x02 << 1;

    QTest::newRow("t01") << 0x03 << 0;

    QTest::newRow("t01") << 0x03 << 1;

    QTest::newRow("t01") << 0x04 << 0;

    QTest::newRow("t01") << 0x04 << 1;

    QTest::newRow("t01") << 0x05 << 0;

    QTest::newRow("t01") << 0x05 << 1;

    QTest::newRow("t01") << 0x06 << 0;

    QTest::newRow("t01") << 0x06 << 1;

    QTest::newRow("t01") << 0x07 << 0;

    QTest::newRow("t01") << 0x07 << 1;

    QTest::newRow("t01") << 0x08 << 0;

    QTest::newRow("t01") << 0x08 << 1;

    QTest::newRow("t01") << 0x09 << 0;

    QTest::newRow("t01") << 0x10 << 0;

    QTest::newRow("t01") << 0x10 << 1;

    QTest::newRow("t01") << 0x11 << 0;

    QTest::newRow("t01") << 0x11 << 1;

    QTest::newRow("t01") << 0x12 << 0;

    QTest::newRow("t01") << 0x12 << 1;

    QTest::newRow("t02") << 0x13 << 0;

    QTest::newRow("t02") << 0x14 << 0;

}

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

// Ut_SatAppToneProvider::testRecognizeTone

// 

// Connects to test object signal and verifies received data.

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

void Ut_SatAppToneProvider::testRecognizeTone()

{

    QFETCH(int, tone);

    QFETCH(int, duration);

    ToneProviderTest test;

    test.TestRecognizeTone(tone, duration);

}

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

// Ut_SatAppToneProvider::testPrepareAudioToneUtility

// 

// Connects to test object signal and verifies received data.

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

void Ut_SatAppToneProvider::testPrepareAudioToneUtility()

{

    ToneProviderTest test;

    test.ConstructAudioTone();

    test.ConstructAudioTone();

}

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

// internal helper class

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

ToneProviderTest::ToneProviderTest()

{

    mTone = new SatAppToneProvider(this);

}

ToneProviderTest::~ToneProviderTest()

{

    cleanup();

}

/**

 * Singleton Pattern - not used

 */

SatAppToneProvider* ToneProviderTest::getToneInstance()

{

}

bool ToneProviderTest::isMessageBoxShown()

{

    if (mTone->mPermanentNote) {

        return true;

    }

    return false;

}

bool ToneProviderTest::isTimerActive()

{

    if (mTone->mTimer && mTone->mTimer->isActive()) {

        return true;

    }

    return false;

}

void ToneProviderTest::ConstructAudioTone()

{

    QByteArray sequence;

    sequence = KNetToneSeqDial;

    TPtrC8 seq((unsigned char*)sequence.constData(),sequence.length());

    if(mTone)

        QT_TRAP_THROWING(mTone->SymbianPrepareAudioToneUtilityL(seq));

}

void ToneProviderTest::DestroyAudioTone()

{

    if(mTone)

        mTone->SymbianStopAudioToneUtility();

}

void ToneProviderTest::ConstructAudioPlayer()

{

    int tone = ESatToneNotSet;

    int duration = 0;

    if(mTone)

        QT_TRAP_THROWING(mTone->SymbianPrepareAudioPlayerL(tone,duration));

}

void ToneProviderTest::DestroyAudioPlayer()

{

    if(mTone)

        mTone->SymbianStopAudioPlayer();

}

void ToneProviderTest::ConstructTimer(bool active)

{

    mTone->mTimer = new QTimer(mTone);

    connect(mTone->mTimer, SIGNAL(timeout()),

            mTone, SLOT(stopPlayTone()));

    if(active)

        mTone->mTimer->start(3000);

}

void ToneProviderTest::DestroyTimer()

{

}

void ToneProviderTest::SetPlayToneResult(TSatUiResponse error)

{

    mTone->mPlayToneError = error;

}

void ToneProviderTest::TestRecognizeTone(int tone, int duration)

{

    QByteArray sequence;

    mTone->recognizeTone(tone, sequence, duration);

}

void ToneProviderTest::cleanup()

{

    delete mTone;

    mTone = 0;

}

// ****************************************************************************

// * ************************************************************************ *

// * *                      SYMBIAN MOC PART                                * *

// * ************************************************************************ *

// ****************************************************************************

// includes

#include <e32cmn.h>

#include <MProfile.h>

#include <MProfileEngine.h>

#include <MProfileTones.h>

#include <TProfileToneSettings.h>

#include <mdaaudiotoneplayer.h> //MMdaAudioToneObserver

class CMocProfileTones : public MProfileTones

    {

    public:

        CMocProfileTones() 

            {

            // Set TProfileToneSettings with specified value

            iToneSettings.iWarningAndGameTones = EFalse;

            TBuf<256> ringTone(_L("Z:\\Data\\Sounds\\Digital\\Nokia tune.aac"));

            TBuf<256> alertTone(_L("Z:\\Data\\Sounds\\Digital\\Message 1.aac"));

            iTone = ringTone;

            }

        virtual ~CMocProfileTones() {}

    public:

        virtual const TDesC& RingingTone1() const 

            {

            //DONE

            return iTone;

            }

        virtual const TDesC& RingingTone2() const 

            {

            //DONE

            return iTone;