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:	 tester	for	methods	in VideoListView

    15 *

    16 */

    17 

    18 #include <QtTest/QtTest>

    19 #include <hbapplication.h>

    20 #include <hbinstance.h>

    21 #include <qactiongroup.h>

    22 #include <hbmenu.h>

    23 #include <hbtoolbar.h>

    24 #include <hbaction.h>

    25 #include <videocollectioncommon.h>

    26 #include <hbstackedwidget.h>

    27 #include <hbgroupbox.h>

    28 #include <hbdocumentloader.h>

    29 #include <qhash.h>

    30 #include <qmap.h>

    31 #include <hbview.h>

    32 #include <hblistview.h>

    33 #include <mpxitemid.h>

    34 #include <vcxmyvideosdefs.h>

    35 

    36 #include "videocollectionwrapper.h"

    37 #include "testlistview.h"

    38 #include "videocollectionviewutils.h"

    39 #include "videolistselectiondialog.h"

    40 #include "videosortfilterproxymodel.h"

    41 #include "videocollectionwrapper.h"

    42 #include "videohintwidget.h"

    43 #include "videolistwidgetdata.h"

    44 #include "videocollectionwrapperdata.h"

    45 #include "videocollectionviewutilsdata.h"

    46 #include "videolistselectiondialogdata.h"

    47 #include "videosortfilterproxymodeldata.h"

    48 #include "videocollectionuiloaderdata.h"

    49 #include "videolistdatamodeldata.h"

    50 

    51 #define	private	public

    52 #include "videolistwidget.h"

    53 #include "videocollectionuiloader.h"

    54 #include "videolistview.h"

    55 #undef private

    56 

    57 // ---------------------------------------------------------------------------

    58 // main

    59 // ---------------------------------------------------------------------------

    60 //

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

    62 {

    63 	HbApplication app(argc,	argv);

    64 	HbMainWindow window;

    65 

    66 	TestListView tv;

    67 

    68     int res;

    69     if(argc > 1)

    70     {   

    71         res = QTest::qExec(&tv, argc, argv);

    72     }

    73     else

    74     {

    75     	char *pass[3];

    76     	pass[0]	= argv[0];

    77     	pass[1]	= "-o";

    78     	pass[2]	= "c:\\data\\testlistview.txt";

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

    80     }

    81 

    82 	return res;

    83 }

    84 

    85 // ---------------------------------------------------------------------------

    86 // init

    87 // ---------------------------------------------------------------------------

    88 //

    89 void TestListView::init(bool initTestView)

    90 {

    91 	mUiLoader = new VideoCollectionUiLoader();

    92 	mUiLoader->reset();

    93 

    94 	bool ok(false);

    95 	QList<QObject *> objects = mUiLoader->load(DOCML_VIDEOCOLLECTIONVIEW_FILE, &ok);

    96     if (!ok)

    97     {

    98     	return;

    99     }

   100 

   101     mTestView = mUiLoader->findObject<VideoListView>( DOCML_NAME_VIEW );

   102     QVERIFY(mTestView);

   103     if(initTestView)

   104     {

   105         QVERIFY(mTestView->initializeView() == 0);

   106     }

   107     

   108     mListWidget = mUiLoader->findWidget<VideoListWidget>(DOCML_NAME_VC_VIDEOLISTWIDGET);

   109     QVERIFY(mListWidget);

   110 

   111 	mWrapper = &VideoCollectionWrapper::instance();

   112 	QVERIFY(mWrapper);

   113 }

   114 

   115 // ---------------------------------------------------------------------------

   116 // cleanup

   117 // ---------------------------------------------------------------------------

   118 //

   119 void TestListView::cleanup()

   120 {

   121 	delete mTestView;

   122 	mTestView =	0;

   123 	

   124 	mWrapper = 0;

   125 

   126 	disconnect();

   127 

   128     VideoListWidgetData::reset();

   129     VideoCollectionWrapperData::reset();

   130     VideoCollectionViewUtilsData::reset();

   131     VideoListSelectionDialogData::reset();

   132     VideoSortFilterProxyModelData::reset();

   133 }

   134 

   135 // ---------------------------------------------------------------------------

   136 // visibleMenuActions

   137 // ---------------------------------------------------------------------------

   138 //

   139 int	TestListView::visibleMenuActions()

   140 {

   141 	int	visibleActions(0);

   142 	VideoCollectionUiLoader::ActionIds key;

   143 	HbAction *action(0);

   144 	foreach(key,mUiLoader->mMenuActions.keys())

   145 	{

   146 		action = dynamic_cast<HbAction*>(mUiLoader->mMenuActions[key]);

   147 		if(action && action->isVisible())

   148 			visibleActions++;

   149 	}

   150 	return visibleActions;

   151 }

   152 

   153 // ---------------------------------------------------------------------------

   154 // setRowCount

   155 // ---------------------------------------------------------------------------

   156 //

   157 void TestListView::setRowCount(int count)

   158 {

   159     if (mTestView)

   160     {

   161         if (!mTestView->mCurrentList)

   162         {

   163             mTestView->activateView();

   164         }

   165         VideoSortFilterProxyModel *model = mTestView->mCurrentList->mModel;

   166         if (model)

   167         {

   168             VideoListDataModel *sourceModel =

   169                 qobject_cast<VideoListDataModel*>(

   170                     model->sourceModel());

   171             if (sourceModel)

   172             {

   173                 VideoListDataModelData::setRowCount(*sourceModel, count);

   174             }

   175         }

   176     }

   177 }

   178 

   179 // ---------------------------------------------------------------------------

   180 // testCreateDelete

   181 // ---------------------------------------------------------------------------

   182 //

   183 void TestListView::testCreateDelete()

   184 {

   185     mWrapper = 0;

   186 

   187     mUiLoader = new VideoCollectionUiLoader();

   188 

   189 	mUiLoader->reset();

   190 

   191 	bool ok(false);

   192 

   193 	QList<QObject *> objects = mUiLoader->load(DOCML_VIDEOCOLLECTIONVIEW_FILE, &ok);

   194 

   195     if (!ok)

   196     {

   197     	return;

   198     }

   199 

   200     mTestView = mUiLoader->findObject<VideoListView>( DOCML_NAME_VIEW );

   201 

   202     delete mTestView;

   203 	mTestView =	0;

   204 }

   205 

   206 // ---------------------------------------------------------------------------

   207 // Slot: test initialize view

   208 // ---------------------------------------------------------------------------

   209 //

   210 void TestListView::testInitializeView()

   211 {

   212     VideoListWidget *videoListWidget = 0;

   213     VideoHintWidget *hintWidget = 0;

   214     

   215     init(false);

   216 	// Test	videolist widget creation failure.

   217 	VideoListWidgetData::mInitializeReturnValue	= -1;

   218 	QVERIFY( mTestView->initializeView() < 0 );

   219 	QVERIFY( mTestView->mToolbarViewsActionGroup == 0 );

   220 	QVERIFY( mTestView->mToolbarCollectionActionGroup == 0 );

   221 	QVERIFY( mTestView->mVideoServices == 0 );

   222 	QVERIFY( mTestView->mIsService == false );

   223 

   224 	cleanup();

   225 

   226 	// Test	widget creation	succeed.

   227 	init(false);

   228     VideoCollectionViewUtilsData::mSortRole = Qt::DisplayRole;

   229     VideoCollectionViewUtilsData::mSortOrder = Qt::DescendingOrder;

   230 	QVERIFY( mTestView->initializeView() ==	0 );

   231 	// Verify

   232 	QCOMPARE( VideoListWidgetData::mInitializeCount, 1 );

   233 	QVERIFY( mTestView->mToolbarViewsActionGroup != 0 );

   234 	QVERIFY( mTestView->mToolbarCollectionActionGroup != 0 );

   235 	QCOMPARE( mTestView->mToolbarViewsActionGroup->actions().count(), 3 );

   236 	QCOMPARE( mTestView->mToolbarCollectionActionGroup->actions().count(), 3 );

   237 	QCOMPARE( mTestView->toolBar()->actions().count(), 3 );

   238 	// to my understanding the all videos action should	always be first.

   239 	QVERIFY( mTestView->mToolbarViewsActionGroup->actions().first()->isChecked()	);

   240 	QCOMPARE( VideoSortFilterProxyModelData::mSortRole, (int)Qt::DisplayRole );

   241 	QCOMPARE( VideoSortFilterProxyModelData::mSortOrder, Qt::DescendingOrder );

   242 	QVERIFY( VideoSortFilterProxyModelData::mSortAsync == false );

   243 	QVERIFY( mTestView->mVideoServices == 0 );

   244 	QVERIFY( mTestView->mIsService == false );

   245 	cleanup();

   246 	cleanup();

   247 

   248 	// Test	command	signal.

   249 	init(true);

   250 	videoListWidget = mUiLoader->findWidget<VideoListWidget>(DOCML_NAME_VC_VIDEOLISTWIDGET);

   251     QVERIFY(videoListWidget);

   252 	connect( this, SIGNAL(testSignal(int)),	videoListWidget, SIGNAL(command(int)) );

   253 	QSignalSpy spy(mTestView, SIGNAL(command(int)));

   254 	emit testSignal(5);

   255 	QCOMPARE( spy.count(), 1 );

   256 	QList<QVariant>	arguments =	spy.takeFirst();

   257 	QCOMPARE( arguments.at(0).toInt(), 5 );

   258 	disconnect();

   259 	cleanup();

   260 

   261 	init(true);

   262 	QPointer<QActionGroup> toolbar = mTestView->mToolbarViewsActionGroup;

   263 	QPointer<QActionGroup> toolbar2 = mTestView->mToolbarCollectionActionGroup;

   264 

   265 	// Test	calling	initializeView again.

   266 	QVERIFY( mTestView->initializeView() ==	0 );

   267 

   268 	QVERIFY( toolbar !=	0 );

   269 	QVERIFY( toolbar2 != 0 );

   270 	QVERIFY( mTestView->mToolbarViewsActionGroup == toolbar );

   271 	QVERIFY( mTestView->mToolbarCollectionActionGroup == toolbar2 );

   272 

   273 	// Test	view deletion.

   274 	cleanup();

   275 	QVERIFY( toolbar ==	0 );

   276 	QVERIFY( toolbar2 == 0 );

   277 

   278 	// Test	get	model failure.

   279 	init(false);

   280 	QVERIFY(mTestView);

   281 	VideoCollectionWrapperData::mGetModelFails	= true;

   282 	QVERIFY( mTestView->initializeView() < 0 );

   283 	QVERIFY( mTestView->mToolbarViewsActionGroup	== 0 );

   284 	QVERIFY( mTestView->mToolbarCollectionActionGroup	== 0 );

   285 	cleanup();

   286 

   287 	// Test	model open failure.

   288 	init(false);

   289 	QVERIFY(mTestView);

   290 	VideoSortFilterProxyModelData::mOpenFails =	true;

   291 	QVERIFY( mTestView->initializeView() < 0 );

   292 	QVERIFY( mTestView->mToolbarViewsActionGroup == 0 );

   293 	QVERIFY( mTestView->mToolbarCollectionActionGroup == 0 );

   294 	cleanup();

   295 

   296 	// Test sorting value load 'failure'.

   297 	init(false);

   298     VideoCollectionViewUtilsData::mSortRole = Qt::DisplayRole;

   299     VideoCollectionViewUtilsData::mSortOrder = Qt::DescendingOrder;

   300     VideoCollectionViewUtilsData::mLoadSortingValuesFails = true;

   301     QVERIFY( mTestView->initializeView() == 0 );

   302     QCOMPARE( VideoSortFilterProxyModelData::mSortRole, (int)VideoCollectionCommon::KeyDateTime );

   303     QCOMPARE( VideoSortFilterProxyModelData::mSortOrder, Qt::AscendingOrder );

   304     QVERIFY( VideoSortFilterProxyModelData::mSortAsync == false );

   305     cleanup();

   306 }

   307 

   308 // ---------------------------------------------------------------------------

   309 // Slot: test create menu

   310 // ---------------------------------------------------------------------------

   311 //

   312 void TestListView::testCreateListMenu()

   313 {

   314 	init(false);

   315 	VideoListWidgetData::mInitializeReturnValue	= -1;

   316 	QVERIFY( mTestView->initializeView() < 0 );

   317 	HbMenu*	menu = mUiLoader->findWidget<HbMenu>(DOCML_NAME_OPTIONS_MENU);

   318 	QVERIFY( menu );

   319 	QCOMPARE( menu->actions().count(), 4 );

   320 

   321 	cleanup();

   322 

   323 	init(false);

   324 	VideoListWidgetData::mInitializeReturnValue	= 0;

   325 	QVERIFY( mTestView->initializeView() ==	0 );

   326 	menu = mUiLoader->findWidget<HbMenu>(DOCML_NAME_OPTIONS_MENU);

   327 	QVERIFY( menu );

   328 	QCOMPARE( menu->actions().count(), 4 );

   329 

   330 	HbAction* sortAction = dynamic_cast<HbAction*>(menu->actions().at(3));

   331 	QVERIFY( sortAction	);

   332 	menu = mUiLoader->findWidget<HbMenu>(DOCML_NAME_OPTIONS_MENU);

   333 	QVERIFY(menu !=	0);

   334 	QVERIFY( menu->actions().count() ==	4 );

   335 

   336 	QVERIFY( mUiLoader->mMenuActions.count() ==	9 );

   337 	QVERIFY( mTestView->mSortingRoles.count() == 5 );

   338 

   339 	cleanup();

   340 }

   341 

   342 // ---------------------------------------------------------------------------

   343 // testMenus

   344 // ---------------------------------------------------------------------------

   345 //

   346 void TestListView::testMenus()

   347 {

   348 	init();

   349 

   350 	HbAction* action;

   351 	QList<QAction*> tbActions = mTestView->toolBar()->actions();

   352 	QList<QAction*>	tbGroupActions;

   353 	QList<QAction*>	tbGroupActions2;

   354 

   355 	// All videos is open for default, verify.

   356 	QVERIFY(mTestView->mToolbarViewsActionGroup != 0);

   357 	QVERIFY(mTestView->mToolbarCollectionActionGroup != 0);

   358 	tbGroupActions = mTestView->mToolbarViewsActionGroup->actions();

   359 	tbGroupActions2 = mTestView->mToolbarCollectionActionGroup->actions();

   360 	QVERIFY(mTestView->mToolbarActions.count() == 6);

   361 	QVERIFY(tbActions.count() == 3);

   362 	QVERIFY(tbGroupActions.count() == 3);

   363 	QVERIFY(tbGroupActions2.count() == 3);

   364 	QVERIFY( tbGroupActions.at(0)->isChecked() ); // First is checked.

   365 	// visible menu items remains constant after init until

   366 	// aboutToShowMainMenuSlot is called

   367 	QVERIFY(visibleMenuActions() == 9);

   368 	// Verify checkable	and	visible	toolbar	actions.

   369 	HbAction* allVideosAction =	mTestView->mToolbarActions[VideoListView::ETBActionAllVideos];

   370 	HbAction* collectionsAction	= mTestView->mToolbarActions[VideoListView::ETBActionCollections];

   371 	HbAction* servicesAction = mTestView->mToolbarActions[VideoListView::ETBActionServices];

   372 	HbAction* addVideosAction =	mTestView->mToolbarActions[VideoListView::ETBActionAddVideos];

   373 	HbAction* removeVideosAction = mTestView->mToolbarActions[VideoListView::ETBActionRemoveVideos];

   374 	HbAction* sortVideosAction = mTestView->mToolbarActions[VideoListView::ETBActionSortVideos];

   375 	QVERIFY( allVideosAction !=	0 && allVideosAction->isCheckable()	&& allVideosAction->isVisible() &&

   376 			tbActions.at(0) == tbGroupActions.at(0));

   377 	QVERIFY( collectionsAction != 0	&& collectionsAction->isCheckable()	&& collectionsAction->isVisible() &&

   378 			tbActions.at(1) == tbGroupActions.at(1));

   379 	QVERIFY( servicesAction	!= 0 &&	servicesAction->isCheckable() && servicesAction->isVisible() &&

   380 			tbActions.at(2) == tbGroupActions.at(2));

   381 	QVERIFY( addVideosAction !=	0 && !addVideosAction->isCheckable() &&

   382 			tbActions.at(0) != tbGroupActions2.at(0));

   383 	QVERIFY( removeVideosAction	!= 0 &&	!removeVideosAction->isCheckable() &&

   384 			tbActions.at(1) != tbGroupActions2.at(1));

   385 	QVERIFY( sortVideosAction != 0 && !sortVideosAction->isCheckable() &&

   386 			tbActions.at(2) != tbGroupActions2.at(2));

   387 

   388 	// Open	collections.

   389 	action = dynamic_cast<HbAction*>(tbGroupActions.at(1));

   390 	QVERIFY(action);

   391 	action->setChecked(false);

   392 	action->trigger();

   393 

   394 	// Verify.

   395 	QVERIFY(mTestView->mToolbarViewsActionGroup);

   396 	tbGroupActions = mTestView->mToolbarViewsActionGroup->actions();

   397 	QVERIFY(mTestView->mToolbarActions.count() == 6);

   398 	QVERIFY(tbGroupActions.count() == 3);

   399 	QVERIFY(tbGroupActions2.count() == 3);

   400 	QVERIFY( tbGroupActions.at(1)->isChecked() ); // 2nd is	checked.

   401 	// visible menu items remains constant after init until

   402 	// aboutToShowMainMenuSlot is called

   403 	QVERIFY(visibleMenuActions() ==	9);

   404 	// Verify checkable	and	visible	toolbar	actions.

   405 	allVideosAction	= mTestView->mToolbarActions[VideoListView::ETBActionAllVideos];

   406 	collectionsAction =	mTestView->mToolbarActions[VideoListView::ETBActionCollections];

   407 	servicesAction = mTestView->mToolbarActions[VideoListView::ETBActionServices];

   408 	addVideosAction	= mTestView->mToolbarActions[VideoListView::ETBActionAddVideos];

   409 	removeVideosAction = mTestView->mToolbarActions[VideoListView::ETBActionRemoveVideos];

   410 	sortVideosAction = mTestView->mToolbarActions[VideoListView::ETBActionSortVideos];

   411 	QVERIFY( allVideosAction !=	0 && allVideosAction->isCheckable()	&& allVideosAction->isVisible()	&&

   412 			tbActions.at(0) == tbGroupActions.at(0));

   413 	QVERIFY( collectionsAction != 0	&& collectionsAction->isCheckable()	&& collectionsAction->isVisible() &&

   414 			tbActions.at(1) == tbGroupActions.at(1));

   415 	QVERIFY( servicesAction	!= 0 &&	servicesAction->isCheckable() && servicesAction->isVisible() &&

   416 			tbActions.at(2) == tbGroupActions.at(2));

   417 	QVERIFY( addVideosAction !=	0 && !addVideosAction->isCheckable() &&

   418 			tbActions.at(0) != tbGroupActions2.at(0));

   419 	QVERIFY( removeVideosAction	!= 0 &&	!removeVideosAction->isCheckable() &&

   420 			tbActions.at(1) != tbGroupActions2.at(1));

   421 	QVERIFY( sortVideosAction != 0 && !sortVideosAction->isCheckable() &&

   422 			tbActions.at(2) != tbGroupActions2.at(2));

   423 

   424 	cleanup();

   425 }

   426 

   427 // ---------------------------------------------------------------------------

   428 // Slot: test create toolbar

   429 // ---------------------------------------------------------------------------

   430 //

   431 void TestListView::testCreateAction()

   432 {

   433 	init();

   434 

   435 	QVERIFY(mTestView->mToolbarViewsActionGroup != 0);

   436 

   437 	QList<QAction*>	actions	= mTestView->mToolbarViewsActionGroup->actions();

   438 	actions.append(mTestView->mToolbarCollectionActionGroup->actions());

   439 	QVERIFY(actions.count()	== 6);

   440 

   441 	QCOMPARE( mTestView->toolBar()->actions().count(), 3 );

   442 

   443 	HbAction* allVideos	= static_cast<HbAction*>(actions.at(0));

   444 	QVERIFY( allVideos->isCheckable() );

   445 	QCOMPARE( allVideos->icon().iconName(),	QString(":/images/qtg_mono_video_all.svg")	);

   446 

   447 	HbAction* collections =	static_cast<HbAction*>(actions.at(1));

   448 	QVERIFY( collections->isCheckable()	);

   449 	QCOMPARE( collections->icon().iconName(), QString(":/images/qtg_mono_video_collection.svg") );

   450 

   451 	HbAction* services = static_cast<HbAction*>(actions.at(2));

   452 	QVERIFY( services->isCheckable() );

   453 	QCOMPARE( services->icon().iconName(), QString(":/images/qtg_mono_video_services.svg") );

   454 

   455 	HbAction* addVideos	= static_cast<HbAction*>(actions.at(3));

   456 	QVERIFY( !addVideos->isCheckable() );

   457 	QCOMPARE( addVideos->icon().iconName(),	QString(":/images/mono_video_addvideos.svg") );

   458 

   459 	HbAction* removeVideos = static_cast<HbAction*>(actions.at(4));

   460 	QVERIFY( !removeVideos->isCheckable() );

   461 	QCOMPARE( removeVideos->icon().iconName(), QString(":/images/mono_video_removevideos.svg") );

   462 

   463 	HbAction* sortVideos = static_cast<HbAction*>(actions.at(5));

   464 	QVERIFY( !sortVideos->isCheckable()	);

   465 	QCOMPARE( sortVideos->icon().iconName(), QString(":/images/mono_video_sortvideos.svg") );

   466 

   467 	cleanup();

   468 }

   469 

   470 // ---------------------------------------------------------------------------

   471 // Slot: test activate view

   472 // ---------------------------------------------------------------------------

   473 //

   474 void TestListView::testActivateView()

   475 {

   476     VideoListWidget* videoListWidget = 0;

   477     

   478 	init();

   479 

   480 	videoListWidget = mUiLoader->findWidget<VideoListWidget>(DOCML_NAME_VC_VIDEOLISTWIDGET);

   481 	QVERIFY(videoListWidget);

   482 	mTestView->mCurrentList = 0;

   483 

   484 	QCOMPARE( mTestView->activateView(), -1	);

   485     QVERIFY( VideoListWidgetData::mActive == false );

   486     QCOMPARE( mTestView->mCurrentList, videoListWidget );

   487     QCOMPARE( VideoListWidgetData::mActivateCount, 0 );

   488 	QCOMPARE( VideoListWidgetData::mDeactivateCount, 0 );

   489 	QVERIFY( mUiLoader->findWidget<HbMenu>(DOCML_NAME_OPTIONS_MENU)->isEnabled() == false );

   490 	

   491 	VideoListWidgetData::mActivateReturnValue =	-1;

   492 

   493 	QCOMPARE( mTestView->activateView(), -1	);

   494 	QVERIFY( VideoListWidgetData::mActive == false );

   495 	QCOMPARE( VideoListWidgetData::mActivateCount, 1 );

   496 	QCOMPARE( VideoListWidgetData::mDeactivateCount, 1 );

   497 	QVERIFY( mUiLoader->findWidget<HbMenu>(DOCML_NAME_OPTIONS_MENU)->isEnabled() == false );

   498 

   499 	VideoListWidgetData::mActivateReturnValue =	0;

   500 	

   501 	QCOMPARE( mTestView->activateView(), 0 );

   502 	QVERIFY( VideoListWidgetData::mActive );

   503 	QCOMPARE( VideoListWidgetData::mActivateCount, 2 );

   504 	QCOMPARE( VideoListWidgetData::mDeactivateCount, 1 );

   505 	QVERIFY( mUiLoader->findWidget<HbMenu>(DOCML_NAME_OPTIONS_MENU)->isEnabled() );

   506 

   507 	QCOMPARE( mTestView->activateView(), 0 );

   508 	QVERIFY( VideoListWidgetData::mActive );

   509 	QCOMPARE( VideoListWidgetData::mActivateCount, 3 );

   510 	QCOMPARE( VideoListWidgetData::mDeactivateCount, 1 );

   511 	QVERIFY( mUiLoader->findWidget<HbMenu>(DOCML_NAME_OPTIONS_MENU)->isEnabled() );

   512 

   513 	cleanup();

   514 }

   515 

   516 // ---------------------------------------------------------------------------

   517 // Slot: test deactivate view

   518 // ---------------------------------------------------------------------------

   519 //

   520 void TestListView::testDeactivateView()

   521 {

   522     VideoListWidget* videoListWidget = 0;

   523 

   524     init();

   525 

   526     videoListWidget = mUiLoader->findWidget<VideoListWidget>(DOCML_NAME_VC_VIDEOLISTWIDGET);

   527     QVERIFY(videoListWidget);

   528     mTestView->mCurrentList = 0;

   529 

   530 	mTestView->deactivateView();

   531 	QVERIFY( mUiLoader->findWidget<HbMenu>(DOCML_NAME_OPTIONS_MENU)->isVisible() == false );

   532 	QVERIFY( mUiLoader->findWidget<HbMenu>(DOCML_NAME_OPTIONS_MENU)->isEnabled() == false );

   533 	QCOMPARE( VideoListWidgetData::mDeactivateCount, 0 );

   534 

   535 	mTestView->deactivateView();

   536 	QVERIFY( mUiLoader->findWidget<HbMenu>(DOCML_NAME_OPTIONS_MENU)->isVisible() == false );

   537 	QVERIFY( mUiLoader->findWidget<HbMenu>(DOCML_NAME_OPTIONS_MENU)->isEnabled() == false );

   538 	QCOMPARE( VideoListWidgetData::mDeactivateCount, 1 );

   539 

   540 	VideoListWidgetData::mActivateReturnValue =	0;

   541 	mTestView->activateView();

   542 	mTestView->deactivateView();

   543 	QVERIFY( mUiLoader->findWidget<HbMenu>(DOCML_NAME_OPTIONS_MENU)->isVisible() == false );

   544 	QVERIFY( mUiLoader->findWidget<HbMenu>(DOCML_NAME_OPTIONS_MENU)->isEnabled() == false );

   545 	QCOMPARE( VideoListWidgetData::mActivateCount, 1 );

   546 	QCOMPARE( VideoListWidgetData::mDeactivateCount, 2 );

   547 

   548 	cleanup();

   549 }

   550 

   551 // ---------------------------------------------------------------------------

   552 // testBack

   553 // ---------------------------------------------------------------------------

   554 //

   555 void TestListView::testBack()

   556 {

   557 	init();

   558 

   559 	mTestView->back();

   560 

   561 	cleanup();

   562 }

   563 

   564 // ---------------------------------------------------------------------------

   565 // Slot: test open all videos slot

   566 // ---------------------------------------------------------------------------

   567 //

   568 void TestListView::testOpenAllVideosViewSlot()

   569 {

   570     VideoListWidget *videoListWidget = 0;

   571     HbGroupBox *subLabel = 0;

   572     

   573 	init();

   574 	

   575     videoListWidget = mUiLoader->findWidget<VideoListWidget>(DOCML_NAME_VC_VIDEOLISTWIDGET);

   576     QVERIFY(videoListWidget);

   577     subLabel = mUiLoader->findWidget<HbGroupBox>(DOCML_NAME_VC_HEADINGBANNER);

   578     QVERIFY(subLabel);

   579 

   580 	QList<QAction*>	actions	= mTestView->mToolbarViewsActionGroup->actions();

   581 	HbAction* action = static_cast<HbAction*>(actions.at(0));

   582 	

   583 	videoListWidget->mCurrentLevel = VideoCollectionCommon::ELevelCategory;

   584 	subLabel->setHeading("invalid");

   585 	

   586 	// action wont emit	if it's	already	checked.

   587 	action->setChecked(false);

   588 	action->trigger();

   589 	QCOMPARE( mTestView->mCurrentList->mCurrentLevel, VideoCollectionCommon::ELevelVideos );

   590     QVERIFY( VideoListWidgetData::mActive == true );

   591     QCOMPARE( VideoListWidgetData::mActivateCount, 1 );

   592     QCOMPARE( VideoListWidgetData::mDeactivateCount, 0 );

   593     QCOMPARE( subLabel->heading(), tr("txt_videos_subtitle_ln_videos" ));

   594 	QCOMPARE(mTestView->mCurrentList, videoListWidget);

   595 

   596 	mTestView->activateView();

   597 	

   598 	VideoListWidgetData::mActivateCount = 0;

   599 	mTestView->mCurrentList->mCurrentLevel = VideoCollectionCommon::ELevelCategory;

   600     subLabel->setHeading("invalid");

   601     

   602     // action wont emit	if it's	already	checked.

   603 	action->setChecked(false);

   604 	action->trigger();

   605     QCOMPARE( mTestView->mCurrentList->mCurrentLevel, VideoCollectionCommon::ELevelVideos );

   606     QVERIFY( VideoListWidgetData::mActive == true );

   607 	QCOMPARE( VideoListWidgetData::mActivateCount, 1 );

   608 	QCOMPARE( VideoListWidgetData::mDeactivateCount, 0 );

   609     QCOMPARE( subLabel->heading(), tr("txt_videos_subtitle_ln_videos" ));

   610     QCOMPARE(mTestView->mCurrentList, videoListWidget);

   611 

   612 	cleanup();

   613 }

   614 

   615 // ---------------------------------------------------------------------------

   616 // Slot: test open collections view	slot

   617 // ---------------------------------------------------------------------------

   618 //

   619 void TestListView::testOpenCollectionViewSlot()

   620 {

   621     VideoListWidget *collectionWidget = 0;

   622     HbGroupBox *subLabel = 0;

   623 

   624     init();

   625 

   626 	QList<QAction*>	actions	= mTestView->mToolbarViewsActionGroup->actions();

   627 	HbAction* action = static_cast<HbAction*>(actions.at(1));

   628 

   629 	collectionWidget = mUiLoader->findWidget<VideoListWidget>(DOCML_NAME_VC_COLLECTIONWIDGET);

   630     QVERIFY(collectionWidget);

   631     subLabel = mUiLoader->findWidget<HbGroupBox>(DOCML_NAME_VC_HEADINGBANNER);

   632     QVERIFY(subLabel);

   633 

   634 	mTestView->mCurrentList->mCurrentLevel = VideoCollectionCommon::ELevelVideos;

   635     subLabel->setHeading("invalid");

   636 

   637 	// action wont emit	if it's	already	checked.

   638 	action->setChecked(false);

   639 	action->trigger();

   640     QCOMPARE( mTestView->mCurrentList->mCurrentLevel, VideoCollectionCommon::ELevelCategory );

   641     QVERIFY( VideoListWidgetData::mActive == true );

   642     QCOMPARE( VideoListWidgetData::mActivateCount, 1 );

   643     QCOMPARE( VideoListWidgetData::mDeactivateCount, 0 );

   644     QCOMPARE( subLabel->heading(), tr("txt_videos_subtitle_l1_collections" ));

   645     QCOMPARE(mTestView->mCurrentList, collectionWidget);

   646 

   647 	mTestView->activateView();

   648 

   649     VideoListWidgetData::mActivateCount = 0;

   650     mTestView->mCurrentList->mCurrentLevel = VideoCollectionCommon::ELevelVideos;

   651     subLabel->setHeading("invalid");

   652     

   653     // action wont emit	if it's	already	checked.

   654 	action->setChecked(false);

   655 	action->trigger();

   656     QCOMPARE( mTestView->mCurrentList->mCurrentLevel, VideoCollectionCommon::ELevelCategory );

   657     QVERIFY( VideoListWidgetData::mActive == true );

   658     QCOMPARE( VideoListWidgetData::mActivateCount, 1 );

   659     QCOMPARE( VideoListWidgetData::mDeactivateCount, 0 );

   660     QCOMPARE( subLabel->heading(), tr("txt_videos_subtitle_l1_collections" ));

   661     QCOMPARE(mTestView->mCurrentList, collectionWidget);

   662 

   663 	cleanup();

   664 }

   665 // ---------------------------------------------------------------------------

   666 // Slot: test open services	view slot

   667 // ---------------------------------------------------------------------------

   668 //

   669 void TestListView::testOpenServicesViewSlot()

   670 {

   671 	init();

   672 

   673 	QList<QAction*>	actions	= mTestView->mToolbarViewsActionGroup->actions();

   674 	HbAction* action = static_cast<HbAction*>(actions.at(2));

   675 

   676 	// action wont emit	if it's	already	checked.

   677 	action->setChecked(false);

   678 	action->trigger();

   679 	

   680 	cleanup();

   681 }

   682 

   683 // ---------------------------------------------------------------------------

   684 // testStartSorting

   685 // ---------------------------------------------------------------------------

   686 //

   687 void TestListView::testStartSortingSlot()

   688 {

   689 	HbAction *action(0);

   690 

   691 	// Active action is	not	sort by.

   692 	init(true);

   693 	action = mUiLoader->mMenuActions[VideoCollectionUiLoader::EActionDelete];

   694 	QVERIFY(action != 0);

   695 	mUiLoader->findWidget<HbMenu>(DOCML_NAME_OPTIONS_MENU)->setActiveAction(action);

   696 	connect(this, SIGNAL(testSignal(int)), mTestView, SLOT(startSorting()));

   697 	emit testSignal(0);

   698 	QCOMPARE(VideoSortFilterProxyModelData::mDoSortingCallCount, 0);

   699 	QCOMPARE(VideoSortFilterProxyModelData::mSortRole, -1);

   700 	cleanup();

   701 

   702 	// Sort	by action has no menu.

   703 	init(true);

   704 

   705 	// Change sort by action to	delete action which	has	no menu.

   706 	HbAction *sortByAction = mUiLoader->mMenuActions[VideoCollectionUiLoader::EActionSortBy];

   707 	HbAction *deleteAction = mUiLoader->mMenuActions[VideoCollectionUiLoader::EActionDelete];

   708 	mUiLoader->mMenuActions[VideoCollectionUiLoader::EActionSortBy] =	deleteAction;

   709 	mUiLoader->findWidget<HbMenu>(DOCML_NAME_OPTIONS_MENU)->setActiveAction(deleteAction);

   710 

   711 	connect(this, SIGNAL(testSignal(int)), mTestView, SLOT(startSorting()));

   712 	emit testSignal(0);

   713     QCOMPARE(VideoSortFilterProxyModelData::mDoSortingCallCount, 0);

   714     QCOMPARE(VideoSortFilterProxyModelData::mSortRole, -1);

   715 

   716 	// Change the action back.

   717 	mUiLoader->mMenuActions[VideoCollectionUiLoader::EActionSortBy] =	sortByAction;

   718 

   719 	cleanup();

   720 

   721 	// View	is not initialized.

   722 	init(false);

   723 	connect(this, SIGNAL(testSignal(int)), mTestView, SLOT(startSorting()));

   724 	emit testSignal(0);

   725     QCOMPARE(VideoSortFilterProxyModelData::mDoSortingCallCount, 0);

   726     QCOMPARE(VideoSortFilterProxyModelData::mSortRole, -1);

   727 	cleanup();

   728 

   729 	// Good	case.

   730 	init();

   731 	action = mUiLoader->mMenuActions[VideoCollectionUiLoader::EActionSortBy];

   732 	QVERIFY(action != 0);

   733 	mUiLoader->findWidget<HbMenu>(DOCML_NAME_OPTIONS_MENU)->setActiveAction(action);

   734 	HbAction* sortAction = mUiLoader->mMenuActions[VideoCollectionUiLoader::EActionSortByName];

   735 	QVERIFY(sortAction != 0);

   736 	action->menu()->setActiveAction(sortAction);

   737 

   738 	connect(this, SIGNAL(testSignal(int)), mTestView, SLOT(startSorting()));

   739 	emit testSignal(0);

   740 	QCOMPARE(VideoSortFilterProxyModelData::mDoSortingCallCount, 1);

   741 	QCOMPARE(VideoSortFilterProxyModelData::mSortRole, (int)Qt::DisplayRole);

   742 	QCOMPARE(VideoSortFilterProxyModelData::mSortOrder, Qt::AscendingOrder);

   743     QVERIFY(VideoSortFilterProxyModelData::mSortAsync);

   744 

   745     // emit test signal again, with same parameters. Sorting should be switched to

   746     // descending order.

   747     emit testSignal(0);

   748     QCOMPARE(VideoSortFilterProxyModelData::mDoSortingCallCount, 2);

   749     QCOMPARE(VideoSortFilterProxyModelData::mSortRole, (int)Qt::DisplayRole);

   750     QCOMPARE(VideoSortFilterProxyModelData::mSortOrder, Qt::DescendingOrder);

   751     QVERIFY(VideoSortFilterProxyModelData::mSortAsync);

   752 

   753     // on third emit, sorting should be switched back to ascending

   754     emit testSignal(0);

   755     QCOMPARE(VideoSortFilterProxyModelData::mDoSortingCallCount, 3);

   756     QCOMPARE(VideoSortFilterProxyModelData::mSortRole, (int)Qt::DisplayRole);

   757     QCOMPARE(VideoSortFilterProxyModelData::mSortOrder, Qt::AscendingOrder);

   758     QVERIFY(VideoSortFilterProxyModelData::mSortAsync);

   759 

   760     // test that after changing the sort role, the order is also switched to ascending.

   761     VideoSortFilterProxyModelData::mSortOrder = Qt::DescendingOrder;

   762     sortAction = mUiLoader->mMenuActions[VideoCollectionUiLoader::EActionSortByDate];

   763     QVERIFY(sortAction != 0);

   764     action->menu()->setActiveAction(sortAction);

   765 

   766     emit testSignal(0);

   767     QCOMPARE(VideoSortFilterProxyModelData::mDoSortingCallCount, 4);

   768     QCOMPARE(VideoSortFilterProxyModelData::mSortRole, (int)VideoCollectionCommon::KeyDateTime);

   769     QCOMPARE(VideoSortFilterProxyModelData::mSortOrder, Qt::AscendingOrder);

   770     QVERIFY(VideoSortFilterProxyModelData::mSortAsync);

   771 

   772 	cleanup();

   773 }

   774 

   775 // ---------------------------------------------------------------------------

   776 // Slot: test orientation related slots

   777 // ---------------------------------------------------------------------------

   778 //

   779 void TestListView::testOrientationSlots()

   780 {

   781 	init();

   782 

   783     HbMainWindow *mainWnd = hbInstance->allMainWindows().value(0);

   784 	mainWnd->addView(mTestView);

   785 	mainWnd->setOrientation(Qt::Horizontal);

   786 	mainWnd->setOrientation(Qt::Vertical);

   787 	

   788 	cleanup();

   789 }

   790 

   791 // ---------------------------------------------------------------------------

   792 // testModelReadySlot

   793 // ---------------------------------------------------------------------------

   794 //

   795 void TestListView::testModelReadySlot()

   796 {

   797     init();

   798     mTestView->mModelReady = false;

   799     connect( this, SIGNAL(testSignal()), mTestView, SLOT(modelReadySlot()) );

   800     emit testSignal();

   801     QVERIFY(mTestView->mModelReady);

   802     cleanup();

   803 }

   804 

   805 // ---------------------------------------------------------------------------

   806 // testDeleteItemsSlot

   807 // ---------------------------------------------------------------------------

   808 //

   809 void TestListView::testDeleteItemsSlot()

   810 {

   811     init();

   812     connect( this, SIGNAL(testSignal()), mTestView, SLOT(deleteItemsSlot()) );

   813     ////////////

   814     // no model

   815     ////////////

   816     emit testSignal();

   817     QVERIFY(VideoListSelectionDialogData::mMultiSelectionLaunchCount == 0);

   818     QVERIFY(VideoListSelectionDialogData::mMultiSelectionItemSelectionCount == 0);

   819 

   820     cleanup();

   821     init();

   822     connect( this, SIGNAL(testSignal()), mTestView, SLOT(deleteItemsSlot()) );

   823 

   824     ////////////

   825     // no selection dialog

   826     ////////////

   827     emit testSignal();

   828     QVERIFY(VideoListSelectionDialogData::mMultiSelectionLaunchCount == 1);

   829     QVERIFY(VideoListSelectionDialogData::mMultiSelectionItemSelectionCount == 0);

   830 

   831     cleanup();

   832     init();

   833     connect( this, SIGNAL(testSignal()), mTestView, SLOT(deleteItemsSlot()) );

   834 

   835     ////////////

   836     // dialog loading fails

   837     ////////////

   838     VideoCollectionUiLoaderData::mFailDialogLoad = true;

   839     emit testSignal();

   840     QVERIFY(VideoListSelectionDialogData::mMultiSelectionLaunchCount == 0);

   841     QVERIFY(VideoListSelectionDialogData::mMultiSelectionItemSelectionCount == 0);

   842     VideoCollectionUiLoaderData::mFailDialogLoad = false;

   843     //////////

   844     // document loader deletes all objects in case of error, so we cannot cleanup all

   845     disconnect();

   846     ///////////////

   847     init();

   848     connect( this, SIGNAL(testSignal()), mTestView, SLOT(deleteItemsSlot()) );

   849 

   850     ////////////

   851     // selection dialog exists

   852     ////////////

   853     emit testSignal();

   854     QVERIFY(VideoListSelectionDialogData::mMultiSelectionLaunchCount == 1);

   855     QVERIFY(VideoListSelectionDialogData::mMultiSelectionItemSelectionCount == 0);

   856     emit testSignal();

   857     QVERIFY(VideoListSelectionDialogData::mMultiSelectionLaunchCount == 2);

   858     QVERIFY(VideoListSelectionDialogData::mMultiSelectionItemSelectionCount == 0);

   859 

   860     cleanup();

   861     init();

   862     connect( this, SIGNAL(testSignal()), mTestView, SLOT(deleteItemsSlot()) );

   863 

   864     ////////////

   865     // exec returns primary key (just for the coverity's sake)

   866     ////////////

   867     VideoListSelectionDialogData::mExecReturnPrimary = true;

   868     VideoListSelectionDialogData::mSelectionCount = 5;

   869     emit testSignal();

   870     QVERIFY(VideoListSelectionDialogData::mMultiSelectionLaunchCount == 1);

   871     QVERIFY(VideoListSelectionDialogData::mMultiSelectionItemSelectionCount == 5);

   872 

   873     cleanup();

   874 }

   875 

   876 // ---------------------------------------------------------------------------

   877 // testAboutToShowMainMenuSlot

   878 // ---------------------------------------------------------------------------

   879 //

   880 void TestListView::testAboutToShowMainMenuSlot()

   881 {

   882 	// All ok.

   883 	init();

   884 	setRowCount(1);

   885 	mUiLoader->findWidget<HbMenu>(DOCML_NAME_OPTIONS_MENU)->show();

   886 	QVERIFY(visibleMenuActions() ==	6);

   887 	cleanup();

   888 

   889 	// View	is not initialized.

   890 	init(false);

   891 	connect( this, SIGNAL(testSignal(int)),	mTestView, SLOT(aboutToShowMainMenuSlot()) );

   892 	emit testSignal(0);

   893 	cleanup();

   894 

   895 	HbAction *action(0);

   896 

   897 	// Collections is triggered	from toolbar.

   898 	init();

   899 	setRowCount(1);

   900 	action = mTestView->mToolbarActions[VideoListView::ETBActionCollections];

   901 	QVERIFY(action != 0);

   902 	action->setChecked(false);

   903 	action->trigger();

   904 	mUiLoader->findWidget<HbMenu>(DOCML_NAME_OPTIONS_MENU)->show();

   905 	int visible = visibleMenuActions();

   906 	QCOMPARE(visible,	5);

   907 	cleanup();

   908 

   909 	// All videos is triggered from	toolbar.

   910 	init();

   911     setRowCount(1);

   912 	action = mTestView->mToolbarActions[VideoListView::ETBActionAllVideos];

   913 	QVERIFY(action != 0);

   914 	action->setChecked(false);

   915 	action->trigger();

   916 	mUiLoader->findWidget<HbMenu>(DOCML_NAME_OPTIONS_MENU)->show();

   917 	visible = visibleMenuActions();

   918 	QCOMPARE(visible,	6);

   919 	cleanup();

   920 

   921 	// Services	is triggered from toolbar.

   922 	init();

   923 	setRowCount(1);

   924 	action = mTestView->mToolbarActions[VideoListView::ETBActionServices];

   925 	QVERIFY(action != 0);

   926 	action->setChecked(false);

   927 	action->trigger();

   928 	mUiLoader->findWidget<HbMenu>(DOCML_NAME_OPTIONS_MENU)->show();

   929 	visible = visibleMenuActions();

   930 	QCOMPARE(visible,	0);

   931 	cleanup();

   932 

   933 	// Add videos action is	visible.

   934 	init();

   935     mTestView->activateView();

   936 	mTestView->toolBar()->clearActions();

   937 	mTestView->toolBar()->addActions( mTestView->mToolbarCollectionActionGroup->actions() );

   938 	setRowCount(1);

   939 	QVERIFY(action != 0);

   940 	mUiLoader->findWidget<HbMenu>(DOCML_NAME_OPTIONS_MENU)->show();

   941 	visible = visibleMenuActions();

   942 	QCOMPARE(visible,	1);

   943 	cleanup();

   944 

   945 	// Menu	action is null

   946 	init();

   947     setRowCount(1);

   948 	action = mUiLoader->mMenuActions.take(VideoCollectionUiLoader::EActionSortBy);

   949 	delete action;

   950 	action = NULL;

   951 	mUiLoader->mMenuActions[VideoCollectionUiLoader::EActionSortBy] =	action;

   952 	mUiLoader->findWidget<HbMenu>(DOCML_NAME_OPTIONS_MENU)->show();

   953 	visible = visibleMenuActions();

   954 	QCOMPARE(visible,	0);

   955 	cleanup();

   956 

   957 	// No menu actions.

   958 	init();

   959 	setRowCount(1);

   960 	QMap<VideoCollectionUiLoader::ActionIds, HbAction*> backupActions =

   961 		QMap<VideoCollectionUiLoader::ActionIds, HbAction*>(mUiLoader->mMenuActions);

   962 	mUiLoader->mMenuActions.clear();

   963 	mUiLoader->findWidget<HbMenu>(DOCML_NAME_OPTIONS_MENU)->show();

   964 	mUiLoader->mMenuActions.unite(backupActions);

   965 	cleanup();

   966 

   967 	// Model has no	items.

   968 	init();

   969 	setRowCount(0);

   970 	mUiLoader->findWidget<HbMenu>(DOCML_NAME_OPTIONS_MENU)->show();

   971 	visible = visibleMenuActions();

   972 	QCOMPARE(visible,	0);

   973 	cleanup();

   974 

   975 	// Toolbar action group	is null

   976 	init();

   977 	setRowCount(1);

   978 	QActionGroup* actionGroup =	mTestView->mToolbarViewsActionGroup;

   979 	mTestView->mToolbarViewsActionGroup = NULL;

   980 	mUiLoader->findWidget<HbMenu>(DOCML_NAME_OPTIONS_MENU)->show();

   981 	mTestView->mToolbarViewsActionGroup = actionGroup;

   982 	cleanup();

   983 }

   984 

   985 // ---------------------------------------------------------------------------

   986 // testOpenSortByMenuSlot

   987 // ---------------------------------------------------------------------------

   988 //

   989 void TestListView::testOpenSortByMenuSlot()

   990 {

   991     HbMenu *optionsMenu = 0;

   992     HbMenu *sortMenu = 0;

   993 

   994     // All ok.

   995     init();

   996     sortMenu = mUiLoader->findWidget<HbMenu>(DOCML_NAME_SORT_MENU);

   997     connect( this, SIGNAL(testSignal(int)), mTestView, SLOT(openSortByMenuSlot()) );

   998     setRowCount(1);

   999     mUiLoader->findWidget<HbMenu>(DOCML_NAME_OPTIONS_MENU)->hide();

  1000     emit testSignal(0);

  1001     // sorting menu should be visible

  1002     QVERIFY(visibleMenuActions() == 4);

  1003     cleanup();

  1004 

  1005     // View is not initialized.

  1006     init(false);

  1007     sortMenu = mUiLoader->findWidget<HbMenu>(DOCML_NAME_SORT_MENU);

  1008     optionsMenu = mUiLoader->findWidget<HbMenu>(DOCML_NAME_OPTIONS_MENU);

  1009     connect( this, SIGNAL(testSignal(int)), mTestView, SLOT(openSortByMenuSlot()) );

  1010     setRowCount(1);

  1011     optionsMenu->hide();

  1012     emit testSignal(0);

  1013     QCOMPARE(visibleMenuActions(),   0);

  1014     cleanup();

  1015 

  1016     // no items

  1017     init();

  1018     sortMenu = mUiLoader->findWidget<HbMenu>(DOCML_NAME_SORT_MENU);

  1019     optionsMenu = mUiLoader->findWidget<HbMenu>(DOCML_NAME_OPTIONS_MENU);

  1020     connect( this, SIGNAL(testSignal(int)), mTestView, SLOT(openSortByMenuSlot()) );

  1021     setRowCount(0);

  1022     mUiLoader->findWidget<HbMenu>(DOCML_NAME_OPTIONS_MENU)->hide();

  1023     emit testSignal(0);

  1024     QCOMPARE(visibleMenuActions(),   0);

  1025     cleanup();

  1026 }

  1027 

  1028 // ---------------------------------------------------------------------------

  1029 // testHandleErrorSlot

  1030 // ---------------------------------------------------------------------------

  1031 //

  1032 void TestListView::testHandleStatusSlot()

  1033 {

  1034 	QVariant *variant =	new	QVariant();

  1035 

  1036 	// Unknown error code.

  1037 	init();

  1038 	connect(this, SIGNAL(testStatusSignal(int, QVariant&)), mTestView, SLOT(handleAsyncStatusSlot(int, QVariant&)));

  1039 	emit testStatusSignal(0, *variant);

  1040 	QVERIFY(VideoCollectionViewUtilsData::mLastError ==	0);

  1041 	cleanup();

  1042 

  1043 	// Multiple	deletion error.

  1044 	init();

  1045 	connect(this, SIGNAL(testStatusSignal(int, QVariant&)), mTestView, SLOT(handleAsyncStatusSlot(int, QVariant&)));

  1046 	emit testStatusSignal(VideoCollectionCommon::statusMultipleDeleteFail, *variant);

  1047 	QVERIFY(VideoCollectionViewUtilsData::mLastError ==	VideoCollectionCommon::statusMultipleDeleteFail);

  1048 	cleanup();

  1049 

  1050 	// Deletion	error.

  1051 	init();

  1052 	connect(this, SIGNAL(testStatusSignal(int, QVariant&)), mTestView, SLOT(handleAsyncStatusSlot(int, QVariant&)));

  1053 	emit testStatusSignal(VideoCollectionCommon::statusSingleDeleteFail, *variant);

  1054 	QVERIFY(VideoCollectionViewUtilsData::mLastError ==	VideoCollectionCommon::statusSingleDeleteFail);

  1055 	cleanup();

  1056 

  1057 	// status multidelete succeed

  1058     init();

  1059     connect(this, SIGNAL(testStatusSignal(int, QVariant&)), mTestView, SLOT(handleAsyncStatusSlot(int, QVariant&)));

  1060     emit testStatusSignal(VideoCollectionCommon::statusDeleteSucceed, *variant);

  1061     QVERIFY(VideoCollectionViewUtilsData::mLastError == VideoCollectionCommon::statusDeleteSucceed);

  1062     cleanup();

  1063 

  1064 	// No model.

  1065 	init(false);

  1066 	connect(this, SIGNAL(testStatusSignal(int, QVariant&)), mTestView, SLOT(handleAsyncStatusSlot(int, QVariant&)));

  1067 	emit testStatusSignal(1,	*variant);

  1068 	QVERIFY(VideoCollectionViewUtilsData::mLastError ==	1);

  1069 	cleanup();

  1070 

  1071 	delete variant;

  1072 }

  1073 

  1074 // ---------------------------------------------------------------------------

  1075 // testCollectionOpenedSlot

  1076 // ---------------------------------------------------------------------------

  1077 //

  1078 void TestListView::testCollectionOpenedSlot()

  1079 {

  1080 	HbAction* removeVideosAction;

  1081 	HbAction* allVideosAction;

  1082 	HbAction* collectionsAction;

  1083 	HbAction* servicesAction;

  1084 	HbAction* addVideosAction;

  1085 	HbAction* sortVideosAction;

  1086 

  1087 	QString testString;

  1088 

  1089 	// View	is not initialized.

  1090 	init(false);

  1091 	connect(this, SIGNAL(testCollectionOpenedSignal(bool, const QString&)),	mTestView, SLOT(collectionOpenedSlot(bool, const QString&)));

  1092 	emit testCollectionOpenedSignal(false, testString);

  1093 	cleanup();

  1094 

  1095 	// No toolbar actions.

  1096 	init(true);

  1097 	// Clear actions.

  1098 	QMap<VideoListView::TViewActionIds,	HbAction*> backupActions =

  1099 		QMap<VideoListView::TViewActionIds,	HbAction*>(mTestView->mToolbarActions);

  1100 	mTestView->mToolbarActions.clear();

  1101 	connect(this, SIGNAL(testCollectionOpenedSignal(bool, const QString&)),	mTestView, SLOT(collectionOpenedSlot(bool, const QString&)));

  1102 	emit testCollectionOpenedSignal(true, testString);

  1103 	mTestView->mToolbarActions.unite(backupActions);

  1104 	cleanup();

  1105 

  1106 	// One of the toolbar actions is null.

  1107 	init();

  1108 	removeVideosAction = mTestView->mToolbarActions[VideoListView::ETBActionRemoveVideos];

  1109 	mTestView->mToolbarActions[VideoListView::ETBActionRemoveVideos] = NULL;

  1110 	connect(this, SIGNAL(testCollectionOpenedSignal(bool, const QString&)),	mTestView, SLOT(collectionOpenedSlot(bool, const QString&)));

  1111 	emit testCollectionOpenedSignal(true, testString);

  1112 	// Verify checkable	and	visible	toolbar	actions.

  1113 	mTestView->mToolbarActions[VideoListView::ETBActionRemoveVideos] = removeVideosAction;

  1114 	allVideosAction	= mTestView->mToolbarActions[VideoListView::ETBActionAllVideos];

  1115 	collectionsAction =	mTestView->mToolbarActions[VideoListView::ETBActionCollections];

  1116 	servicesAction = mTestView->mToolbarActions[VideoListView::ETBActionServices];

  1117 	addVideosAction	= mTestView->mToolbarActions[VideoListView::ETBActionAddVideos];

  1118 	sortVideosAction = mTestView->mToolbarActions[VideoListView::ETBActionSortVideos];

  1119 	// Remove videos is	not	checked	because	it was used	as null	action.

  1120 	QCOMPARE( mTestView->mCollectionName, testString );

  1121 	QCOMPARE( mTestView->toolBar()->actions().count(), 3 );

  1122 	QVERIFY( allVideosAction !=	0 && allVideosAction->isCheckable());

  1123 	QVERIFY( collectionsAction != 0	&& collectionsAction->isCheckable());

  1124 	QVERIFY( servicesAction	!= 0 &&	servicesAction->isCheckable());

  1125 	QVERIFY( addVideosAction !=	0 && !addVideosAction->isCheckable() );

  1126 	QVERIFY( sortVideosAction != 0 && !sortVideosAction->isCheckable() );

  1127 	cleanup();

  1128 

  1129 

  1130 	testString = "Test text string";

  1131 

  1132 	// Collection opened.

  1133 	init();

  1134 	connect(this, SIGNAL(testCollectionOpenedSignal(bool, const QString&)),	mTestView, SLOT(collectionOpenedSlot(bool, const QString&)));