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: 

    15 *

    16 */

    17 

    18 #include "unittest_medialistwrapper.h"

    19 #include "glxmlwrapper.h"

    20 #include <glxcollectionpluginall.hrh>

    21 #include <glxmodelparm.h>

    22 #include <hbicon.h>

    23 #include <qdatetime.h>

    24 #include <QString>

    25 

    26 

    27 

    28 

    29 // -----------------------------------------------------------------------------

    30 // initTestCase

    31 // -----------------------------------------------------------------------------

    32 //

    33 void TestGlxMLWrapper::initTestCase()

    34 {

    35     mTestObject = 0;

    36     mTestObject = new GlxMLWrapper(KGlxCollectionPluginAllImplementationUid,0,EGlxFilterImage);

    37     QVERIFY(mTestObject);

    38 }

    39 

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

    41 // init

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

    43 //

    44 void TestGlxMLWrapper::init()

    45 {

    46    

    47 }

    48 

    49 // -----------------------------------------------------------------------------

    50 // cleanup

    51 // -----------------------------------------------------------------------------

    52 //

    53 void TestGlxMLWrapper::cleanup()

    54 {

    55 

    56 }

    57 

    58 // -----------------------------------------------------------------------------

    59 // cleanupTestCase

    60 // -----------------------------------------------------------------------------

    61 //

    62 void TestGlxMLWrapper::cleanupTestCase()

    63 {

    64     if(mTestObject)

    65     {

    66         delete mTestObject;

    67         mTestObject = 0;

    68     }  

    69 }

    70 

    71 // -----------------------------------------------------------------------------

    72 // testGetItemCount

    73 // -----------------------------------------------------------------------------

    74 //

    75 void TestGlxMLWrapper::testGetItemCount()

    76 {

    77     QTest::qWait(3000);

    78     int count = mTestObject->getItemCount();

    79     QVERIFY(count >= 0);

    80 }

    81 

    82 

    83 void TestGlxMLWrapper::testGetFocusIndex()

    84 {

    85     int focusIndex = mTestObject->getFocusIndex();

    86    //QVERIFY(focusIndex == -1);

    87     mTestObject->setFocusIndex(mTestObject->getItemCount()-1);

    88     focusIndex = mTestObject->getFocusIndex();

    89     QVERIFY(focusIndex == mTestObject->getItemCount()-1);

    90 }

    91 

    92 void TestGlxMLWrapper::testSetFocusIndex()

    93 {

    94     mTestObject->setFocusIndex(mTestObject->getItemCount()-1);

    95     int focusIndex = mTestObject->getFocusIndex();

    96     QVERIFY(focusIndex == mTestObject->getItemCount()-1);

    97 }

    98 

    99 void TestGlxMLWrapper::testSetContextMode()

   100 {

   101     int itemIndex = mTestObject->getItemCount()-1;

   102     

   103     //Retriveing without adding any context .so grid icon should be NULL

   104     HbIcon* icon = mTestObject->retrieveItemIcon(itemIndex,GlxTBContextGrid);

   105     QVERIFY(icon == NULL);

   106     

   107     // After adding grid context should get grid icon 

   108     mTestObject->setContextMode(GlxContextPtGrid);

   109     QTest::qWait(10000);

   110     icon = mTestObject->retrieveItemIcon(itemIndex,GlxTBContextGrid);

   111     QVERIFY(icon != NULL);

   112 }

   113 

   114 void TestGlxMLWrapper::testRetrieveItemUri()

   115 {

   116     qDebug("TestGlxMLWrapper::testRetrieveItemUri enter");

   117 	

   118 	int count = mTestObject->getItemCount();

   119 	mTestObject->setContextMode(GlxContextPtGrid);

   120     QTest::qWait(10000);

   121 	QString uri = mTestObject->retrieveItemUri(count-1);

   122 	qDebug("TestGlxMLWrapper::testRetrieveItemUri =%d",uri.isEmpty());

   123 	QVERIFY( uri.isEmpty() == 0 );

   124 }

   125 

   126 void TestGlxMLWrapper::testRetrieveItemUriName()

   127 {

   128     qDebug("TestGlxMLWrapper::testRetrieveItemUriName enter");

   129 	

   130 	int count = mTestObject->getItemCount();

   131 	mTestObject->setContextMode(GlxContextPtGrid);

   132     QTest::qWait(10000);

   133     	

   134     QString uri = mTestObject->retrieveItemUri(count-1);

   135 	QString imageName = uri.section('\\',-1);

   136     qDebug("TestGlxMLWrapper::testRetrieveItemUriName =%d",uri.isEmpty());

   137     QVERIFY( imageName.isEmpty() == 0 );

   138 }

   139 

   140 void TestGlxMLWrapper::testRetrieveItemIconIsNull()

   141 {

   142    int itemIndex = mTestObject->getItemCount()-1;

   143 // grid icon should be NULL

   144     HbIcon* icon = mTestObject->retrieveItemIcon(itemIndex,GlxTBContextGrid);

   145     QVERIFY(icon == NULL);

   146     

   147     // fullscreen icon should be NULL

   148     icon = mTestObject->retrieveItemIcon(itemIndex,GlxTBContextLsFs);

   149     QVERIFY(icon == NULL);   

   150 }

   151 

   152 void TestGlxMLWrapper::testRetrieveItemIcon()

   153 {

   154     int itemIndex = mTestObject->getItemCount()-1;

   155     

   156     // Should get fullscreen icon 

   157     mTestObject->setContextMode(GlxContextLsFs);

   158     QTest::qWait(4000);

   159     HbIcon* icon = mTestObject->retrieveItemIcon(itemIndex,GlxTBContextLsFs);

   160     QVERIFY(icon != NULL);

   161     

   162     // Should get grid icon

   163     mTestObject->setContextMode(GlxContextPtGrid);

   164     QTest::qWait(2000);

   165     icon = mTestObject->retrieveItemIcon(itemIndex,GlxTBContextGrid);

   166     QVERIFY(icon != NULL);

   167 	   

   168 }

   169 

   170 void TestGlxMLWrapper::testRetrieveItemDateIsNotNull()

   171 {

   172     qDebug("TestGlxMLWrapper::testRetrieveItemDateIsNotNull enter");

   173     int count = mTestObject->getItemCount();

   174     mTestObject->setContextMode(GlxContextPtGrid);

   175     QTest::qWait(10000);

   176 	

   177 	QDate date = mTestObject->retrieveItemDate(count-1);

   178     qDebug("TestGlxMLWrapper::testRetrieveItemDateIsNotNull =%d",date.isNull());

   179     QVERIFY( date.isNull() == 0 );

   180 }

   181 

   182 

   183 void TestGlxMLWrapper::testRetrieveItemDateIsValid()

   184 {

   185     qDebug("TestGlxMLWrapper::testRetrieveItemDateIsValid enter");

   186     int count = mTestObject->getItemCount();

   187     mTestObject->setContextMode( GlxContextPtGrid );

   188     QTest::qWait(10000);

   189 	

   190 	QDate date = mTestObject->retrieveItemDate(count-1);

   191 	qDebug("TestGlxMLWrapper::testRetrieveItemDateIsValid IsNull=%d",date.isNull());

   192     qDebug("TestGlxMLWrapper::testRetrieveItemDateIsValid IsValid=%d",date.isValid() );

   193 	

   194     QVERIFY( date.isNull() == 0 );

   195     QVERIFY( date.isValid() == 1 );

   196 }

   197 

   198 void TestGlxMLWrapper::testRetrieveItemDateValidate()

   199 {

   200     qDebug("TestGlxMLWrapper::testRetrieveItemDateValidate enter");

   201     int count = mTestObject->getItemCount();

   202 	mTestObject->setContextMode( GlxContextPtGrid );

   203     QTest::qWait(10000);

   204 	

   205     QDate date = mTestObject->retrieveItemDate(count-1);

   206     qDebug("TestGlxMLWrapper::testRetrieveItemDateValidate =%d",date.isValid(date.year(), date.month(), date.day()) );

   207     QVERIFY( date.isValid(date.year(), date.month(), date.day()) == 1 );

   208 }

   209 

   210 void TestGlxMLWrapper::testGetVisibleWindowIndex()

   211 {

   212     int visibleIndex = mTestObject->getVisibleWindowIndex();

   213     QVERIFY(visibleIndex == 0);

   214     

   215     int itemIndex = mTestObject->getItemCount()-1;

   216     mTestObject->setVisibleWindowIndex(itemIndex);

   217     visibleIndex = mTestObject->getVisibleWindowIndex();

   218     QVERIFY(visibleIndex == itemIndex);

   219 }

   220 

   221 void TestGlxMLWrapper::testSetVisibleWindowIndex()

   222 {

   223     int itemIndex = mTestObject->getItemCount()-1;

   224     mTestObject->setVisibleWindowIndex(itemIndex);

   225     int visibleIndex = mTestObject->getVisibleWindowIndex();

   226     QVERIFY(visibleIndex == itemIndex);

   227 }

   228 

   229 void TestGlxMLWrapper::testItemsAdded()

   230 {

   231     QSignalSpy spysignal(mTestObject, SIGNAL(insertItems(int ,int )));

   232     QVERIFY(spysignal.count() == 0);

   233     

   234     int index = mTestObject->getItemCount();

   235     spysignal.clear(); 

   236 

   237     mTestObject->itemsAdded(index,index + 5);

   238     qDebug("Signal Count %d",spysignal.count());

   239     QVERIFY(spysignal.count() == 1);

   240     QVERIFY(spysignal.value(0).at(0).toInt() == index);

   241     QVERIFY(spysignal.value(0).at(1).toInt() == index+5);

   242 

   243     mTestObject->itemsAdded(index + 6,index + 6);

   244     qDebug("Signal #Count %d",spysignal.count());

   245     QVERIFY(spysignal.count() == 2);

   246     QVERIFY(spysignal.value(1).at(0).toInt() == index+6);

   247     QVERIFY(spysignal.value(1).at(1).toInt() == index+6);

   248 }

   249 

   250 void TestGlxMLWrapper::testItemsRemoved()

   251 {

   252     QSignalSpy spysignal(mTestObject, SIGNAL(removeItems(int ,int )));

   253     QVERIFY(spysignal.count() == 0);

   254     

   255     int index = mTestObject->getItemCount();

   256     spysignal.clear(); 

   257 

   258     mTestObject->itemsRemoved(index,index + 5);

   259     qDebug("Signal Count %d",spysignal.count());

   260     QVERIFY(spysignal.count() == 1);

   261     QVERIFY(spysignal.value(0).at(0).toInt() == index);

   262     QVERIFY(spysignal.value(0).at(1).toInt() == index+5);

   263 

   264     mTestObject->itemsRemoved(index + 6,index + 6);

   265     qDebug("Signal #Count %d",spysignal.count());

   266     QVERIFY(spysignal.count() == 2);

   267     QVERIFY(spysignal.value(1).at(0).toInt() == index+6);

   268     QVERIFY(spysignal.value(1).at(1).toInt() == index+6);

   269 }

   270 

   271 void TestGlxMLWrapper::testHandleReceivedIcon()

   272 {

   273     qRegisterMetaType<GlxTBContextType>("GlxTBContextType");

   274     QSignalSpy spysignal(mTestObject, SIGNAL(updateItem(int , GlxTBContextType )));

   275     QVERIFY(spysignal.count() == 0);

   276     

   277     int count = mTestObject->getItemCount();

   278     spysignal.clear(); 

   279 

   280     mTestObject->handleReceivedIcon(count-1,GlxTBContextGrid);

   281     qDebug("Signal Count %d",spysignal.count());

   282     QVERIFY(spysignal.count() == 1);

   283     QVERIFY(spysignal.value(0).at(0).toInt() == count-1);

   284     QVERIFY(spysignal.value(0).at(1).toInt() == GlxTBContextGrid);

   285     spysignal.clear(); 

   286 

   287     // mTestObject->handleReceivedIcon(count-1,GlxTBContextLsFs);

   288     // qDebug("Signal Count %d",spysignal.count());

   289     // QVERIFY(spysignal.count() == 1);

   290     // QVERIFY(spysignal.value(0).at(0).toInt() == count-1);

   291     // QVERIFY(spysignal.value(0).at(1).toInt() == GlxTBContextLsFs);

   292     // spysignal.clear(); 

   293 

   294     // mTestObject->handleReceivedIcon(count-1,GlxTBContextPtFs);

   295     // qDebug("Signal Count %d",spysignal.count());

   296     // QVERIFY(spysignal.count() == 1);

   297     // QVERIFY(spysignal.value(0).at(0).toInt() == count-1);

   298     // QVERIFY(const_cast<GlxTBContextType>(spysignal.value(0).at(1)) == GlxTBContextPtFs);

   299 

   300 }

   301 

   302 void TestGlxMLWrapper::testHandleIconCorrupt()

   303 {

   304     QSignalSpy spysignal(mTestObject, SIGNAL(itemCorrupted(int )));

   305     QVERIFY(spysignal.count() == 0);

   306     

   307     int index = mTestObject->getItemCount();

   308     spysignal.clear(); 

   309 

   310     mTestObject->handleIconCorrupt(index-1);

   311     qDebug("Signal Count %d",spysignal.count());

   312     QVERIFY(spysignal.count() == 1);

   313     QVERIFY(spysignal.value(0).at(0).toInt() == index-1);

   314 

   315 }

   316 

   317 void TestGlxMLWrapper::testHandleListItemAvailable()

   318 {

   319     qRegisterMetaType<GlxTBContextType>("GlxTBContextType");

   320     QSignalSpy spysignal(mTestObject, SIGNAL(updateItem(int , GlxTBContextType )));

   321     QVERIFY(spysignal.count() == 0);

   322     

   323     int count = mTestObject->getItemCount();

   324     spysignal.clear(); 

   325 

   326     mTestObject->handleListItemAvailable(count-1);

   327     qDebug("Signal Count %d",spysignal.count());

   328     QVERIFY(spysignal.count() == 1);

   329     QVERIFY(spysignal.value(0).at(0).toInt() == count-1);

   330 }

   331 

   332 void TestGlxMLWrapper::testRetrieveItemDateIsNull()

   333 {

   334     int count = mTestObject->getItemCount();

   335     QDate date = mTestObject->retrieveItemDate(count-1);

   336     qDebug("TestGlxMLWrapper::testRetrieveItemDateIsNull =%d",date.isNull());

   337     QVERIFY( date.isNull() == 1 );

   338 }

   339 

   340 QTEST_MAIN(TestGlxMLWrapper)

   341 #include "moc_unittest_medialistwrapper.cpp"