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:  Videoplayerengine test class implementation.

    15 *

    16 */

    17 

    18 // Version : %version:  1 %

    19 

    20 // INCLUDES

    21 

    22 #include <QtTest/QtTest>

    23 #include <qdebug.h>

    24 #include <hbapplication.h>

    25 

    26 #include "mpxhbvideocommondefs.h"

    27 #include "testvideoiadupdatewrapper.h"

    28 #include "mpxvideo_debug.h"

    29 

    30 #include "iaupdate.h"

    31 #include "iaupdateparameters.h"

    32 #include "iaupdateresult.h"

    33 

    34 #define private public

    35 #include "videoiadupdatewrapper.h"

    36 #undef private

    37 

    38 extern int IsFeatureSupported;

    39 

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

    41 // main

    42 // ---------------------------------------------------------------------------

    43 //

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

    45 {

    46     HbApplication app(argc, argv);

    47 

    48     TestVideoIadUpdateWrapper tc;

    49 

    50     char *pass[3];

    51     pass[0] = argv[0];

    52     pass[1] = "-o";

    53     pass[2] = "c:\\data\\TestVideoIadUpdateWrapper.txt";

    54 

    55     return QTest::qExec(&tc, 3, pass);

    56 }

    57 

    58 

    59 TestVideoIadUpdateWrapper::TestVideoIadUpdateWrapper()

    60     : mTestObject( 0 )

    61 {

    62     MPX_DEBUG(_L("TestVideoIadUpdateWrapper::TestVideoIadUpdateWrapper()"));

    63 }

    64 

    65 TestVideoIadUpdateWrapper::~TestVideoIadUpdateWrapper()

    66 {

    67     MPX_ENTER_EXIT(_L("TestVideoIadUpdateWrapper::~TestVideoIadUpdateWrapper()"));

    68     

    69     delete mTestObject;

    70     mTestObject = 0;

    71 }

    72 

    73 

    74 void TestVideoIadUpdateWrapper::init()

    75 {

    76     MPX_DEBUG(_L("TestVideoIadUpdateWrapper::init()"));

    77     

    78     mTestObject = new VideoIadUpdateWrapper();

    79 }

    80 

    81 void TestVideoIadUpdateWrapper::cleanup()

    82 {

    83     MPX_ENTER_EXIT(_L("TestVideoIadUpdateWrapper::cleanup()"));

    84 

    85     delete mTestObject;

    86     mTestObject = 0;

    87 }

    88 

    89 void TestVideoIadUpdateWrapper::TestCreateDelete()

    90 {

    91     MPX_DEBUG(_L("TestVideoIadUpdateWrapper::testCreateDelete()"));

    92     

    93     init();

    94 

    95     QVERIFY( mTestObject );

    96     QVERIFY( mTestObject->mUpdate == 0);

    97     QVERIFY( mTestObject->mParameters == 0);

    98     

    99     cleanup();

   100 

   101     QVERIFY( mTestObject == 0 );

   102 }

   103 

   104 void TestVideoIadUpdateWrapper::cleanupTestCase()

   105 {

   106     MPX_DEBUG(_L("TestVideoIadUpdateWrapper::cleanupTestCase()"));

   107     // all common cleanup here

   108 }

   109 

   110 void TestVideoIadUpdateWrapper::TestCheckForUpdates()

   111 {

   112     MPX_DEBUG(_L("TestVideoIadUpdateWrapper::testCheckForUpdates()"));

   113 

   114     init();

   115 

   116     QVERIFY( mTestObject );

   117     

   118     IsFeatureSupported = 1;

   119     

   120     mTestObject->checkForUpdates();

   121 

   122     QVERIFY( mTestObject );

   123     QVERIFY( mTestObject->mUpdate != 0);

   124     QVERIFY( mTestObject->mParameters != 0);

   125     

   126     cleanup();

   127 }

   128 

   129 void TestVideoIadUpdateWrapper::TestCheckUpdatesComplete()

   130 {

   131     MPX_DEBUG(_L("TestVideoIadUpdateWrapper::TestCheckUpdatesComplete()"));

   132 

   133     init();

   134 

   135     QVERIFY( mTestObject );

   136     

   137     // error case: do nothing

   138     TInt errorCode = 1;

   139     TInt availableUpdates = 0;

   140     

   141     mTestObject->CheckUpdatesComplete(errorCode, availableUpdates);

   142 

   143     QVERIFY( mTestObject );

   144     QVERIFY( mTestObject->mUpdate == 0);

   145     QVERIFY( mTestObject->mParameters == 0);

   146 

   147     // update available

   148     errorCode=0;

   149     availableUpdates=1;

   150     

   151     mTestObject->mUpdate = CIAUpdate::NewL( *mTestObject );

   152     mTestObject->mParameters = CIAUpdateParameters::NewL();

   153     mTestObject->CheckUpdatesComplete(errorCode, availableUpdates);

   154 

   155     QVERIFY( mTestObject );

   156     QVERIFY( mTestObject->mUpdate != 0);

   157     QVERIFY( mTestObject->mParameters != 0);    

   158     

   159     // no update, everything should be deleted

   160     errorCode = 0;

   161     availableUpdates = 0;

   162     

   163     mTestObject->CheckUpdatesComplete(errorCode, availableUpdates);

   164 

   165     QVERIFY( mTestObject );

   166     QVERIFY( mTestObject->mUpdate == 0);

   167     QVERIFY( mTestObject->mParameters == 0);

   168     

   169 

   170     

   171     cleanup();

   172 }

   173 

   174 void TestVideoIadUpdateWrapper::TestUpdateComplete()

   175 {

   176     MPX_DEBUG(_L("TestVideoIadUpdateWrapper::TestUpdateComplete()"));

   177 

   178     init();

   179 

   180     QVERIFY( mTestObject );

   181     TInt errorCode(0);

   182     CIAUpdateResult* resultDetails = new CIAUpdateResult;    

   183     mTestObject->UpdateComplete(errorCode, resultDetails);

   184 

   185     QVERIFY( mTestObject );

   186     QVERIFY( mTestObject->mUpdate == 0);

   187     QVERIFY( mTestObject->mParameters == 0);

   188     

   189     cleanup();

   190 }

   191 

   192 void TestVideoIadUpdateWrapper::TestUpdateQueryComplete()

   193 {

   194     MPX_DEBUG(_L("TestVideoIadUpdateWrapper::TestUpdateQueryComplete()"));

   195 

   196     init();

   197 

   198     QVERIFY( mTestObject );

   199     

   200     // no error, no update: cleans up the members.

   201     

   202     TInt errorCode(0);

   203     TBool updateNow(0);

   204 

   205     mTestObject->mUpdate = CIAUpdate::NewL( *mTestObject );

   206     mTestObject->mParameters = CIAUpdateParameters::NewL();

   207     

   208     mTestObject->UpdateQueryComplete(errorCode, updateNow);

   209     

   210     QVERIFY( mTestObject );

   211     QVERIFY( mTestObject->mUpdate == 0);

   212     QVERIFY( mTestObject->mParameters == 0);

   213     

   214     // error case: does nothing

   215     

   216     errorCode = 1;

   217     updateNow = 0;

   218     

   219     mTestObject->UpdateQueryComplete(errorCode, updateNow);

   220     

   221     QVERIFY( mTestObject );

   222     QVERIFY( mTestObject->mUpdate == 0);

   223     QVERIFY( mTestObject->mParameters == 0);

   224     

   225     // the update case: should preserve members, strats the update.

   226     

   227     errorCode = 0;

   228     updateNow = 1;

   229     

   230     mTestObject->mUpdate = CIAUpdate::NewL(  *mTestObject  );

   231     mTestObject->mParameters = CIAUpdateParameters::NewL();

   232     

   233     mTestObject->UpdateQueryComplete(errorCode, updateNow);

   234     

   235     QVERIFY( mTestObject );

   236     QVERIFY( mTestObject->mUpdate != 0);

   237     QVERIFY( mTestObject->mParameters != 0);

   238     

   239     cleanup();

   240 }

   241 

   242 void TestVideoIadUpdateWrapper::TestDoCheckForUpdatesL()

   243 {

   244     MPX_DEBUG(_L("TestVideoIadUpdateWrapper::TestdoCheckForUpdatesL()"));

   245 

   246     init();

   247 

   248     QVERIFY( mTestObject );

   249     

   250     // feature not supported

   251 

   252     IsFeatureSupported = 0;

   253     mTestObject->doCheckForUpdatesL();

   254 

   255     QVERIFY( mTestObject );

   256     QVERIFY( mTestObject->mUpdate == 0);

   257     QVERIFY( mTestObject->mParameters == 0);

   258 

   259     // feature  supported, initializes the data

   260     

   261     IsFeatureSupported = 1;

   262     mTestObject->doCheckForUpdatesL();

   263 

   264     QVERIFY( mTestObject );

   265     QVERIFY( mTestObject->mUpdate != 0);

   266     QVERIFY( mTestObject->mParameters != 0);

   267     

   268     cleanup();

   269 }

   270 

   271 void TestVideoIadUpdateWrapper::TestCleanup()

   272 {

   273     MPX_DEBUG(_L("TestVideoIadUpdateWrapper::Testcleanup()"));

   274 

   275     init();

   276 

   277     QVERIFY( mTestObject );

   278     

   279     mTestObject->cleanup();

   280 

   281     QVERIFY( mTestObject );

   282     QVERIFY( mTestObject->mUpdate == 0);

   283     QVERIFY( mTestObject->mParameters == 0);

   284     

   285     cleanup();

   286 }

   287 

   288 // End of file

   289