1 /**

     2 * Copyright (c) 2010 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:   tester for methods in TestMPXVideoPlaybackFileDetailsWidget

    15 * 

    16 */

    17 

    18 // Version : %version:  2 %

    19 

    20 

    21 #include <qdebug>

    22 #include <hbmainwindow.h>

    23 #include <hbapplication.h>

    24 #include <hblistwidget.h>

    25 #include <hblistwidgetitem.h>

    26 

    27 #include "mpxvideoplaybackviewfiledetails.h"

    28 #include "mpxvideoplaybackcontrolscontroller.h"

    29 #include "testmpxvideoplaybackfiledetailswidget.h"

    30 

    31 #define private public

    32 #include "mpxvideoplaybackfiledetailswidget.h"

    33 #undef private

    34 

    35 const QString KFILEPATH = "C:\\sample1.wav";

    36 

    37 

    38 // ---------------------------------------------------------------------------

    39 // main

    40 // ---------------------------------------------------------------------------

    41 //

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

    43 {

    44     MPX_ENTER_EXIT(_L("TestMPXVideoPlaybackFileDetailsWidget::Main()"));

    45 

    46     HbApplication app(argc, argv);

    47     HbMainWindow window;

    48 

    49     TestMPXVideoPlaybackFileDetailsWidget tv;

    50 

    51     char *pass[3];

    52     pass[0] = argv[0];

    53     pass[1] = "-o";

    54     pass[2] = "c:\\data\\testmpxvideoplaybackfiledetailswidget.txt";

    55     

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

    57     

    58     return res;

    59 }

    60 

    61 

    62 // ---------------------------------------------------------------------------

    63 // init

    64 // ---------------------------------------------------------------------------

    65 //

    66 void TestMPXVideoPlaybackFileDetailsWidget::init()

    67 {

    68     MPX_ENTER_EXIT(_L("TestMPXVideoPlaybackFileDetailsWidget::init()"));

    69 

    70     mController = new QMPXVideoPlaybackControlsController();   

    71     mWidget = new QMPXVideoPlaybackFileDetailsWidget( mController );

    72 }

    73 

    74 // ---------------------------------------------------------------------------

    75 // cleanup

    76 // ---------------------------------------------------------------------------

    77 //

    78 void TestMPXVideoPlaybackFileDetailsWidget::cleanup()

    79 {

    80     MPX_ENTER_EXIT(_L("TestMPXVideoPlaybackFileDetailsWidget::cleanup()"));

    81 

    82     if ( mController )

    83     {

    84         delete mController;

    85         mController = NULL;

    86     }

    87 

    88     if ( mWidget )

    89     {

    90         delete mWidget;

    91         mWidget = NULL;

    92     }

    93 }

    94 

    95 // ---------------------------------------------------------------------------

    96 // testTitle

    97 // ---------------------------------------------------------------------------

    98 //

    99 void TestMPXVideoPlaybackFileDetailsWidget::testTitle()

   100 {

   101     MPX_ENTER_EXIT(_L("TestMPXVideoPlaybackFileDetailsWidget::testTitle()"));

   102 

   103     init();

   104 

   105     QMPXVideoPlaybackViewFileDetails *details = mController->fileDetails();

   106 

   107     //

   108     // For Audio only view

   109     //

   110     mController->mViewMode = EAudioOnlyView;

   111 

   112     // If title information is available

   113     details->mTitle = "Title for Test clip";

   114     mWidget->updateWithFileDetails( details );

   115     verifyResult( "Title", true, details->mTitle );

   116 

   117     mWidget->mListWidget->clear();

   118     mWidget->mFileDetailsUpdated = false;

   119 

   120     // If title informatio is not available

   121     details->mTitle = "";

   122     details->mClipName = KFILEPATH;

   123 

   124     mWidget->updateWithFileDetails( details );

   125     verifyResult( "Title", true, "sample1" );

   126 

   127     mWidget->mListWidget->clear();

   128     mWidget->mFileDetailsUpdated = false;

   129 

   130     //

   131     // For Details view

   132     //

   133     mController->mViewMode = EFullScreenView;

   134 

   135     mWidget->updateWithFileDetails( details );

   136 

   137     verifyResult( "Title", false );

   138 

   139     cleanup();

   140 }

   141 

   142 // ---------------------------------------------------------------------------

   143 // testDescription

   144 // ---------------------------------------------------------------------------

   145 //

   146 void TestMPXVideoPlaybackFileDetailsWidget::testDescription()

   147 {

   148     MPX_ENTER_EXIT(_L("TestMPXVideoPlaybackFileDetailsWidget::testDescription()"));

   149 

   150     init();

   151 

   152     QMPXVideoPlaybackViewFileDetails *details = mController->fileDetails();

   153     details->mDescription = "This is for unit test";

   154     

   155     mWidget->updateWithFileDetails( details );

   156 

   157     verifyResult( "Description", true, details->mDescription );

   158 

   159     cleanup();

   160 }

   161 

   162 // ---------------------------------------------------------------------------

   163 // testDate

   164 // ---------------------------------------------------------------------------

   165 //

   166 void TestMPXVideoPlaybackFileDetailsWidget::testDuration()

   167 {

   168     MPX_ENTER_EXIT(_L("TestMPXVideoPlaybackFileDetailsWidget::testDuration()"));

   169 

   170     init();

   171 

   172     QMPXVideoPlaybackViewFileDetails *details = mController->fileDetails();

   173 

   174     //

   175     // If it's local mode, need to show the duration

   176     //

   177     details->mPlaybackMode = EMPXVideoLiveStreaming;

   178     details->mDuration = 3700000;

   179     

   180     mWidget->updateWithFileDetails( details );

   181 

   182     verifyResult( "Duration", "" );

   183 

   184     mWidget->mListWidget->clear();

   185     mWidget->mFileDetailsUpdated = false;

   186 

   187     //

   188     // If it's local mode, need to show the duration

   189     //

   190     details->mPlaybackMode = EMPXVideoLocal;

   191     details->mDuration = 3700000;

   192     

   193     mWidget->updateWithFileDetails( details );

   194 

   195     verifyResult( "Duration", true, "1 hr 1 min 40 sec " );

   196 

   197     cleanup();

   198 }

   199 

   200 // ---------------------------------------------------------------------------

   201 // testDate

   202 // ---------------------------------------------------------------------------

   203 //

   204 void TestMPXVideoPlaybackFileDetailsWidget::testDate()

   205 {

   206     MPX_ENTER_EXIT(_L("TestMPXVideoPlaybackFileDetailsWidget::testDate()"));

   207 

   208     init();

   209 

   210     QMPXVideoPlaybackViewFileDetails *details = mController->fileDetails();

   211 

   212     //

   213     // If it is streaming case, we don't show size information

   214     //

   215     details->mClipName = KFILEPATH;

   216     details->mPlaybackMode = EMPXVideoStreaming;

   217     mWidget->updateWithFileDetails( details );

   218 

   219     verifyResult( "Date", false );

   220     verifyResult( "Modified", false );

   221 

   222     mWidget->mListWidget->clear();

   223     mWidget->mFileDetailsUpdated = false;

   224 

   225     //

   226     // If it is local, we  show size information

   227     //

   228     details->mClipName = KFILEPATH;

   229     details->mPlaybackMode = EMPXVideoLocal;

   230     mWidget->updateWithFileDetails( details );

   231 

   232     verifyResult( "Date", true, "", false );

   233     verifyResult( "Modified", true, "", false );

   234 

   235     cleanup();

   236 }

   237 

   238 // ---------------------------------------------------------------------------

   239 // testLocation

   240 // ---------------------------------------------------------------------------

   241 //

   242 void TestMPXVideoPlaybackFileDetailsWidget::testLocation()

   243 {

   244     MPX_ENTER_EXIT(_L("TestMPXVideoPlaybackFileDetailsWidget::testLocation()"));

   245 

   246     init();

   247 

   248     QMPXVideoPlaybackViewFileDetails *details = mController->fileDetails();

   249     details->mLocation = "C:\\data\\Videos\\";

   250     

   251     mWidget->updateWithFileDetails( details );

   252 

   253     verifyResult( "Location", true, details->mLocation );

   254 

   255     cleanup();

   256 }

   257 

   258 // ---------------------------------------------------------------------------

   259 // testAuthor

   260 // ---------------------------------------------------------------------------

   261 //

   262 void TestMPXVideoPlaybackFileDetailsWidget::testAuthor()

   263 {

   264     MPX_ENTER_EXIT(_L("TestMPXVideoPlaybackFileDetailsWidget::testAuthor()"));

   265 

   266     init();

   267 

   268     QMPXVideoPlaybackViewFileDetails *details = mController->fileDetails();

   269     details->mArtist = "Fusion";

   270     

   271     mWidget->updateWithFileDetails( details );

   272 

   273     verifyResult( "Author", true, details->mArtist );

   274 

   275     cleanup();

   276 }

   277 

   278 // ---------------------------------------------------------------------------

   279 // testCopyright

   280 // ---------------------------------------------------------------------------

   281 //

   282 void TestMPXVideoPlaybackFileDetailsWidget::testCopyright()

   283 {

   284     MPX_ENTER_EXIT(_L("TestMPXVideoPlaybackFileDetailsWidget::testCopyright()"));

   285 

   286     init();

   287 

   288     QMPXVideoPlaybackViewFileDetails *details = mController->fileDetails();

   289     details->mCopyright = "Fusion team";

   290     

   291     mWidget->updateWithFileDetails( details );

   292 

   293     verifyResult( "Copyright", true, details->mCopyright );

   294 

   295     cleanup();

   296 }

   297 

   298 // ---------------------------------------------------------------------------

   299 // testLanguage

   300 // ---------------------------------------------------------------------------

   301 //

   302 void TestMPXVideoPlaybackFileDetailsWidget::testLanguage()

   303 {

   304     MPX_ENTER_EXIT(_L("TestMPXVideoPlaybackFileDetailsWidget::testLanguage()"));

   305 

   306     init();

   307 

   308     QMPXVideoPlaybackViewFileDetails *details = mController->fileDetails();

   309     details->mLanguage = "English";

   310     

   311     mWidget->updateWithFileDetails( details );

   312 

   313     verifyResult( "Language", true, details->mLanguage );

   314 

   315     cleanup();

   316 }

   317 

   318 // ---------------------------------------------------------------------------

   319 // testKeywords

   320 // ---------------------------------------------------------------------------

   321 //

   322 void TestMPXVideoPlaybackFileDetailsWidget::testKeywords()

   323 {

   324     MPX_ENTER_EXIT(_L("TestMPXVideoPlaybackFileDetailsWidget::testKeywords()"));

   325 

   326     init();

   327 

   328     QMPXVideoPlaybackViewFileDetails *details = mController->fileDetails();

   329     details->mKeywords = "QTest";

   330     

   331     mWidget->updateWithFileDetails( details );

   332 

   333     verifyResult( "Keywords", true, details->mKeywords );

   334 

   335     cleanup();

   336 }

   337 

   338 // ---------------------------------------------------------------------------

   339 // testSize

   340 // ---------------------------------------------------------------------------

   341 //

   342 void TestMPXVideoPlaybackFileDetailsWidget::testSize()

   343 {

   344     MPX_ENTER_EXIT(_L("TestMPXVideoPlaybackFileDetailsWidget::testSize()"));

   345 

   346     init();

   347 

   348     QMPXVideoPlaybackViewFileDetails *details = mController->fileDetails();

   349 

   350     //

   351     // If it is streaming case, we don't show size information

   352     //

   353     details->mPlaybackMode = EMPXVideoStreaming;

   354     details->mClipName = KFILEPATH;

   355 

   356     mWidget->updateWithFileDetails( details );

   357 

   358     verifyResult( "Size", false );

   359 

   360     mWidget->mListWidget->clear();

   361     mWidget->mFileDetailsUpdated = false;

   362 

   363     //

   364     // If it is local, we show size information

   365     //

   366     details->mPlaybackMode = EMPXVideoLocal;

   367     mWidget->updateWithFileDetails( details );

   368     

   369     verifyResult( "Size", true, "", false );

   370 

   371     cleanup();

   372 }

   373 

   374 // ---------------------------------------------------------------------------

   375 // testResolution

   376 // ---------------------------------------------------------------------------

   377 //

   378 void TestMPXVideoPlaybackFileDetailsWidget::testResolution()

   379 {

   380     MPX_ENTER_EXIT(_L("TestMPXVideoPlaybackFileDetailsWidget::testResolution()"));

   381 

   382     init();

   383 

   384     QMPXVideoPlaybackViewFileDetails *details = mController->fileDetails();

   385 

   386     //

   387     // If it is audio only clip, don't need to show resolution

   388     //

   389     details->mVideoEnabled = false;

   390     

   391     mWidget->updateWithFileDetails( details );

   392 

   393     verifyResult( "Resolution", false );

   394 

   395     mWidget->mListWidget->clear();

   396     mWidget->mFileDetailsUpdated = false;

   397 

   398     //

   399     // If it has video track

   400     //

   401     details->mVideoEnabled = true;

   402     details->mVideoWidth = 640;

   403     details->mVideoHeight = 360;

   404 

   405     mWidget->updateWithFileDetails( details );

   406 

   407     QString resolution = QString("%1 x %2")

   408             .arg( details->mVideoWidth ).arg( details->mVideoHeight );

   409 

   410     verifyResult( "Resolution", true, resolution );

   411 

   412     cleanup();

   413 }

   414 

   415 // ---------------------------------------------------------------------------

   416 // testFormat

   417 // ---------------------------------------------------------------------------

   418 //

   419 void TestMPXVideoPlaybackFileDetailsWidget::testFormat()

   420 {

   421     MPX_ENTER_EXIT(_L("TestMPXVideoPlaybackFileDetailsWidget::testFormat()"));

   422 

   423     init();

   424 

   425     QMPXVideoPlaybackViewFileDetails *details = mController->fileDetails();

   426     details->mMimeType = "Nothing";

   427     

   428     mWidget->updateWithFileDetails( details );

   429 

   430     verifyResult( "Format", true, details->mMimeType );

   431 

   432     cleanup();

   433 }

   434 

   435 // ---------------------------------------------------------------------------

   436 // testBitrate

   437 // ---------------------------------------------------------------------------

   438 //

   439 void TestMPXVideoPlaybackFileDetailsWidget::testBitrate()

   440 {

   441     MPX_ENTER_EXIT(_L("TestMPXVideoPlaybackFileDetailsWidget::testBitrate()"));

   442 

   443 

   444     init();

   445 

   446     QMPXVideoPlaybackViewFileDetails *details = mController->fileDetails();

   447     details->mBitRate = 1024;

   448     

   449     mWidget->updateWithFileDetails( details );

   450 

   451     verifyResult( "Bitrate", true, "1024 Kbps" );

   452 

   453     cleanup();

   454 }

   455 

   456 // ---------------------------------------------------------------------------

   457 // testFolder

   458 // ---------------------------------------------------------------------------

   459 //

   460 void TestMPXVideoPlaybackFileDetailsWidget::testFolder()

   461 {

   462     MPX_ENTER_EXIT(_L("TestMPXVideoPlaybackFileDetailsWidget::testFolder()"));

   463 

   464     init();

   465 

   466     QMPXVideoPlaybackViewFileDetails *details = mController->fileDetails();

   467 

   468     //

   469     // If it is streaming case, we don't show folder information

   470     //

   471     details->mPlaybackMode = EMPXVideoStreaming;

   472     details->mClipName = KFILEPATH;

   473     

   474     mWidget->updateWithFileDetails( details );

   475 

   476     verifyResult( "Collection", false );

   477 

   478     mWidget->mListWidget->clear();

   479     mWidget->mFileDetailsUpdated = false;

   480 

   481     //

   482     // If it is local case, we show folder information

   483     //

   484     details->mPlaybackMode = EMPXVideoLocal;

   485 

   486     mWidget->updateWithFileDetails( details );

   487 

   488     verifyResult( "Collection", false );

   489 

   490     cleanup();

   491 

   492 }

   493 

   494 // ---------------------------------------------------------------------------

   495 // verifyResult

   496 // ---------------------------------------------------------------------------

   497 //

   498 void TestMPXVideoPlaybackFileDetailsWidget::verifyResult( 

   499         QString primaryText, bool exist, QString expectedSecondaryText, bool needToBeCompared )

   500 {

   501     QString secondaryText = "";

   502     int i = 0;

   503 

   504     for( ; i < mWidget->mListWidget->count() ; i++ )

   505     {

   506         HbListWidgetItem *item = mWidget->mListWidget->item( i );

   507 

   508         if ( item->text() == primaryText )

   509         {

   510             secondaryText = item->secondaryText();

   511             break;

   512         }

   513     }

   514 

   515     //

   516     // If the item needs to be existed in HbListWidget, check the result

   517     //

   518     if ( exist )

   519     {

   520         if ( needToBeCompared )

   521         {

   522             QVERIFY( expectedSecondaryText == secondaryText );

   523         }

   524         else

   525         {

   526             //

   527             // Doens't need to compare the secondary text. Just make sure it's in the list

   528             //

   529             QVERIFY( i < mWidget->mListWidget->count() );

   530         }

   531 

   532     }

   533     //

   534     // If not, just make sure that item is not in the list

   535     //

   536     else

   537     {

   538         QVERIFY( i == mWidget->mListWidget->count() );

   539     }

   540 }

   541 

   542 // End of file