Mercurial Mercurial > oss > FCL > sf > app > videoplayer / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
videoplayerapp/videoplayerengine/tsrc/testvideoservices/src/testvideoservices.cpp
changeset 52 e3cecb93e76a
parent 17 69946d1824c4
equal deleted inserted replaced
47:45e72b57a2fd 52:e3cecb93e76a 
    13 *
 
    13 *
 
    14 * Description:  Videoplayerengine test class implementation.
 
    14 * Description:  Videoplayerengine test class implementation.
 
    15 *
 
    15 *
 
    16 */
 
    16 */
 
    17 
    17 
    18 // Version : %version:  %
 
    18 // Version : %version:  da1mmcf#5 %
 
    19 
    19 
    20 // INCLUDES
 
    20 // INCLUDES
 
    21 #include <QtTest/QtTest>
 
    21 #include <QtTest/QtTest>
 
    22 #include <qdebug.h>
 
    22 #include <qdebug.h>
 
    23 #include <hbapplication.h>
 
    23 #include <hbapplication.h>
 
    29 
    29 
    30 #define private public
 
    30 #define private public
 
    31 #include "videoservices.h"
 
    31 #include "videoservices.h"
 
    32 #include "videoserviceurifetch.h"
 
    32 #include "videoserviceurifetch.h"
 
    33 #include "videoserviceplay.h"
 
    33 #include "videoserviceplay.h"
 
       
    34 #include "videoserviceuri.h"
 
    34 #undef private
 
    35 #undef private
 
    35 
    36 
    36 // ---------------------------------------------------------------------------
 
    37 // ---------------------------------------------------------------------------
 
    37 // main
 
    38 // main
 
    38 // ---------------------------------------------------------------------------
 
    39 // ---------------------------------------------------------------------------
 
    52 }
 
    53 }
 
    53 
    54 
    54 
    55 
    55 TestVideoServices::TestVideoServices()
 
    56 TestVideoServices::TestVideoServices()
 
    56     : mTestObject( 0 )
 
    57     : mTestObject( 0 )
 
    57 	, mEngine( 0 )
 
    58     , mEngine( 0 )
 
    58 {
 
    59 {
 
    59     MPX_DEBUG(_L("TestVideoServices::TestVideoServices()"));
 
    60     MPX_DEBUG(_L("TestVideoServices::TestVideoServices()"));
 
    60 }
 
    61 }
 
    61 
    62 
    62 TestVideoServices::~TestVideoServices()
 
    63 TestVideoServices::~TestVideoServices()
 
    78     MPX_ENTER_EXIT(_L("TestVideoServices::cleanup()"));
 
    79     MPX_ENTER_EXIT(_L("TestVideoServices::cleanup()"));
 
    79     
    80     
    80     delete mEngine;
 
    81     delete mEngine;
 
    81     mEngine = 0;
 
    82     mEngine = 0;
 
    82 	
    83 	
    83     QCOMPARE(mTestObject->mReferenceCount, 1);
 
    84     QCOMPARE( mTestObject->mReferenceCount, 1 );
 
    84 	if(mTestObject)
 
    85 
    85 	{
 
    86     if ( mTestObject)
 
    86 		mTestObject->decreaseReferenceCount();
 
    87     {
 
    87 	}
 
    88         mTestObject->decreaseReferenceCount();
 
    88 	mTestObject = 0;
 
    89     }
 
       
    90 
       
    91     mTestObject = 0;
 
    89 }
 
    92 }
 
    90 
    93 
    91 void TestVideoServices::testCreateDelete()
 
    94 void TestVideoServices::testCreateDelete()
 
    92 {
 
    95 {
 
    93     MPX_DEBUG(_L("TestVideoServices::testCreateDelete()"));
 
    96     MPX_DEBUG(_L("TestVideoServices::testCreateDelete()"));
 
    94     
    97     
    95 	mTestObject = VideoServices::instance();
 
    98     mTestObject = VideoServices::instance();
 
    96 
    99 
    97     QVERIFY(mTestObject);
 
   100     QVERIFY( mTestObject );
 
    98     QVERIFY(mTestObject->mServicePlay);
 
   101     QVERIFY( mTestObject->mServicePlay );
 
    99     QVERIFY(mTestObject->mServiceUriFetch);
 
   102     QVERIFY( mTestObject->mServiceUriFetch );
 
   100     QVERIFY(mTestObject->mServiceView);
 
   103     QVERIFY( mTestObject->mServiceView );
 
   101     QVERIFY(mTestObject->mEngine == 0);
 
   104     QVERIFY( mTestObject->mServiceUriView );
 
   102     QVERIFY(mTestObject->mCurrentService == VideoServices::ENoService);
 
   105     QVERIFY( mTestObject->mEngine == 0 );
 
       
   106     QVERIFY( mTestObject->mCurrentService == VideoServices::ENoService );
 
   103 }
 
   107 }
 
   104 
   108 
   105 void TestVideoServices::testCreateDeleteEngine()
 
   109 void TestVideoServices::testCreateDeleteEngine()
 
   106 {
 
   110 {
 
   107     MPX_DEBUG(_L("TestVideoServices::testCreateDeleteEngine()"));
 
   111     MPX_DEBUG(_L("TestVideoServices::testCreateDeleteEngine()"));
 
   108     
   112     
   109 	mEngine = new QVideoPlayerEngine();
 
   113     mEngine = new VideoPlayerEngine();
 
   110 	mTestObject = VideoServices::instance(mEngine);
 
   114     mTestObject = VideoServices::instance(mEngine);
 
   111 
   115 
   112     QVERIFY(mTestObject);
 
   116     QVERIFY( mTestObject );
 
   113     QVERIFY(mTestObject->mServicePlay);
 
   117     QVERIFY( mTestObject->mServicePlay );
 
   114     QVERIFY(mTestObject->mServiceUriFetch);
 
   118     QVERIFY( mTestObject->mServiceUriFetch );
 
   115     QVERIFY(mTestObject->mServiceView);
 
   119     QVERIFY( mTestObject->mServiceView );
 
   116     QVERIFY(mTestObject->mEngine == mEngine);
 
   120     QVERIFY( mTestObject->mServiceUriView );    
   117     QVERIFY(mTestObject->mCurrentService == VideoServices::ENoService);
 
   121     QVERIFY( mTestObject->mEngine == mEngine );
 
       
   122     QVERIFY( mTestObject->mCurrentService == VideoServices::ENoService );
 
   118 }
 
   123 }
 
   119 
   124 
   120 
   125 
   121 void TestVideoServices::testCurrentService()
 
   126 void TestVideoServices::testCurrentService()
 
   122 {
 
   127 {
 
   123     MPX_DEBUG(_L("TestVideoServices::testCurrentService()"));
 
   128     MPX_DEBUG(_L("TestVideoServices::testCurrentService()"));
 
   124     
   129     
   125 	mTestObject = VideoServices::instance();
 
   130     mTestObject = VideoServices::instance();
 
   126 
   131 
   127     QVERIFY(mTestObject);
 
   132     QVERIFY( mTestObject );
 
   128     QVERIFY(mTestObject->mServicePlay);
 
   133     QVERIFY( mTestObject->mServicePlay );
 
   129     QVERIFY(mTestObject->mServiceUriFetch);
 
   134     QVERIFY( mTestObject->mServiceUriFetch );
 
   130     QVERIFY(mTestObject->mServiceView);
 
   135     QVERIFY( mTestObject->mServiceView );
 
   131     QVERIFY(mTestObject->mEngine == 0);
 
   136     QVERIFY( mTestObject->mServiceUriView );    
   132     QVERIFY(mTestObject->mCurrentService == VideoServices::ENoService);
 
   137     QVERIFY( mTestObject->mEngine == 0 );
 
       
   138     QVERIFY( mTestObject->mCurrentService == VideoServices::ENoService );
 
   133 
   139 
   134     mTestObject->mServicePlay->playMedia(QString());
 
   140     mTestObject->mServicePlay->playMedia( QString() );
 
   135     QVERIFY(mTestObject->mCurrentService == VideoServices::ENoService);
 
   141     QVERIFY( mTestObject->mCurrentService == VideoServices::ENoService );
 
   136 
   142 
   137     mTestObject->mServiceUriFetch->fetch(QString());
 
   143     mTestObject->mServiceUriFetch->fetch( QString() );
 
   138     QVERIFY(mTestObject->mCurrentService == VideoServices::EUriFetcher);
 
   144     QVERIFY( mTestObject->mCurrentService == VideoServices::EUriFetcher );
 
   139     
   145     
   140     mTestObject->mServicePlay->playMedia(QString());
 
   146     mTestObject->mServicePlay->playMedia( QString() );
 
   141     QVERIFY(mTestObject->mCurrentService == VideoServices::EUriFetcher);
 
   147     QVERIFY( mTestObject->mCurrentService == VideoServices::EUriFetcher );
 
   142     
   148     
   143 	cleanup();
 
   149     cleanup();
 
   144 
   150 
   145 	mEngine = new QVideoPlayerEngine();
 
   151     mEngine = new VideoPlayerEngine();
 
   146 	mTestObject = VideoServices::instance(mEngine);
 
   152     mTestObject = VideoServices::instance(mEngine);
 
   147 
   153 
   148 	QVERIFY(mTestObject);
 
   154     QVERIFY( mTestObject );
 
   149     QVERIFY(mTestObject->mServicePlay);
 
   155     QVERIFY( mTestObject->mServicePlay );
 
   150     QVERIFY(mTestObject->mServiceUriFetch);
 
   156     QVERIFY( mTestObject->mServiceUriFetch );
 
   151     QVERIFY(mTestObject->mServiceView);
 
   157     QVERIFY( mTestObject->mServiceView );
 
   152     QVERIFY(mTestObject->mEngine == mEngine);
 
   158     QVERIFY( mTestObject->mEngine == mEngine );
 
   153     QVERIFY(mTestObject->mCurrentService == VideoServices::ENoService);
 
   159     QVERIFY( mTestObject->mCurrentService == VideoServices::ENoService );
 
   154 
   160 
   155     mTestObject->mServiceUriFetch->fetch(QString());
 
   161     mTestObject->mServiceUriFetch->fetch( QString() );
 
   156     QVERIFY(mTestObject->mCurrentService == VideoServices::EUriFetcher);
 
   162     QVERIFY( mTestObject->mCurrentService == VideoServices::EUriFetcher );
 
   157     
   163     
   158     mTestObject->mServicePlay->playMedia(QString());
 
   164     mTestObject->mServicePlay->playMedia( QString() );
 
   159     QVERIFY(mTestObject->mCurrentService == VideoServices::EPlayback);
 
   165     QVERIFY( mTestObject->mCurrentService == VideoServices::EPlayback );
 
       
   166     
       
   167     mTestObject->mServiceUriView->view( QString() );
 
       
   168     QVERIFY( mTestObject->mCurrentService == VideoServices::EUriView );    
   160 }
 
   169 }
 
   161 
   170 
   162 void TestVideoServices::cleanupTestCase()
 
   171 void TestVideoServices::cleanupTestCase()
 
   163 {
 
   172 {
 
   164     MPX_DEBUG(_L("TestVideoServices::cleanupTestCase()"));
 
   173     MPX_DEBUG(_L("TestVideoServices::cleanupTestCase()"));
FCL/sf/app/videoplayer