mpengine/tsrc/unittest_mpengine/src/unittest_mpengine.cpp
changeset 47 4cc1412daed0
child 51 560ce2306a17
equal deleted inserted replaced
45:612c4815aebe 47:4cc1412daed0
       
     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 mpengine
       
    15 *
       
    16 */
       
    17 
       
    18 #include <QSignalSpy>
       
    19 #include <EqualizerConstants.h>
       
    20 
       
    21 #include "unittest_mpengine.h"
       
    22 #include "mpmediakeyhandler.h"
       
    23 #include "mpmpxcollectionviewdefs.h"
       
    24 
       
    25 #define private public
       
    26 #include "mpengine.h"
       
    27 #undef private
       
    28 
       
    29 // help to test private function 
       
    30 #include "../../src/mpengine.cpp"
       
    31 
       
    32 /*!
       
    33  Make our test case a stand-alone executable that runs all the test functions.
       
    34  */
       
    35 int main(int argc, char *argv[])
       
    36 {
       
    37     QApplication app(argc, argv);
       
    38 
       
    39     TestMpEngine tv;
       
    40 
       
    41     if ( argc > 1 ) {
       
    42         return QTest::qExec( &tv, argc, argv);
       
    43     }
       
    44     else {
       
    45         char *pass[3];
       
    46         pass[0] = argv[0];
       
    47         pass[1] = "-o";
       
    48         pass[2] = "c:\\data\\unittest_mpengine.txt";
       
    49 
       
    50         return QTest::qExec(&tv, 3, pass);
       
    51     }
       
    52 }
       
    53 
       
    54 TestMpEngine::TestMpEngine()
       
    55     : mTest(0)
       
    56 {
       
    57 }
       
    58 
       
    59 TestMpEngine::~TestMpEngine()
       
    60 {
       
    61     delete mTest;
       
    62 }
       
    63 
       
    64 /*!
       
    65  Called before the first testfunction is executed.
       
    66  */
       
    67 void TestMpEngine::initTestCase()
       
    68 {
       
    69 }
       
    70 
       
    71 /*!
       
    72  Called after the last testfunction was executed.
       
    73  */
       
    74 void TestMpEngine::cleanupTestCase()
       
    75 {
       
    76     MpEngineFactory::close();
       
    77 }
       
    78 
       
    79 /*!
       
    80  Called before each testfunction is executed.
       
    81  */
       
    82 void TestMpEngine::init()
       
    83 {
       
    84 
       
    85 }
       
    86 
       
    87 /*!
       
    88  Called after every testfunction.
       
    89  */
       
    90 void TestMpEngine::cleanup()
       
    91 {
       
    92 
       
    93 }
       
    94 
       
    95 /*!
       
    96  test initialize
       
    97  */
       
    98 void TestMpEngine::testInitialize()
       
    99 {
       
   100     mTest = MpEngineFactory::createIsolatedEngine( MpEngine::StandAlone );
       
   101     QVERIFY( mTest->mSongData != 0 );
       
   102     QVERIFY( mTest->mMpxHarvesterWrapper != 0 );
       
   103     QVERIFY( mTest->mMpxCollectionWrapper != 0 );
       
   104     QVERIFY( mTest->mEqualizerWrapper != 0 );
       
   105     QVERIFY( mTest->mMpxPlaybackWrapper != 0 );
       
   106     QVERIFY( mTest->mAudioEffectsWrapper != 0 );
       
   107     
       
   108     mTest = MpEngineFactory::createIsolatedEngine( MpEngine::Fetch );
       
   109     QVERIFY( mTest->mMpxHarvesterWrapper != 0 );
       
   110     QVERIFY( mTest->mMpxCollectionWrapper != 0 );
       
   111     QVERIFY( mTest->mMpxPlaybackWrapper != 0 );
       
   112     QVERIFY( mTest->mEqualizerWrapper == 0 );
       
   113     QVERIFY( mTest->mAudioEffectsWrapper == 0 );
       
   114     
       
   115     mTest = MpEngineFactory::createIsolatedEngine( MpEngine::MediaBrowsing );
       
   116     QVERIFY( mTest->mMpxCollectionWrapper != 0 );
       
   117     QVERIFY( mTest->mMpxHarvesterWrapper == 0 );
       
   118     QVERIFY( mTest->mMpxPlaybackWrapper == 0 );
       
   119     QVERIFY( mTest->mEqualizerWrapper == 0 );
       
   120     QVERIFY( mTest->mAudioEffectsWrapper == 0 );
       
   121     
       
   122     mTest = MpEngineFactory::createIsolatedEngine( MpEngine::Embedded );
       
   123     QVERIFY( mTest->mMpxPlaybackWrapper != 0 );
       
   124     QVERIFY( mTest->mSongData != 0 );
       
   125 }
       
   126 
       
   127 /*!
       
   128  test verifyUsbBlocking
       
   129  */
       
   130 void TestMpEngine::testVerifyUsbBlocking() 
       
   131 {
       
   132     bool result;
       
   133     QSignalSpy spy( mTest, SIGNAL( unableToCotinueDueUSB() ) );
       
   134     
       
   135     mTest->mUsbBlockingState = MpEngine::USB_Connected;
       
   136     result = mTest->verifyUsbBlocking( true );    
       
   137     QVERIFY( result == true );
       
   138     QVERIFY( spy.count() == 1 ); 
       
   139     spy.clear();
       
   140     
       
   141     mTest->mUsbBlockingState = MpEngine::USB_Connected;
       
   142     result = mTest->verifyUsbBlocking( false );
       
   143     QVERIFY( result == true );
       
   144     QVERIFY( spy.count() == 0 );
       
   145     spy.clear();
       
   146     
       
   147     mTest->mUsbBlockingState = MpEngine::USB_NotConnected;
       
   148     result = mTest->verifyUsbBlocking( true );
       
   149     QVERIFY( result == false );
       
   150     QVERIFY( spy.count() == 0 );
       
   151     spy.clear();
       
   152     
       
   153     mTest->mUsbBlockingState = MpEngine::USB_NotConnected;
       
   154     result = mTest->verifyUsbBlocking( false );
       
   155     QVERIFY( result == false );
       
   156     QVERIFY( spy.count() == 0 );
       
   157     spy.clear();
       
   158     
       
   159     mTest->mUsbBlockingState = MpEngine::USB_Synchronizing;
       
   160     result = mTest->verifyUsbBlocking( true );
       
   161     QVERIFY( result == false );
       
   162     QVERIFY( spy.count() == 0 );
       
   163     spy.clear();
       
   164     
       
   165     mTest->mUsbBlockingState = MpEngine::USB_Synchronizing;
       
   166     result = mTest->verifyUsbBlocking( false );
       
   167     QVERIFY( result == false );
       
   168     QVERIFY( spy.count() == 0 );
       
   169     spy.clear();    
       
   170 }
       
   171 
       
   172 /*!
       
   173  test songScanner
       
   174  */
       
   175 void TestMpEngine::testSongScanner() 
       
   176 {
       
   177     mTest = MpEngineFactory::createIsolatedEngine( MpEngine::StandAlone );
       
   178     QCOMPARE( mTest->mSongScanner, mTest->songScanner() );
       
   179 }
       
   180 
       
   181 /*!
       
   182  test refreshLibrary
       
   183  */
       
   184 void TestMpEngine::testRefreshLibrary() 
       
   185 {
       
   186     mTest = MpEngineFactory::createIsolatedEngine( MpEngine::StandAlone );
       
   187     QSignalSpy spy( mTest, SIGNAL( libraryAboutToUpdate() ) );
       
   188     
       
   189     mTest->mUsbBlockingState = MpEngine::USB_Connected;
       
   190     QVERIFY( mTest->verifyUsbBlocking() == true );
       
   191     mTest->refreshLibrary( true );
       
   192     QVERIFY( mTest->mSongScanner == 0 );
       
   193     QVERIFY( spy.count() == 0 );
       
   194     
       
   195     mTest->mUsbBlockingState = MpEngine::USB_NotConnected;
       
   196     QVERIFY( mTest->verifyUsbBlocking() == false );
       
   197     mTest->refreshLibrary( true );
       
   198     QVERIFY( mTest->mSongScanner != 0 );
       
   199     QVERIFY( spy.count() == 1 );
       
   200     spy.clear();
       
   201     
       
   202     mTest->mUsbBlockingState = MpEngine::USB_Synchronizing;
       
   203     QVERIFY( mTest->verifyUsbBlocking() == false );
       
   204     mTest->refreshLibrary( true );
       
   205     QVERIFY( mTest->mSongScanner != 0 );
       
   206     QVERIFY( spy.count() == 1 );
       
   207     spy.clear();
       
   208 }
       
   209 
       
   210 /*!
       
   211  test handleScanStarted 
       
   212  */
       
   213 void TestMpEngine::testHandleScanStarted()
       
   214 {
       
   215     mTest = MpEngineFactory::createIsolatedEngine( MpEngine::StandAlone );
       
   216     mTest->handleScanStarted();
       
   217     QVERIFY( mTest->mHandleMediaCommands == false );
       
   218 }
       
   219 
       
   220 /*!
       
   221  test handleScanEnded
       
   222  */
       
   223 void TestMpEngine::testHandleScanEnded() 
       
   224 {
       
   225     mTest = MpEngineFactory::createIsolatedEngine( MpEngine::StandAlone );
       
   226     QSignalSpy spy( mTest, SIGNAL( libraryUpdated() ) );
       
   227     
       
   228     mTest->handleScanEnded( 0, 0 );
       
   229     QVERIFY( mTest->mHandleMediaCommands == true );
       
   230     
       
   231     QVERIFY( spy.count() == 1 );
       
   232     spy.clear();    
       
   233 }
       
   234 
       
   235 /*!
       
   236  test handleDiskEvent
       
   237  */
       
   238 void TestMpEngine::testHandleDiskEvent() 
       
   239 {
       
   240     mTest = MpEngineFactory::createIsolatedEngine( MpEngine::StandAlone );
       
   241     QSignalSpy spy( mTest, SIGNAL( libraryUpdated() ) );
       
   242     QSignalSpy spyTwo( mTest, SIGNAL( libraryAboutToUpdate() ) );
       
   243     
       
   244     mTest->handleDiskEvent( DiskFormatStarted );
       
   245     QVERIFY( mTest->mHandleMediaCommands == false );
       
   246     
       
   247     mTest->handleDiskEvent( DiskFormatEnded );
       
   248     QVERIFY( mTest->mHandleMediaCommands == true );
       
   249     
       
   250     mTest->mUsbBlockingState = MpEngine::USB_Synchronizing;
       
   251     mTest->handleDiskEvent( DiskRemoved );
       
   252     QVERIFY( spy.count() == 0 );
       
   253     spy.clear();    
       
   254     
       
   255     mTest->mUsbBlockingState = MpEngine::USB_NotConnected;
       
   256     mTest->handleDiskEvent( DiskRemoved );
       
   257     QVERIFY( spy.count() == 1 );
       
   258     spy.clear();   
       
   259     
       
   260     mTest->mUsbBlockingState = MpEngine::USB_Connected;
       
   261     mTest->handleDiskEvent( DiskRemoved );
       
   262     QVERIFY( spy.count() == 1 );
       
   263     spy.clear();   
       
   264     
       
   265     mTest->mUsbBlockingState = MpEngine::USB_NotConnected;
       
   266     mTest->handleDiskEvent( DiskInserted );
       
   267     QVERIFY( mTest->verifyUsbBlocking() == false );
       
   268     QVERIFY( spyTwo.count() == 1 );
       
   269     spyTwo.clear();   
       
   270     
       
   271     mTest->mUsbBlockingState = MpEngine::USB_Connected;
       
   272     mTest->handleDiskEvent( DiskInserted );
       
   273     QVERIFY( spy.count() == 1 );
       
   274     spy.clear();      
       
   275 }
       
   276 
       
   277 /*!
       
   278  test HandleUsbEvent
       
   279  */
       
   280 void TestMpEngine::testHandleUsbEvent()
       
   281 {
       
   282     // no need to test here 
       
   283 }
       
   284 
       
   285 /*!
       
   286  test handleUsbMassStorageStartEvent
       
   287  */
       
   288 void TestMpEngine::testHandleUsbMassStorageStartEvent()
       
   289 {
       
   290     mTest = MpEngineFactory::createIsolatedEngine( MpEngine::StandAlone );
       
   291     QSignalSpy spy( mTest, SIGNAL( usbBlocked( bool ) ) );
       
   292     QSignalSpy spyTwo( mTest, SIGNAL( usbSynchronizationStarted() ) );
       
   293     
       
   294     mTest->handleUsbMassStorageStartEvent();
       
   295     QVERIFY( mTest->mHandleMediaCommands == false );
       
   296     QVERIFY( spy.count() == 1 );
       
   297     QList<QVariant> arguments = spy.takeFirst();
       
   298     QVERIFY( arguments.at(0).toBool() == true ); 
       
   299     
       
   300     QVERIFY( spyTwo.count() == 1 );
       
   301 }
       
   302 
       
   303 /*!
       
   304  test handleUsbMassStorageEndEvent
       
   305  */
       
   306 void TestMpEngine::testHandleUsbMassStorageEndEvent() 
       
   307 {
       
   308     mTest = MpEngineFactory::createIsolatedEngine( MpEngine::StandAlone );
       
   309     QSignalSpy spy( mTest, SIGNAL( usbBlocked( bool ) ) );
       
   310     QSignalSpy spyTwo( mTest, SIGNAL( usbSynchronizationFinished() ) );
       
   311     
       
   312     mTest->handleUsbMassStorageEndEvent();
       
   313     QVERIFY( mTest->mHandleMediaCommands == true );
       
   314     QVERIFY( spy.count() == 1 );
       
   315     QList<QVariant> arguments = spy.takeFirst();
       
   316     QVERIFY(arguments.at(0).toBool() == false ); 
       
   317     
       
   318     QVERIFY( spyTwo.count() == 1 );
       
   319 }
       
   320 
       
   321 /*!
       
   322  test handleUsbMtpStartEvent
       
   323  */
       
   324 void TestMpEngine::testHandleUsbMtpStartEvent() 
       
   325 {
       
   326     mTest = MpEngineFactory::createIsolatedEngine( MpEngine::StandAlone );
       
   327     QSignalSpy spy( mTest, SIGNAL( usbBlocked( bool ) ) );
       
   328     QSignalSpy spyTwo( mTest, SIGNAL( libraryAboutToUpdate() ) );
       
   329     QSignalSpy spyThree( mTest, SIGNAL( usbSynchronizationStarted() ) );
       
   330     
       
   331     mTest->handleUsbMtpStartEvent();
       
   332     QVERIFY( mTest->mHandleMediaCommands == false );
       
   333     QVERIFY( spy.count() == 1 );
       
   334     QList<QVariant> arguments = spy.takeFirst();
       
   335     QVERIFY( arguments.at(0).toBool() == true ); 
       
   336     QVERIFY( spyTwo.count() == 1 );
       
   337     QVERIFY( spyThree.count() == 1 );
       
   338 }
       
   339 
       
   340 /*!
       
   341  test handleUsbMtpEndEvent
       
   342  */
       
   343 void TestMpEngine::testHandleUsbMtpEndEvent() 
       
   344 {
       
   345     mTest = MpEngineFactory::createIsolatedEngine( MpEngine::StandAlone );
       
   346     QSignalSpy spy( mTest, SIGNAL( usbBlocked( bool ) ) );
       
   347     QSignalSpy spyTwo( mTest, SIGNAL( usbSynchronizationFinished() ) );
       
   348     QSignalSpy spyThree( mTest, SIGNAL( libraryUpdated() ) );
       
   349     QList<QVariant> arguments;
       
   350     
       
   351     mTest->mUsbBlockingState = MpEngine::USB_Synchronizing;
       
   352     mTest->handleUsbMtpEndEvent();
       
   353     QVERIFY( mTest->mHandleMediaCommands == true );
       
   354     QVERIFY( spy.count() == 1 );
       
   355     arguments = spy.takeFirst();
       
   356     QVERIFY( arguments.at(0).toBool() == false ); 
       
   357     QVERIFY( spyTwo.count() == 1 );
       
   358     QVERIFY( spyThree.count() == 1 );
       
   359     spyTwo.clear();
       
   360     spyThree.clear();
       
   361     arguments.clear();
       
   362     
       
   363     mTest->mPreviousUsbState = MpEngine::USB_NotConnected;
       
   364     mTest->handleUsbMtpEndEvent();
       
   365     QVERIFY( mTest->mHandleMediaCommands == true );
       
   366     QVERIFY( spy.count() == 1 );
       
   367     arguments = spy.takeFirst();
       
   368     QVERIFY( arguments.at(0).toBool() == false ); 
       
   369     QVERIFY( spyTwo.count() == 0 );
       
   370     QVERIFY( spyThree.count() == 0 );
       
   371     spyTwo.clear();
       
   372     spyThree.clear();
       
   373     arguments.clear();
       
   374     
       
   375     mTest->mPreviousUsbState = MpEngine::USB_Connected;
       
   376     mTest->handleUsbMtpEndEvent();
       
   377     QVERIFY( mTest->mHandleMediaCommands == true );
       
   378     QVERIFY( spy.count() == 1 );
       
   379     arguments = spy.takeFirst();
       
   380     QVERIFY( arguments.at(0).toBool() == false ); 
       
   381     QVERIFY( spyTwo.count() == 0 );
       
   382     QVERIFY( spyThree.count() == 0 );
       
   383     spyTwo.clear();
       
   384     spyThree.clear();
       
   385     arguments.clear();
       
   386 }
       
   387 
       
   388 /*!
       
   389  test handleUsbMtpNotActive
       
   390  */
       
   391 void TestMpEngine::testHandleUsbMtpNotActive() 
       
   392 {   
       
   393     mTest = MpEngineFactory::createIsolatedEngine( MpEngine::StandAlone );
       
   394     QSignalSpy spy( mTest, SIGNAL( usbBlocked( bool ) ) );
       
   395     
       
   396     mTest->handleUsbMtpNotActive();
       
   397     QVERIFY( spy.count() == 1 );
       
   398     QList<QVariant> arguments = spy.takeFirst();
       
   399     QVERIFY( arguments.at(0).toBool() == true ); 
       
   400 }
       
   401 
       
   402 /*!
       
   403  test changeUsbBlockingState
       
   404  */
       
   405 void TestMpEngine::testChangeUsbBlockingState()
       
   406 {
       
   407     mTest = MpEngineFactory::createIsolatedEngine( MpEngine::StandAlone );
       
   408     
       
   409     MpEngine::UsbBlockingState cState = mTest->mUsbBlockingState;
       
   410     mTest->changeUsbBlockingState( MpEngine::USB_Connected );
       
   411     QCOMPARE( mTest->mPreviousUsbState, cState );
       
   412     QCOMPARE( mTest->mUsbBlockingState, MpEngine::USB_Connected );
       
   413 }
       
   414 
       
   415 /*!
       
   416  test handleDeleteStarted
       
   417  */
       
   418 void TestMpEngine::testHandleDeleteStarted() 
       
   419 {
       
   420     mTest = MpEngineFactory::createIsolatedEngine( MpEngine::StandAlone );
       
   421     qRegisterMetaType<QModelIndex>("TCollectionContext");
       
   422     QSignalSpy spy( mTest, SIGNAL( deleteStarted( TCollectionContext, int ) ) );
       
   423     
       
   424     TCollectionContext context( ECollectionContextAllSongs );
       
   425     mTest->handleDeleteStarted( context, 0 );
       
   426     QVERIFY( mTest->mHandleMediaCommands == false );
       
   427     QVERIFY( spy.count() == 1 );
       
   428 }
       
   429 
       
   430 /*!
       
   431  test handleDeleteEnded
       
   432  */
       
   433 void TestMpEngine::testHandleDeleteEnded() 
       
   434 {
       
   435     mTest = MpEngineFactory::createIsolatedEngine( MpEngine::StandAlone );
       
   436     QSignalSpy spy( mTest, SIGNAL( songsDeleted( bool ) ) );
       
   437     QList<QVariant> arguments;
       
   438     
       
   439     mTest->handleDeleteEnded( true );
       
   440     QVERIFY( mTest->mHandleMediaCommands == true );
       
   441     QVERIFY( spy.count() == 1 );
       
   442     arguments = spy.takeFirst();
       
   443     QVERIFY( arguments.at(0).toBool() == true ); 
       
   444     spy.clear();
       
   445     arguments.clear();
       
   446     
       
   447     mTest->handleDeleteEnded( false );
       
   448     QVERIFY( mTest->mHandleMediaCommands == true );
       
   449     QVERIFY( spy.count() == 1 );
       
   450     arguments = spy.takeFirst();
       
   451     QVERIFY( arguments.at(0).toBool() == false );
       
   452     spy.clear();
       
   453     arguments.clear();
       
   454 }
       
   455 
       
   456 /*!
       
   457  test playbackData
       
   458  */
       
   459 void TestMpEngine::testPlaybackData() 
       
   460 {
       
   461     mTest = MpEngineFactory::createIsolatedEngine( MpEngine::StandAlone );
       
   462     QVERIFY( mTest->mMpxPlaybackWrapper->mPlaybackData == mTest->playbackData() );
       
   463 }
       
   464 
       
   465 /*!
       
   466  test songData
       
   467  */
       
   468 void TestMpEngine::testSongData() 
       
   469 {
       
   470     mTest = MpEngineFactory::createIsolatedEngine( MpEngine::StandAlone );
       
   471     QVERIFY( mTest->mSongData == mTest->songData() );
       
   472 }
       
   473 
       
   474 /*!
       
   475  test balance
       
   476  */
       
   477 void TestMpEngine::testBalance() 
       
   478 {
       
   479     mTest = MpEngineFactory::createIsolatedEngine( MpEngine::StandAlone );
       
   480     QVERIFY( mTest->mAudioEffectsWrapper->mBalance == mTest->balance() );
       
   481 }
       
   482 
       
   483 /*!
       
   484  test loudness
       
   485  */
       
   486 void TestMpEngine::testLoudness()
       
   487 {
       
   488     mTest = MpEngineFactory::createIsolatedEngine( MpEngine::StandAlone );
       
   489     QVERIFY( mTest->mAudioEffectsWrapper->mLoudness == mTest->loudness() );
       
   490 }
       
   491 
       
   492 /*!
       
   493  test setBalance
       
   494  */
       
   495 void TestMpEngine::testSetBalance()
       
   496 {
       
   497     // nothing to test here
       
   498 }
       
   499 
       
   500 /*!
       
   501  test setLoudness
       
   502  */
       
   503 void TestMpEngine::testSetLoudness()
       
   504 {
       
   505     // nothing to test here
       
   506 }
       
   507 
       
   508 /*!
       
   509  test applyPreset
       
   510  */
       
   511 void TestMpEngine::testApplyPreset()
       
   512 {
       
   513     mTest = MpEngineFactory::createIsolatedEngine( MpEngine::StandAlone );
       
   514     mTest->mCurrentPresetIndex = 2;
       
   515     
       
   516     mTest->applyPreset( 4 );
       
   517     QCOMPARE( mTest->mCurrentPresetIndex, 4 );
       
   518 }
       
   519 
       
   520 /*!
       
   521  test disableEqualizer
       
   522  */
       
   523 void TestMpEngine::testDisableEqualizer()
       
   524 {
       
   525     mTest = MpEngineFactory::createIsolatedEngine( MpEngine::StandAlone );
       
   526     mTest->disableEqualizer();
       
   527     
       
   528     QCOMPARE( mTest->mCurrentPresetIndex, KEqualizerPresetNone );
       
   529 }
       
   530 
       
   531 /*!
       
   532  test activePreset
       
   533  */
       
   534 void TestMpEngine::testActivePreset()
       
   535 {
       
   536     mTest = MpEngineFactory::createIsolatedEngine( MpEngine::StandAlone );
       
   537     
       
   538     QCOMPARE( mTest->mCurrentPresetIndex, mTest->activePreset() );
       
   539 }
       
   540 
       
   541 /*!
       
   542  test presetNames
       
   543  */
       
   544 void TestMpEngine::testPresetNames() 
       
   545 {
       
   546     mTest = MpEngineFactory::createIsolatedEngine( MpEngine::StandAlone );
       
   547     
       
   548     QCOMPARE( mTest->mEqualizerWrapper->mList, mTest->presetNames() );
       
   549 }
       
   550 
       
   551 /*!
       
   552  test handleEqualizerReady
       
   553  */
       
   554 void TestMpEngine::testHandleEqualizerReady() 
       
   555 {
       
   556     mTest = MpEngineFactory::createIsolatedEngine( MpEngine::StandAlone );
       
   557     QSignalSpy spy( mTest, SIGNAL( equalizerReady() ) );
       
   558     
       
   559     mTest->handleEqualizerReady();
       
   560     QCOMPARE( mTest->mCurrentPresetIndex, 1 );
       
   561     QVERIFY( spy.count() == 1 );
       
   562 }
       
   563 
       
   564 
       
   565 // End of file