1 /**

     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description: Unit test for mpequalizerwrapper

    15 *

    16 */

    17 

    18 #include <QSignalSpy>

    19 #include <QStringList>

    20 #include <QMetaType>

    21 #include <hbapplication.h>

    22 #include <hbmainwindow.h>

    23 #include <centralrepository.h>

    24 

    25 #include "unittest_mpequalizerwrapper.h"

    26 #include "stub/inc/mpxuser.h"

    27 #include "stub/inc/mpxplaybackutility.h"

    28 #include "stub/inc/audioequalizerutility.h"

    29 #include "mpsettingsmanager.h"

    30 

    31 // Do this so we can access all member variables.

    32 #define private public

    33 #include "mpequalizerwrapper.h"

    34 #include "mpequalizerwrapper_p.h"

    35 #undef private

    36 

    37 //This so we can test private functions

    38 #include "mpequalizerwrapper_p.cpp"

    39 

    40 //    Predifined values

    41 //sa stub/inc/audioequalizerutility.cpp for Predifined Values

    42 //PresetName    PresetEngineId  PresetId (Ui)

    43 //  Off              -1             -1

    44 //  Bass             0x0A           1

    45 //  Classical        0x0B           2

    46 //  Pop              0x0C           3

    47 //  Jazz             0x0D           4

    48 //  Rock             0x0E           5

    49 

    50 /*!

    51  Make our test case a stand-alone executable that runs all the test functions.

    52  */

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

    54 {

    55     HbApplication app(argc, argv);

    56     HbMainWindow window;

    57 

    58     TestMpEqualizerWrapper tv;

    59 

    60     char *pass[3];

    61     pass[0] = argv[0];

    62     pass[1] = "-o";

    63     pass[2] = "c:\\data\\unittest_mpequalizerwrapper.txt";

    64 

    65     int res = QTest::qExec(&tv, 3, pass);

    66 

    67     return res;

    68 }

    69 

    70 TestMpEqualizerWrapper::TestMpEqualizerWrapper()

    71 {

    72 }

    73 

    74 TestMpEqualizerWrapper::~TestMpEqualizerWrapper()

    75 {

    76     delete mTest;

    77 }

    78 

    79 /*!

    80  Called before the first testfunction is executed.

    81  */

    82 void TestMpEqualizerWrapper::initTestCase()

    83 {

    84    

    85 }   

    86 

    87 /*!

    88  Called after the last testfunction was executed.

    89  */

    90 void TestMpEqualizerWrapper::cleanupTestCase()

    91 {

    92 }

    93 

    94 /*!

    95  Called before each testfunction is executed.

    96  */

    97 void TestMpEqualizerWrapper::init()

    98 {

    99     mTest = new MpEqualizerWrapper();

   100     mTestPrivate = mTest->d_ptr;

   101 }

   102 

   103 /*!

   104  Called after every testfunction.

   105  */

   106 void TestMpEqualizerWrapper::cleanup()

   107 {

   108     delete mTest;

   109     mTest = 0;

   110 }

   111 

   112 /*!

   113  Tests constructor and DoInit().

   114  */

   115 void TestMpEqualizerWrapper::testConstructor()

   116 {    

   117     QVERIFY(mTestPrivate->iMpxPlaybackUtility != 0);

   118     QVERIFY(mTestPrivate->iMdaPlayUtility != 0);

   119 }

   120 

   121 /*!

   122  Tests MapcInitComplete.

   123  */

   124 void TestMpEqualizerWrapper::testMapcInitComplete()

   125 {   

   126     QSignalSpy spyEqualizerReady(mTest, SIGNAL(equalizerReady()));

   127     

   128     mTestPrivate->MapcInitComplete(KErrNone, 0);

   129 

   130     QVERIFY(mTestPrivate->iEqualizerUtility != 0);

   131     QCOMPARE(spyEqualizerReady.count(), 1);

   132 }

   133 

   134 /*!

   135  Tests getPresetId

   136  */

   137 void TestMpEqualizerWrapper::testGetPresetId()

   138 {       

   139     TInt presetId(0);

   140     mTestPrivate->MapcInitComplete(KErrNone, 0);

   141     

   142     //When a valid preset is currently set

   143     MpSettingsManager::setPreset(0x0A);

   144     QTest::qWait(250);

   145     

   146     mTestPrivate->GetPresetId(presetId);    

   147     QCOMPARE(mTestPrivate->iCurrentPresetIndex, presetId);                   

   148     QVERIFY(presetId == 1);

   149     

   150     //When there is no any preset set

   151     MpSettingsManager::setPreset(KEqualizerPresetNone);

   152     QTest::qWait(250);

   153     

   154     mTestPrivate->GetPresetId(presetId);    

   155     QCOMPARE(mTestPrivate->iCurrentPresetIndex, presetId);                   

   156     QVERIFY(presetId == KEqualizerPresetNone);

   157 }

   158 

   159 /*!

   160  Tests GetEngineIndexL.

   161  */

   162 void TestMpEqualizerWrapper::testGetEngineIndexL()

   163 {   

   164     mTestPrivate->MapcInitComplete(KErrNone, 0);    

   165     

   166     QVERIFY(mTestPrivate->GetEngineIndexL(2) == 0x0C);    

   167 }

   168 

   169 /*!

   170  Tests activePreset.

   171  */

   172 void TestMpEqualizerWrapper::testActivePreset()

   173 {

   174     MpSettingsManager::setPreset(0x0A);

   175     mTestPrivate->MapcInitComplete(KErrNone, 0);

   176     

   177     QCOMPARE(mTest->activePreset(), mTestPrivate->iCurrentPresetIndex );

   178 }

   179 

   180 /*!

   181  Tests applyPreset and HandlePresetActivation.

   182  */

   183 void TestMpEqualizerWrapper::testApplyPreset()

   184 {   

   185     int presetId(2);    

   186     

   187     mTestPrivate->MapcInitComplete(KErrNone, 0);    

   188     mTest->applyPreset(presetId);

   189     QTest::qWait(250);

   190     

   191     QVERIFY(mTestPrivate->iMpxPlaybackUtility->commandSent);        

   192     QVERIFY(MpSettingsManager::preset() == 0x0B);

   193     

   194     QCOMPARE(mTestPrivate->iCurrentPresetIndex, presetId);

   195 }

   196 

   197 /*!

   198  Tests disableEqualizer and HandlePresetActivation.

   199  */

   200 void TestMpEqualizerWrapper::testDisableEqualizer()

   201 {   

   202     MpSettingsManager::setPreset(0x0A); //Set any preset different than KEqualizerPresetNone

   203     

   204     mTestPrivate->MapcInitComplete(KErrNone, 0);    

   205     mTest->disableEqualizer();

   206     QTest::qWait(250);

   207     

   208     QVERIFY(mTestPrivate->iMpxPlaybackUtility->commandSent);        

   209     QVERIFY(MpSettingsManager::preset() == KEqualizerPresetNone);

   210     

   211     QVERIFY(mTestPrivate->iCurrentPresetIndex == KEqualizerPresetNone);

   212 }

   213 

   214 /*!

   215  Tests presetNames

   216  */

   217 void TestMpEqualizerWrapper::testPresetNames()

   218 {   

   219     

   220     mTestPrivate->MapcInitComplete(KErrNone, 0);

   221     

   222     QStringList presetNames = mTest->presetNames();

   223     

   224     QVERIFY(presetNames.at(0) == "Bass");

   225     QVERIFY(presetNames.at(1) == "Classical");

   226     QVERIFY(presetNames.at(2) == "Pop");

   227     QVERIFY(presetNames.at(3) == "Jazz");

   228     QVERIFY(presetNames.at(4) == "Rock");    

   229 }

   230 

   231 // End of file