videocollection/videocollectionview/tsrc/testlistview/src/testlistview.cpp
changeset 36 8aed59de29f9
parent 34 bbb98528c666
child 37 4eb2df7f7cbe
equal deleted inserted replaced
35:3738fe97f027 36:8aed59de29f9
    13 *
    13 *
    14 * Description:	 tester	for	methods	in VideoListView
    14 * Description:	 tester	for	methods	in VideoListView
    15 *
    15 *
    16 */
    16 */
    17 
    17 
       
    18 // Version : %version: 36 %
       
    19 
       
    20 #define private public
       
    21 #include "videoservices.h"
       
    22 #include "videosortfilterproxymodel.h"
       
    23 #include "videolistwidget.h"
       
    24 #include "videolistview.h"
       
    25 #undef private
       
    26 
       
    27 #include <qdebug.h>
       
    28 #include <xqserviceutil.h>
    18 #include <QtTest/QtTest>
    29 #include <QtTest/QtTest>
    19 #include <hbapplication.h>
    30 #include "hbapplication.h"
    20 #include <hbinstance.h>
    31 #include "hbeffect.h"
       
    32 #include "hbinstance.h"
       
    33 #include "hbmenu.h"
       
    34 #include "hbmenudata.h"
       
    35 #include "hbtoolbar.h"
       
    36 #include "hbaction.h"
       
    37 #include "hbstackedwidget.h"
       
    38 #include "hbgroupbox.h"
       
    39 #include "hbdocumentloader.h"
       
    40 #include "hbview.h"
       
    41 #include "hblistview.h"
       
    42 #include "hbinputdialog.h"
    21 #include <qactiongroup.h>
    43 #include <qactiongroup.h>
    22 #include <hbmenu.h>
       
    23 #include <hbtoolbar.h>
       
    24 #include <hbaction.h>
       
    25 #include <videocollectioncommon.h>
    44 #include <videocollectioncommon.h>
    26 #include <hbstackedwidget.h>
       
    27 #include <hbgroupbox.h>
       
    28 #include <hbdocumentloader.h>
       
    29 #include <qhash.h>
    45 #include <qhash.h>
    30 #include <qmap.h>
    46 #include <qmap.h>
    31 #include <hbview.h>
       
    32 #include <hblistview.h>
       
    33 #include <mpxitemid.h>
    47 #include <mpxitemid.h>
    34 #include <vcxmyvideosdefs.h>
    48 #include <vcxmyvideosdefs.h>
    35 
    49 
       
    50 #include "videocollectionuiloader.h"
    36 #include "videocollectionwrapper.h"
    51 #include "videocollectionwrapper.h"
    37 #include "testlistview.h"
    52 #include "testlistview.h"
    38 #include "videocollectionviewutils.h"
    53 #include "videocollectionviewutils.h"
    39 #include "videolistselectiondialog.h"
    54 #include "videolistselectiondialog.h"
    40 #include "videosortfilterproxymodel.h"
       
    41 #include "videocollectionwrapper.h"
    55 #include "videocollectionwrapper.h"
    42 #include "videohintwidget.h"
    56 #include "videohintwidget.h"
       
    57 #include "videohintwidgetdata.h"
    43 #include "videolistwidgetdata.h"
    58 #include "videolistwidgetdata.h"
    44 #include "videocollectionwrapperdata.h"
    59 #include "videocollectionwrapperdata.h"
    45 #include "videocollectionviewutilsdata.h"
    60 #include "videocollectionviewutilsdata.h"
    46 #include "videolistselectiondialogdata.h"
    61 #include "videolistselectiondialogdata.h"
    47 #include "videosortfilterproxymodeldata.h"
    62 #include "videosortfilterproxymodeldata.h"
    48 #include "videocollectionuiloaderdata.h"
    63 #include "videocollectionuiloaderdata.h"
    49 #include "videolistdatamodeldata.h"
    64 #include "videolistdatamodeldata.h"
    50 
    65 #include "xqserviceutilxtra.h"
    51 #define	private	public
       
    52 #include "videolistwidget.h"
       
    53 #include "videocollectionuiloader.h"
       
    54 #include "videolistview.h"
       
    55 #undef private
       
    56 
    66 
    57 // ---------------------------------------------------------------------------
    67 // ---------------------------------------------------------------------------
    58 // main
    68 // main
    59 // ---------------------------------------------------------------------------
    69 // ---------------------------------------------------------------------------
    60 //
    70 //
    61 int	main(int argc, char	*argv[])
    71 int	main(int argc, char	*argv[])
    62 {
    72 {
    63 	HbApplication app(argc,	argv);
    73 	HbApplication app(argc,	argv);
    64 	HbMainWindow window;
    74 	HbMainWindow window;
       
    75 	hbInstance->mWindowses.append(&window);
    65 
    76 
    66 	TestListView tv;
    77 	TestListView tv;
    67 
    78 
    68     int res;
    79     int res;
    69     if(argc > 1)
    80     if(argc > 1)
    86 // init
    97 // init
    87 // ---------------------------------------------------------------------------
    98 // ---------------------------------------------------------------------------
    88 //
    99 //
    89 void TestListView::init(bool initTestView)
   100 void TestListView::init(bool initTestView)
    90 {
   101 {
       
   102     XQServiceUtilXtra::service = false;
    91 	mUiLoader = new VideoCollectionUiLoader();
   103 	mUiLoader = new VideoCollectionUiLoader();
    92 	mUiLoader->reset();
   104 	mUiLoader->reset();
    93 
   105 
    94 	bool ok(false);
   106 	bool ok(false);
    95 	QList<QObject *> objects = mUiLoader->load(DOCML_VIDEOCOLLECTIONVIEW_FILE, &ok);
   107 	mUiLoader->load(DOCML_VIDEOCOLLECTIONVIEW_FILE, &ok);
    96     if (!ok)
   108     if (!ok)
    97     {
   109     {
    98     	return;
   110     	return;
    99     }
   111     }
   100 
   112 
   101     mTestView = mUiLoader->findObject<VideoListView>( DOCML_NAME_VIEW );
   113     mTestView = mUiLoader->findWidget<VideoListView>( DOCML_NAME_VIEW );
   102     QVERIFY(mTestView);
   114     QVERIFY(mTestView);
   103     if(initTestView)
   115     if(initTestView)
   104     {
   116     {
   105         QVERIFY(mTestView->initializeView() == 0);
   117         QVERIFY(mTestView->initializeView() == 0);
   106     }
   118     }
   116 // cleanup
   128 // cleanup
   117 // ---------------------------------------------------------------------------
   129 // ---------------------------------------------------------------------------
   118 //
   130 //
   119 void TestListView::cleanup()
   131 void TestListView::cleanup()
   120 {
   132 {
   121 	delete mTestView;
   133 	delete mUiLoader;
   122 	mTestView =	0;
   134 	mUiLoader = 0;
   123 	
   135 	
   124 	mWrapper = 0;
   136 	mWrapper = 0;
   125 
   137 	mTestView = 0;
   126 	disconnect();
   138 	disconnect();
   127 
   139 
   128     VideoListWidgetData::reset();
   140     VideoListWidgetData::reset();
   129     VideoCollectionWrapperData::reset();
   141     VideoCollectionWrapperData::reset();
   130     VideoCollectionViewUtilsData::reset();
   142     VideoCollectionViewUtilsData::reset();
   131     VideoListSelectionDialogData::reset();
   143     VideoListSelectionDialogData::reset();
   132     VideoSortFilterProxyModelData::reset();
   144     VideoSortFilterProxyModelData::reset();
       
   145     HbDocumentLoader::cleanup();
   133 }
   146 }
   134 
   147 
   135 // ---------------------------------------------------------------------------
   148 // ---------------------------------------------------------------------------
   136 // visibleMenuActions
   149 // visibleMenuActions
   137 // ---------------------------------------------------------------------------
   150 // ---------------------------------------------------------------------------
   139 int	TestListView::visibleMenuActions()
   152 int	TestListView::visibleMenuActions()
   140 {
   153 {
   141 	int	visibleActions(0);
   154 	int	visibleActions(0);
   142 	VideoCollectionUiLoader::ActionIds key;
   155 	VideoCollectionUiLoader::ActionIds key;
   143 	HbAction *action(0);
   156 	HbAction *action(0);
   144 	foreach(key,mUiLoader->mMenuActions.keys())
   157 	foreach (key,VideoCollectionUiLoaderData::mMenuActions.keys())
   145 	{
   158 	{
   146 		action = dynamic_cast<HbAction*>(mUiLoader->mMenuActions[key]);
   159 		action = dynamic_cast<HbAction*>(VideoCollectionUiLoaderData::mMenuActions[key]);
   147 		if(action && action->isVisible())
   160 		if (action && action->isVisible())
   148 			visibleActions++;
   161 		{
       
   162             visibleActions++;
       
   163 		}
   149 	}
   164 	}
   150 	return visibleActions;
   165 	return visibleActions;
   151 }
   166 }
   152 
   167 
   153 // ---------------------------------------------------------------------------
   168 // ---------------------------------------------------------------------------
   154 // setRowCount
   169 // setRowCount
   155 // ---------------------------------------------------------------------------
   170 // ---------------------------------------------------------------------------
   156 //
   171 //
   157 void TestListView::setRowCount(int count)
   172 void TestListView::setRowCount(int count, VideoSortFilterProxyModel *model)
   158 {
   173 {
   159     if (mTestView)
   174     if(!model)
   160     {
   175     {
   161         if (!mTestView->mCurrentList)
   176         if (mTestView)
   162         {
   177         {
   163             mTestView->activateView();
   178             if (!mTestView->mCurrentList)
   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             {
   179             {
   173                 VideoListDataModelData::setRowCount(*sourceModel, count);
   180                 mTestView->activateView(TMPXItemId::InvalidId());
   174             }
   181             }
       
   182             model = mTestView->mCurrentList->mModel;
   175         }
   183         }
   176     }
   184     }
       
   185 
       
   186     if (model)
       
   187     {
       
   188         VideoListDataModel *sourceModel =
       
   189             qobject_cast<VideoListDataModel*>(
       
   190                 model->sourceModel());
       
   191         if(sourceModel)
       
   192         {
       
   193             VideoListDataModelData::setRowCount(*sourceModel, count);
       
   194         }
       
   195     }
       
   196 }
       
   197 
       
   198 // ---------------------------------------------------------------------------
       
   199 // isActionVisible
       
   200 // ---------------------------------------------------------------------------
       
   201 //
       
   202 bool TestListView::isActionVisible(const char *name) const
       
   203 {
       
   204     bool isVisible = false;
       
   205     
       
   206     HbAction *action = mUiLoader->findObject<HbAction>(name);
       
   207     if (!action)
       
   208     {
       
   209         // must be menu widget
       
   210         HbMenu *menu = mUiLoader->findWidget<HbMenu>(name);
       
   211         if (menu)
       
   212         {
       
   213             action = menu->menuAction();
       
   214         }
       
   215     }
       
   216     
       
   217     // check if action is visible
       
   218     if (action)
       
   219     {
       
   220         isVisible = action->isVisible();
       
   221     }
       
   222     
       
   223     return isVisible;
   177 }
   224 }
   178 
   225 
   179 // ---------------------------------------------------------------------------
   226 // ---------------------------------------------------------------------------
   180 // testCreateDelete
   227 // testCreateDelete
   181 // ---------------------------------------------------------------------------
   228 // ---------------------------------------------------------------------------
   188 
   235 
   189 	mUiLoader->reset();
   236 	mUiLoader->reset();
   190 
   237 
   191 	bool ok(false);
   238 	bool ok(false);
   192 
   239 
   193 	QList<QObject *> objects = mUiLoader->load(DOCML_VIDEOCOLLECTIONVIEW_FILE, &ok);
   240 	mUiLoader->load(DOCML_VIDEOCOLLECTIONVIEW_FILE, &ok);
   194 
   241 
   195     if (!ok)
   242     if (!ok)
   196     {
   243     {
   197     	return;
   244     	return;
   198     }
   245     }
   199 
   246 
   200     mTestView = mUiLoader->findObject<VideoListView>( DOCML_NAME_VIEW );
   247     mTestView = mUiLoader->findWidget<VideoListView>( DOCML_NAME_VIEW );
   201 
   248 
   202     delete mTestView;
   249     delete mTestView;
   203 	mTestView =	0;
   250 	mTestView =	0;
   204 }
   251 }
   205 
   252 
   211 {
   258 {
   212     VideoListWidget *videoListWidget = 0;
   259     VideoListWidget *videoListWidget = 0;
   213     VideoHintWidget *hintWidget = 0;
   260     VideoHintWidget *hintWidget = 0;
   214     
   261     
   215     init(false);
   262     init(false);
   216 	// Test	videolist widget creation failure.
   263 	// Test mUiLoader is null
   217 	VideoListWidgetData::mInitializeReturnValue	= -1;
   264     VideoCollectionUiLoader *tmp = mTestView->mUiLoader;
   218 	QVERIFY( mTestView->initializeView() < 0 );
   265 	mTestView->mUiLoader = 0;
   219 	QVERIFY( mTestView->mToolbarViewsActionGroup == 0 );
   266 	QVERIFY( mTestView->initializeView() < 0 );	
   220 	QVERIFY( mTestView->mToolbarCollectionActionGroup == 0 );
       
   221 	QVERIFY( mTestView->mVideoServices == 0 );
   267 	QVERIFY( mTestView->mVideoServices == 0 );
   222 	QVERIFY( mTestView->mIsService == false );
   268 	QVERIFY( mTestView->mIsService == false );
   223 
   269 	mTestView->mUiLoader = tmp;
   224 	cleanup();
   270 	
   225 
   271 	// service flag is false and mVideoServices is != 0
   226 	// Test	widget creation	succeed.
   272 	mTestView->mIsService = false;
   227 	init(false);
   273 	XQServiceUtilXtra::service = false;
   228     VideoCollectionViewUtilsData::mSortRole = Qt::DisplayRole;
   274 	mTestView->mVideoServices = VideoServices::instance();
   229     VideoCollectionViewUtilsData::mSortOrder = Qt::DescendingOrder;
   275 	QVERIFY( mTestView->initializeView() == 0 );    
   230 	QVERIFY( mTestView->initializeView() ==	0 );
   276     QVERIFY( mTestView->mVideoServices != 0 );
   231 	// Verify
   277     QVERIFY( mTestView->mIsService == false );
   232 	QCOMPARE( VideoListWidgetData::mInitializeCount, 1 );
   278 	
   233 	QVERIFY( mTestView->mToolbarViewsActionGroup != 0 );
   279     // servicve flag is true, mVideoServices is 0
   234 	QVERIFY( mTestView->mToolbarCollectionActionGroup != 0 );
   280     mTestView->mVideoServices = 0;
   235 	QCOMPARE( mTestView->mToolbarViewsActionGroup->actions().count(), 3 );
   281     XQServiceUtilXtra::service = true;
   236 	QCOMPARE( mTestView->mToolbarCollectionActionGroup->actions().count(), 3 );
   282     QVERIFY( mTestView->initializeView() == 0 );    
   237 	QCOMPARE( mTestView->toolBar()->actions().count(), 3 );
   283     QVERIFY( mTestView->mVideoServices != 0 );
   238 	// to my understanding the all videos action should	always be first.
   284     QVERIFY( mTestView->mIsService == true );
   239 	QVERIFY( mTestView->mToolbarViewsActionGroup->actions().first()->isChecked()	);
   285     XQServiceUtilXtra::service = false;
   240 	QCOMPARE( VideoSortFilterProxyModelData::mSortRole, (int)Qt::DisplayRole );
   286     
   241 	QCOMPARE( VideoSortFilterProxyModelData::mSortOrder, Qt::DescendingOrder );
   287 	cleanup();	
   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 }
   288 }
   341 
   289 
   342 // ---------------------------------------------------------------------------
   290 // ---------------------------------------------------------------------------
   343 // testMenus
   291 // testMenus
   344 // ---------------------------------------------------------------------------
   292 // ---------------------------------------------------------------------------
   345 //
   293 //
   346 void TestListView::testMenus()
   294 void TestListView::testMenus()
   347 {
   295 {
   348 	init();
   296     init();
   349 
   297     mTestView->activateView(TMPXItemId::InvalidId());
   350 	HbAction* action;
   298 
   351 	QList<QAction*> tbActions = mTestView->toolBar()->actions();
   299     HbAction* action = 0;
   352 	QList<QAction*>	tbGroupActions;
   300     QList<QAction*> tbActions = mTestView->toolBar()->actions();
   353 	QList<QAction*>	tbGroupActions2;
   301     QList<QAction*>	tbGroupActions;
   354 
   302     QList<QAction*>	tbGroupActions2;
   355 	// All videos is open for default, verify.
   303 
   356 	QVERIFY(mTestView->mToolbarViewsActionGroup != 0);
   304     // All videos is open for default, verify.
   357 	QVERIFY(mTestView->mToolbarCollectionActionGroup != 0);
   305     QVERIFY( mTestView->mToolbarViewsActionGroup != 0 );
   358 	tbGroupActions = mTestView->mToolbarViewsActionGroup->actions();
   306     QVERIFY( mTestView->mToolbarCollectionActionGroup != 0 );
   359 	tbGroupActions2 = mTestView->mToolbarCollectionActionGroup->actions();
   307     tbGroupActions = mTestView->mToolbarViewsActionGroup->actions();
   360 	QVERIFY(mTestView->mToolbarActions.count() == 6);
   308     tbGroupActions2 = mTestView->mToolbarCollectionActionGroup->actions();
   361 	QVERIFY(tbActions.count() == 3);
   309     QCOMPARE( mTestView->mToolbarActions.count(), 5 );
   362 	QVERIFY(tbGroupActions.count() == 3);
   310     QCOMPARE( tbActions.count(), 3 );
   363 	QVERIFY(tbGroupActions2.count() == 3);
   311     QCOMPARE( tbGroupActions.count(), 3 );
   364 	QVERIFY( tbGroupActions.at(0)->isChecked() ); // First is checked.
   312     QCOMPARE( tbGroupActions2.count(), 2 );
   365 	// visible menu items remains constant after init until
   313     QVERIFY( tbGroupActions.at(0)->isChecked() ); // First is checked.
   366 	// aboutToShowMainMenuSlot is called
   314 
   367 	QVERIFY(visibleMenuActions() == 9);
   315     // Verify checkable	and	visible	toolbar	actions.
   368 	// Verify checkable	and	visible	toolbar	actions.
   316     HbAction* allVideosAction =	mTestView->mToolbarActions[VideoListView::ETBActionAllVideos];
   369 	HbAction* allVideosAction =	mTestView->mToolbarActions[VideoListView::ETBActionAllVideos];
   317     HbAction* collectionsAction	= mTestView->mToolbarActions[VideoListView::ETBActionCollections];
   370 	HbAction* collectionsAction	= mTestView->mToolbarActions[VideoListView::ETBActionCollections];
   318     HbAction* servicesAction = mTestView->mToolbarActions[VideoListView::ETBActionServices];
   371 	HbAction* servicesAction = mTestView->mToolbarActions[VideoListView::ETBActionServices];
   319     HbAction* addVideosAction =	mTestView->mToolbarActions[VideoListView::ETBActionAddVideos];
   372 	HbAction* addVideosAction =	mTestView->mToolbarActions[VideoListView::ETBActionAddVideos];
   320     HbAction* removeVideosAction = mTestView->mToolbarActions[VideoListView::ETBActionRemoveVideos];
   373 	HbAction* removeVideosAction = mTestView->mToolbarActions[VideoListView::ETBActionRemoveVideos];
   321     QVERIFY( allVideosAction !=	0 );
   374 	HbAction* sortVideosAction = mTestView->mToolbarActions[VideoListView::ETBActionSortVideos];
   322     QVERIFY( allVideosAction->isCheckable()	);
   375 	QVERIFY( allVideosAction !=	0 && allVideosAction->isCheckable()	&& allVideosAction->isVisible() &&
   323     QVERIFY( allVideosAction->isVisible() );
   376 			tbActions.at(0) == tbGroupActions.at(0));
   324     QVERIFY( tbActions.at(0) == tbGroupActions.at(0) );
   377 	QVERIFY( collectionsAction != 0	&& collectionsAction->isCheckable()	&& collectionsAction->isVisible() &&
   325     
   378 			tbActions.at(1) == tbGroupActions.at(1));
   326     QVERIFY( collectionsAction != 0	);
   379 	QVERIFY( servicesAction	!= 0 &&	servicesAction->isCheckable() && servicesAction->isVisible() &&
   327     QVERIFY( collectionsAction->isCheckable() );
   380 			tbActions.at(2) == tbGroupActions.at(2));
   328     QVERIFY( collectionsAction->isVisible() );
   381 	QVERIFY( addVideosAction !=	0 && !addVideosAction->isCheckable() &&
   329     QVERIFY( tbActions.at(1) == tbGroupActions.at(1) );
   382 			tbActions.at(0) != tbGroupActions2.at(0));
   330     
   383 	QVERIFY( removeVideosAction	!= 0 &&	!removeVideosAction->isCheckable() &&
   331     QVERIFY( servicesAction	!= 0 );
   384 			tbActions.at(1) != tbGroupActions2.at(1));
   332     QVERIFY( !servicesAction->isCheckable() );
   385 	QVERIFY( sortVideosAction != 0 && !sortVideosAction->isCheckable() &&
   333     QVERIFY( servicesAction->isVisible() );
   386 			tbActions.at(2) != tbGroupActions2.at(2));
   334     QVERIFY( tbActions.at(2) == tbGroupActions.at(2) );
   387 
   335     
   388 	// Open	collections.
   336     QVERIFY( addVideosAction !=	0 );
   389 	action = dynamic_cast<HbAction*>(tbGroupActions.at(1));
   337     QVERIFY( !addVideosAction->isCheckable() );
   390 	QVERIFY(action);
   338     QVERIFY( tbActions.at(0) != tbGroupActions2.at(0) );
   391 	action->setChecked(false);
   339     
   392 	action->trigger();
   340     QVERIFY( removeVideosAction	!= 0 );
   393 
   341     QVERIFY( !removeVideosAction->isCheckable() );
   394 	// Verify.
   342     QVERIFY( tbActions.at(1) != tbGroupActions2.at(1) );
   395 	QVERIFY(mTestView->mToolbarViewsActionGroup);
   343 
   396 	tbGroupActions = mTestView->mToolbarViewsActionGroup->actions();
   344     // Open	collections.
   397 	QVERIFY(mTestView->mToolbarActions.count() == 6);
   345     action = dynamic_cast<HbAction*>(tbGroupActions.at(1));
   398 	QVERIFY(tbGroupActions.count() == 3);
   346     QVERIFY( action );
   399 	QVERIFY(tbGroupActions2.count() == 3);
   347     action->setChecked(false);
   400 	QVERIFY( tbGroupActions.at(1)->isChecked() ); // 2nd is	checked.
   348     action->QAction::trigger();
   401 	// visible menu items remains constant after init until
   349 
   402 	// aboutToShowMainMenuSlot is called
   350     // Verify.
   403 	QVERIFY(visibleMenuActions() ==	9);
   351     QVERIFY( mTestView->mToolbarViewsActionGroup );
   404 	// Verify checkable	and	visible	toolbar	actions.
   352     tbGroupActions = mTestView->mToolbarViewsActionGroup->actions();
   405 	allVideosAction	= mTestView->mToolbarActions[VideoListView::ETBActionAllVideos];
   353     QCOMPARE( mTestView->mToolbarActions.count(), 5 );
   406 	collectionsAction =	mTestView->mToolbarActions[VideoListView::ETBActionCollections];
   354     QCOMPARE( tbGroupActions.count(), 3 );
   407 	servicesAction = mTestView->mToolbarActions[VideoListView::ETBActionServices];
   355     QCOMPARE( tbGroupActions2.count(), 2 );
   408 	addVideosAction	= mTestView->mToolbarActions[VideoListView::ETBActionAddVideos];
   356     QVERIFY( tbGroupActions.at(1)->isChecked() ); // 2nd is	checked.
   409 	removeVideosAction = mTestView->mToolbarActions[VideoListView::ETBActionRemoveVideos];
   357 
   410 	sortVideosAction = mTestView->mToolbarActions[VideoListView::ETBActionSortVideos];
   358     // Verify checkable	and	visible	toolbar	actions.
   411 	QVERIFY( allVideosAction !=	0 && allVideosAction->isCheckable()	&& allVideosAction->isVisible()	&&
   359     allVideosAction	= mTestView->mToolbarActions[VideoListView::ETBActionAllVideos];
   412 			tbActions.at(0) == tbGroupActions.at(0));
   360     collectionsAction =	mTestView->mToolbarActions[VideoListView::ETBActionCollections];
   413 	QVERIFY( collectionsAction != 0	&& collectionsAction->isCheckable()	&& collectionsAction->isVisible() &&
   361     servicesAction = mTestView->mToolbarActions[VideoListView::ETBActionServices];
   414 			tbActions.at(1) == tbGroupActions.at(1));
   362     addVideosAction	= mTestView->mToolbarActions[VideoListView::ETBActionAddVideos];
   415 	QVERIFY( servicesAction	!= 0 &&	servicesAction->isCheckable() && servicesAction->isVisible() &&
   363     removeVideosAction = mTestView->mToolbarActions[VideoListView::ETBActionRemoveVideos];
   416 			tbActions.at(2) == tbGroupActions.at(2));
   364     QVERIFY( allVideosAction !=	0 );
   417 	QVERIFY( addVideosAction !=	0 && !addVideosAction->isCheckable() &&
   365     QVERIFY( allVideosAction->isCheckable()	);
   418 			tbActions.at(0) != tbGroupActions2.at(0));
   366     QVERIFY( allVideosAction->isVisible() );
   419 	QVERIFY( removeVideosAction	!= 0 &&	!removeVideosAction->isCheckable() &&
   367     QVERIFY( tbActions.at(0) == tbGroupActions.at(0) );
   420 			tbActions.at(1) != tbGroupActions2.at(1));
   368     
   421 	QVERIFY( sortVideosAction != 0 && !sortVideosAction->isCheckable() &&
   369     QVERIFY( collectionsAction != 0	);
   422 			tbActions.at(2) != tbGroupActions2.at(2));
   370     QVERIFY( collectionsAction->isCheckable() );
   423 
   371     QVERIFY( collectionsAction->isVisible() );
   424 	cleanup();
   372     QVERIFY( tbActions.at(1) == tbGroupActions.at(1) );
       
   373     
       
   374     QVERIFY( servicesAction	!= 0 );
       
   375     QVERIFY( !servicesAction->isCheckable() );
       
   376     QVERIFY( servicesAction->isVisible() );
       
   377     QVERIFY( tbActions.at(2) == tbGroupActions.at(2) );
       
   378     
       
   379     QVERIFY( addVideosAction !=	0 );
       
   380     QVERIFY( !addVideosAction->isCheckable() );
       
   381     QVERIFY( tbActions.at(0) != tbGroupActions2.at(0) );
       
   382     
       
   383     QVERIFY( removeVideosAction	!= 0 );
       
   384     QVERIFY( !removeVideosAction->isCheckable() );
       
   385     QVERIFY( tbActions.at(1) != tbGroupActions2.at(1) );
       
   386 
       
   387     cleanup();
   425 }
   388 }
   426 
   389 
   427 // ---------------------------------------------------------------------------
   390 // ---------------------------------------------------------------------------
   428 // Slot: test create toolbar
   391 // Slot: test create toolbar
   429 // ---------------------------------------------------------------------------
   392 // ---------------------------------------------------------------------------
   430 //
   393 //
   431 void TestListView::testCreateAction()
   394 void TestListView::testCreateAction()
   432 {
   395 {
   433 	init();
   396 	init();
       
   397 	mTestView->activateView(TMPXItemId::InvalidId());
   434 
   398 
   435 	QVERIFY(mTestView->mToolbarViewsActionGroup != 0);
   399 	QVERIFY(mTestView->mToolbarViewsActionGroup != 0);
   436 
   400 
   437 	QList<QAction*>	actions	= mTestView->mToolbarViewsActionGroup->actions();
   401 	QList<QAction*>	actions	= mTestView->mToolbarViewsActionGroup->actions();
   438 	actions.append(mTestView->mToolbarCollectionActionGroup->actions());
   402 	actions.append(mTestView->mToolbarCollectionActionGroup->actions());
   439 	QVERIFY(actions.count()	== 6);
   403 	QCOMPARE(actions.count(), 5);
   440 
   404 
   441 	QCOMPARE( mTestView->toolBar()->actions().count(), 3 );
   405 	QCOMPARE( mTestView->toolBar()->actions().count(), 3 );
   442 
   406 
   443 	HbAction* allVideos	= static_cast<HbAction*>(actions.at(0));
   407 	HbAction* allVideos	= static_cast<HbAction*>(actions.at(0));
   444 	QVERIFY( allVideos->isCheckable() );
   408 	QVERIFY( allVideos->isCheckable() );
   445 	QCOMPARE( allVideos->icon().iconName(),	QString(":/images/qtg_mono_video_all.svg")	);
   409 	QCOMPARE( allVideos->icon().iconName(),	QString(":/images/qtg_mono_video_all.svg")	);
       
   410 	QVERIFY( allVideos->isChecked() );
   446 
   411 
   447 	HbAction* collections =	static_cast<HbAction*>(actions.at(1));
   412 	HbAction* collections =	static_cast<HbAction*>(actions.at(1));
   448 	QVERIFY( collections->isCheckable()	);
   413 	QVERIFY( collections->isCheckable()	);
   449 	QCOMPARE( collections->icon().iconName(), QString(":/images/qtg_mono_video_collection.svg") );
   414 	QCOMPARE( collections->icon().iconName(), QString("qtg_mono_video_collection") );
   450 
   415 
   451 	HbAction* services = static_cast<HbAction*>(actions.at(2));
   416 	HbAction* services = static_cast<HbAction*>(actions.at(2));
   452 	QVERIFY( services->isCheckable() );
   417 	QVERIFY( !services->isCheckable() );
   453 	QCOMPARE( services->icon().iconName(), QString(":/images/qtg_mono_video_services.svg") );
   418 	QCOMPARE( services->icon().iconName(), QString("qtg_mono_ovistore") );
   454 
   419 
   455 	HbAction* addVideos	= static_cast<HbAction*>(actions.at(3));
   420 	HbAction* addVideos	= static_cast<HbAction*>(actions.at(3));
   456 	QVERIFY( !addVideos->isCheckable() );
   421 	QVERIFY( !addVideos->isCheckable() );
   457 	QCOMPARE( addVideos->icon().iconName(),	QString(":/images/mono_video_addvideos.svg") );
   422 	QCOMPARE( addVideos->icon().iconName(),	QString("qtg_mono_add_to_video_collection") );
   458 
   423 
   459 	HbAction* removeVideos = static_cast<HbAction*>(actions.at(4));
   424 	HbAction* removeVideos = static_cast<HbAction*>(actions.at(4));
   460 	QVERIFY( !removeVideos->isCheckable() );
   425 	QVERIFY( !removeVideos->isCheckable() );
   461 	QCOMPARE( removeVideos->icon().iconName(), QString(":/images/mono_video_removevideos.svg") );
   426 	QCOMPARE( removeVideos->icon().iconName(), QString("qtg_mono_remove_from_video_collection") );
   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 
   427 
   467 	cleanup();
   428 	cleanup();
   468 }
   429 }
   469 
   430 
   470 // ---------------------------------------------------------------------------
   431 // ---------------------------------------------------------------------------
   474 void TestListView::testActivateView()
   435 void TestListView::testActivateView()
   475 {
   436 {
   476     VideoListWidget* videoListWidget = 0;
   437     VideoListWidget* videoListWidget = 0;
   477     
   438     
   478 	init();
   439 	init();
   479 
   440 	
   480 	videoListWidget = mUiLoader->findWidget<VideoListWidget>(DOCML_NAME_VC_VIDEOLISTWIDGET);
   441 	HbMainWindow *mainWnd = hbInstance->allMainWindows().value(0);
   481 	QVERIFY(videoListWidget);
   442 	mainWnd->unsetOrientation(false);
   482 	mTestView->mCurrentList = 0;
   443     mTestView->mCurrentList = 0;
   483 
   444 	HbDocumentLoader::mFindWidgetFails = true;
   484 	QCOMPARE( mTestView->activateView(), -1	);
   445 	QCOMPARE( mTestView->activateView(TMPXItemId::InvalidId()), -1	);
   485     QVERIFY( VideoListWidgetData::mActive == false );
   446     QVERIFY( VideoListWidgetData::mActive == false );
   486     QCOMPARE( mTestView->mCurrentList, videoListWidget );
   447     QVERIFY( mTestView->mCurrentList == 0 );
   487     QCOMPARE( VideoListWidgetData::mActivateCount, 0 );
   448     QCOMPARE( VideoListWidgetData::mActivateCount, 0 );
   488 	QCOMPARE( VideoListWidgetData::mDeactivateCount, 0 );
   449 	QCOMPARE( VideoListWidgetData::mDeactivateCount, 0 );
   489 	QVERIFY( mUiLoader->findWidget<HbMenu>(DOCML_NAME_OPTIONS_MENU)->isEnabled() == false );
   450 	QVERIFY( mainWnd->mOrientationSet == false );
   490 	
   451 	
       
   452     HbDocumentLoader::mFindWidgetFails = false;
       
   453     videoListWidget = mUiLoader->findWidget<VideoListWidget>(DOCML_NAME_VC_VIDEOLISTWIDGET);
       
   454     QVERIFY(videoListWidget);
   491 	VideoListWidgetData::mActivateReturnValue =	-1;
   455 	VideoListWidgetData::mActivateReturnValue =	-1;
   492 
   456 	QCOMPARE( mTestView->activateView(TMPXItemId::InvalidId()), -1	);
   493 	QCOMPARE( mTestView->activateView(), -1	);
       
   494 	QVERIFY( VideoListWidgetData::mActive == false );
   457 	QVERIFY( VideoListWidgetData::mActive == false );
   495 	QCOMPARE( VideoListWidgetData::mActivateCount, 1 );
   458 	QCOMPARE( VideoListWidgetData::mActivateCount, 1 );
   496 	QCOMPARE( VideoListWidgetData::mDeactivateCount, 1 );
   459 	QCOMPARE( VideoListWidgetData::mDeactivateCount, 1 );
   497 	QVERIFY( mUiLoader->findWidget<HbMenu>(DOCML_NAME_OPTIONS_MENU)->isEnabled() == false );
   460     QVERIFY( mainWnd->mOrientationSet == false );
   498 
   461 
   499 	VideoListWidgetData::mActivateReturnValue =	0;
   462 	VideoListWidgetData::mActivateReturnValue =	0;
   500 	
   463 	QCOMPARE( mTestView->activateView(TMPXItemId::InvalidId()), 0 );
   501 	QCOMPARE( mTestView->activateView(), 0 );
       
   502 	QVERIFY( VideoListWidgetData::mActive );
   464 	QVERIFY( VideoListWidgetData::mActive );
   503 	QCOMPARE( VideoListWidgetData::mActivateCount, 2 );
   465 	QCOMPARE( VideoListWidgetData::mActivateCount, 2 );
   504 	QCOMPARE( VideoListWidgetData::mDeactivateCount, 1 );
   466 	QCOMPARE( VideoListWidgetData::mDeactivateCount, 1 );
   505 	QVERIFY( mUiLoader->findWidget<HbMenu>(DOCML_NAME_OPTIONS_MENU)->isEnabled() );
   467     QVERIFY( mainWnd->mOrientationSet );
   506 
   468     QCOMPARE( mainWnd->mOrientation, Qt::Vertical );
   507 	QCOMPARE( mTestView->activateView(), 0 );
   469 
       
   470 	QCOMPARE( mTestView->activateView(TMPXItemId::InvalidId()), 0 );
   508 	QVERIFY( VideoListWidgetData::mActive );
   471 	QVERIFY( VideoListWidgetData::mActive );
   509 	QCOMPARE( VideoListWidgetData::mActivateCount, 3 );
   472 	QCOMPARE( VideoListWidgetData::mActivateCount, 3 );
   510 	QCOMPARE( VideoListWidgetData::mDeactivateCount, 1 );
   473 	QCOMPARE( VideoListWidgetData::mDeactivateCount, 1 );
   511 	QVERIFY( mUiLoader->findWidget<HbMenu>(DOCML_NAME_OPTIONS_MENU)->isEnabled() );
   474     QVERIFY( mainWnd->mOrientationSet );
   512 
   475     QCOMPARE( mainWnd->mOrientation, Qt::Vertical );
   513 	cleanup();
   476     
       
   477     cleanup();
       
   478 
       
   479     // activate view:
       
   480     // -browse service
       
   481     // -captured category
       
   482     TMPXItemId itemId = TMPXItemId::InvalidId();
       
   483     init();
       
   484     VideoListWidgetData::reset();
       
   485     VideoSortFilterProxyModelData::reset();
       
   486     itemId.iId1 = KVcxMvcCategoryIdCaptured;
       
   487     itemId.iId2 = KVcxMvcMediaTypeCategory;
       
   488     QCOMPARE(mTestView->activateView(itemId), 0);
       
   489     QVERIFY(VideoListWidgetData::mActive);
       
   490     QCOMPARE(VideoListWidgetData::mActivateCount, 1);
       
   491     QCOMPARE(mTestView->mCollectionName, hbTrId("txt_videos_dblist_captured"));
       
   492     QCOMPARE(mTestView->mCurrentList->getLevel(), VideoCollectionCommon::ELevelDefaultColl);
       
   493     QCOMPARE(VideoSortFilterProxyModelData::mLastItemId, itemId);
       
   494     QCOMPARE(VideoSortFilterProxyModelData::mSortRole, (int)VideoCollectionCommon::KeyDateTime);
       
   495     QCOMPARE(VideoSortFilterProxyModelData::mSortOrder, Qt::AscendingOrder);
       
   496     cleanup();
       
   497     
       
   498     // activate view:
       
   499     // -browse service
       
   500     // -downloaded category
       
   501     init();
       
   502     VideoListWidgetData::reset();
       
   503     VideoSortFilterProxyModelData::reset();
       
   504     itemId.iId1 = KVcxMvcCategoryIdDownloads;
       
   505     itemId.iId2 = KVcxMvcMediaTypeCategory;
       
   506     QCOMPARE(mTestView->activateView(itemId), 0);
       
   507     QVERIFY(VideoListWidgetData::mActive);
       
   508     QCOMPARE(VideoListWidgetData::mActivateCount, 1);
       
   509     QCOMPARE(mTestView->mCollectionName, hbTrId("txt_videos_dblist_downloaded"));
       
   510     QCOMPARE(mTestView->mCurrentList->getLevel(), VideoCollectionCommon::ELevelDefaultColl);
       
   511     QCOMPARE(VideoSortFilterProxyModelData::mLastItemId, itemId);
       
   512     QCOMPARE(VideoSortFilterProxyModelData::mSortRole, (int)VideoCollectionCommon::KeyDateTime);
       
   513     QCOMPARE(VideoSortFilterProxyModelData::mSortOrder, Qt::AscendingOrder);
       
   514     cleanup();
       
   515 
       
   516     // activate view:
       
   517     // -browse service
       
   518     // -other category
       
   519     init();
       
   520     VideoListWidgetData::reset();
       
   521     VideoSortFilterProxyModelData::reset();
       
   522     itemId.iId1 = KVcxMvcCategoryIdOther;
       
   523     itemId.iId2 = KVcxMvcMediaTypeCategory;
       
   524     QCOMPARE(mTestView->activateView(itemId), 0);
       
   525     QVERIFY(VideoListWidgetData::mActive);
       
   526     QCOMPARE(VideoListWidgetData::mActivateCount, 1);
       
   527     QCOMPARE(mTestView->mCollectionName.length(), 0);
       
   528     QCOMPARE(mTestView->mCurrentList->getLevel(), VideoCollectionCommon::ELevelVideos);
       
   529     QCOMPARE(VideoSortFilterProxyModelData::mLastItemId, TMPXItemId::InvalidId());
       
   530     cleanup();
       
   531 
       
   532     // activate view:
       
   533     // -browse service
       
   534     // -invalid category but item id is ok
       
   535     init();
       
   536     VideoListWidgetData::reset();
       
   537     VideoSortFilterProxyModelData::reset();
       
   538     itemId.iId1 = 0;
       
   539     itemId.iId2 = KVcxMvcMediaTypeVideo;
       
   540     QCOMPARE(mTestView->activateView(itemId), 0);
       
   541     QVERIFY(VideoListWidgetData::mActive);
       
   542     QCOMPARE(VideoListWidgetData::mActivateCount, 1);
       
   543     QCOMPARE(mTestView->mCollectionName.length(), 0);
       
   544     QCOMPARE(mTestView->mCurrentList->getLevel(), VideoCollectionCommon::ELevelVideos);
       
   545     QCOMPARE(VideoSortFilterProxyModelData::mLastItemId, TMPXItemId::InvalidId());
       
   546     cleanup();
   514 }
   547 }
   515 
   548 
   516 // ---------------------------------------------------------------------------
   549 // ---------------------------------------------------------------------------
   517 // Slot: test deactivate view
   550 // Slot: test deactivate view
   518 // ---------------------------------------------------------------------------
   551 // ---------------------------------------------------------------------------
   520 void TestListView::testDeactivateView()
   553 void TestListView::testDeactivateView()
   521 {
   554 {
   522     VideoListWidget* videoListWidget = 0;
   555     VideoListWidget* videoListWidget = 0;
   523 
   556 
   524     init();
   557     init();
       
   558 
       
   559     HbMainWindow *mainWnd = hbInstance->allMainWindows().value(0);
   525 
   560 
   526     videoListWidget = mUiLoader->findWidget<VideoListWidget>(DOCML_NAME_VC_VIDEOLISTWIDGET);
   561     videoListWidget = mUiLoader->findWidget<VideoListWidget>(DOCML_NAME_VC_VIDEOLISTWIDGET);
   527     QVERIFY(videoListWidget);
   562     QVERIFY(videoListWidget);
   528     mTestView->mCurrentList = 0;
   563     mTestView->mCurrentList = 0;
       
   564     mainWnd->mOrientationSet = true;
   529 
   565 
   530 	mTestView->deactivateView();
   566 	mTestView->deactivateView();
   531 	QVERIFY( mUiLoader->findWidget<HbMenu>(DOCML_NAME_OPTIONS_MENU)->isVisible() == false );
   567 	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 );
   568 	QCOMPARE( VideoListWidgetData::mDeactivateCount, 0 );
   534 
   569     QVERIFY( mainWnd->mOrientationSet == false );
       
   570     
       
   571     mTestView->mCurrentList = videoListWidget;
       
   572     mainWnd->mOrientationSet = true;
       
   573     
   535 	mTestView->deactivateView();
   574 	mTestView->deactivateView();
   536 	QVERIFY( mUiLoader->findWidget<HbMenu>(DOCML_NAME_OPTIONS_MENU)->isVisible() == false );
   575 	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 );
   576 	QCOMPARE( VideoListWidgetData::mDeactivateCount, 1 );
       
   577     QVERIFY( mainWnd->mOrientationSet == false );
   539 
   578 
   540 	VideoListWidgetData::mActivateReturnValue =	0;
   579 	VideoListWidgetData::mActivateReturnValue =	0;
   541 	mTestView->activateView();
   580     mainWnd->mOrientationSet = true;
       
   581 	mTestView->activateView(TMPXItemId::InvalidId());
   542 	mTestView->deactivateView();
   582 	mTestView->deactivateView();
   543 	QVERIFY( mUiLoader->findWidget<HbMenu>(DOCML_NAME_OPTIONS_MENU)->isVisible() == false );
   583 	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 );
   584 	QCOMPARE( VideoListWidgetData::mActivateCount, 1 );
   546 	QCOMPARE( VideoListWidgetData::mDeactivateCount, 2 );
   585 	QCOMPARE( VideoListWidgetData::mDeactivateCount, 2 );
       
   586     QVERIFY( mainWnd->mOrientationSet == false );
   547 
   587 
   548 	cleanup();
   588 	cleanup();
   549 }
   589 }
   550 
   590 
   551 // ---------------------------------------------------------------------------
   591 // ---------------------------------------------------------------------------
   569 {
   609 {
   570     VideoListWidget *videoListWidget = 0;
   610     VideoListWidget *videoListWidget = 0;
   571     HbGroupBox *subLabel = 0;
   611     HbGroupBox *subLabel = 0;
   572     
   612     
   573 	init();
   613 	init();
       
   614 	mTestView->activateView(TMPXItemId::InvalidId());
   574 	
   615 	
   575     videoListWidget = mUiLoader->findWidget<VideoListWidget>(DOCML_NAME_VC_VIDEOLISTWIDGET);
   616     videoListWidget = mUiLoader->findWidget<VideoListWidget>(DOCML_NAME_VC_VIDEOLISTWIDGET);
   576     QVERIFY(videoListWidget);
   617     QVERIFY( videoListWidget );
   577     subLabel = mUiLoader->findWidget<HbGroupBox>(DOCML_NAME_VC_HEADINGBANNER);
       
   578     QVERIFY(subLabel);
       
   579 
   618 
   580 	QList<QAction*>	actions	= mTestView->mToolbarViewsActionGroup->actions();
   619 	QList<QAction*>	actions	= mTestView->mToolbarViewsActionGroup->actions();
   581 	HbAction* action = static_cast<HbAction*>(actions.at(0));
   620 	HbAction* action = static_cast<HbAction*>(actions.at(0));
   582 	
       
   583 	videoListWidget->mCurrentLevel = VideoCollectionCommon::ELevelCategory;
       
   584 	subLabel->setHeading("invalid");
       
   585 	
   621 	
   586 	// action wont emit	if it's	already	checked.
   622 	// action wont emit	if it's	already	checked.
   587 	action->setChecked(false);
   623 	action->setChecked(false);
   588 	action->trigger();
   624 	action->trigger();
   589 	QCOMPARE( mTestView->mCurrentList->mCurrentLevel, VideoCollectionCommon::ELevelVideos );
   625 	QCOMPARE( mTestView->mCurrentList, videoListWidget );
   590     QVERIFY( VideoListWidgetData::mActive == true );
   626 
   591     QCOMPARE( VideoListWidgetData::mActivateCount, 1 );
   627 	mTestView->mCurrentList = mUiLoader->findWidget<VideoListWidget>(DOCML_NAME_VC_COLLECTIONWIDGET);
   592     QCOMPARE( VideoListWidgetData::mDeactivateCount, 0 );
   628 	QVERIFY( mTestView->mCurrentList );
   593     QCOMPARE( subLabel->heading(), tr("txt_videos_subtitle_ln_videos" ));
   629     VideoListWidgetData::mActivateCount = 0;
   594 	QCOMPARE(mTestView->mCurrentList, videoListWidget);
   630 	videoListWidget->mCurrentLevel = VideoCollectionCommon::ELevelCategory;
   595 
       
   596 	mTestView->activateView();
       
   597 	
       
   598 	VideoListWidgetData::mActivateCount = 0;
       
   599 	mTestView->mCurrentList->mCurrentLevel = VideoCollectionCommon::ELevelCategory;
       
   600     subLabel->setHeading("invalid");
       
   601     
   631     
   602     // action wont emit	if it's	already	checked.
   632     // action wont emit	if it's	already	checked.
   603 	action->setChecked(false);
   633 	action->setChecked(false);
   604 	action->trigger();
   634 	action->trigger();
       
   635     QCOMPARE( mTestView->mCurrentList, videoListWidget );
   605     QCOMPARE( mTestView->mCurrentList->mCurrentLevel, VideoCollectionCommon::ELevelVideos );
   636     QCOMPARE( mTestView->mCurrentList->mCurrentLevel, VideoCollectionCommon::ELevelVideos );
   606     QVERIFY( VideoListWidgetData::mActive == true );
   637     QVERIFY( VideoListWidgetData::mActive == true );
   607 	QCOMPARE( VideoListWidgetData::mActivateCount, 1 );
   638 	QCOMPARE( VideoListWidgetData::mActivateCount, 1 );
   608 	QCOMPARE( VideoListWidgetData::mDeactivateCount, 0 );
   639 	QCOMPARE( VideoListWidgetData::mDeactivateCount, 1 );
   609     QCOMPARE( subLabel->heading(), tr("txt_videos_subtitle_ln_videos" ));
       
   610     QCOMPARE(mTestView->mCurrentList, videoListWidget);
       
   611 
   640 
   612 	cleanup();
   641 	cleanup();
   613 }
   642 }
   614 
   643 
   615 // ---------------------------------------------------------------------------
   644 // ---------------------------------------------------------------------------
   620 {
   649 {
   621     VideoListWidget *collectionWidget = 0;
   650     VideoListWidget *collectionWidget = 0;
   622     HbGroupBox *subLabel = 0;
   651     HbGroupBox *subLabel = 0;
   623 
   652 
   624     init();
   653     init();
       
   654     mTestView->activateView(TMPXItemId::InvalidId());
   625 
   655 
   626 	QList<QAction*>	actions	= mTestView->mToolbarViewsActionGroup->actions();
   656 	QList<QAction*>	actions	= mTestView->mToolbarViewsActionGroup->actions();
   627 	HbAction* action = static_cast<HbAction*>(actions.at(1));
   657 	HbAction* action = static_cast<HbAction*>(actions.at(1));
   628 
   658 
   629 	collectionWidget = mUiLoader->findWidget<VideoListWidget>(DOCML_NAME_VC_COLLECTIONWIDGET);
   659 	collectionWidget = mUiLoader->findWidget<VideoListWidget>(DOCML_NAME_VC_COLLECTIONWIDGET);
   630     QVERIFY(collectionWidget);
   660     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 
   661 
   637 	// action wont emit	if it's	already	checked.
   662 	// action wont emit	if it's	already	checked.
   638 	action->setChecked(false);
   663 	action->setChecked(false);
   639 	action->trigger();
   664 	action->trigger();
       
   665     QCOMPARE(mTestView->mCurrentList, collectionWidget);
       
   666 
       
   667     mTestView->mCurrentList = mUiLoader->findWidget<VideoListWidget>(DOCML_NAME_VC_VIDEOLISTWIDGET);
       
   668     QVERIFY( mTestView->mCurrentList );
       
   669     VideoListWidgetData::mActivateCount = 0;
       
   670     VideoListWidgetData::mDeactivateCount = 0;
       
   671     collectionWidget->mCurrentLevel = VideoCollectionCommon::ELevelVideos;
       
   672     
       
   673     // action wont emit	if it's	already	checked.
       
   674 	action->setChecked(false);
       
   675 	action->trigger();
       
   676     QCOMPARE(mTestView->mCurrentList, collectionWidget);
   640     QCOMPARE( mTestView->mCurrentList->mCurrentLevel, VideoCollectionCommon::ELevelCategory );
   677     QCOMPARE( mTestView->mCurrentList->mCurrentLevel, VideoCollectionCommon::ELevelCategory );
   641     QVERIFY( VideoListWidgetData::mActive == true );
   678     QVERIFY( VideoListWidgetData::mActive == true );
   642     QCOMPARE( VideoListWidgetData::mActivateCount, 1 );
   679     QCOMPARE( VideoListWidgetData::mActivateCount, 1 );
   643     QCOMPARE( VideoListWidgetData::mDeactivateCount, 0 );
   680     QCOMPARE( VideoListWidgetData::mDeactivateCount, 1 );
   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 
   681 
   663 	cleanup();
   682 	cleanup();
   664 }
   683 }
   665 // ---------------------------------------------------------------------------
   684 // ---------------------------------------------------------------------------
   666 // Slot: test open services	view slot
   685 // Slot: test open services	view slot
   667 // ---------------------------------------------------------------------------
   686 // ---------------------------------------------------------------------------
   668 //
   687 //
   669 void TestListView::testOpenServicesViewSlot()
   688 void TestListView::testOpenServicesViewSlot()
   670 {
   689 {
   671 	init();
   690     QFAIL("Feature not yet implemented!");
   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 }
   691 }
   682 
   692 
   683 // ---------------------------------------------------------------------------
   693 // ---------------------------------------------------------------------------
   684 // testStartSorting
   694 // testStartSorting
   685 // ---------------------------------------------------------------------------
   695 // ---------------------------------------------------------------------------
   686 //
   696 //
   687 void TestListView::testStartSortingSlot()
   697 void TestListView::testStartSortingSlot()
   688 {
   698 {
   689 	HbAction *action(0);
   699 	HbAction *action(0);
   690 
   700 	HbMenu *sortMenu(0);
   691 	// Active action is	not	sort by.
   701 	HbAction *sortMenuAction = new HbAction("test");
   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 
   702 
   721 	// View	is not initialized.
   703 	// View	is not initialized.
   722 	init(false);
   704 	init(false);
   723 	connect(this, SIGNAL(testSignal(int)), mTestView, SLOT(startSorting()));
   705 	connect(this, SIGNAL(testSignal(int)), mTestView, SLOT(startSorting()));
   724 	emit testSignal(0);
   706 	emit testSignal(0);
   725     QCOMPARE(VideoSortFilterProxyModelData::mDoSortingCallCount, 0);
   707     QCOMPARE(VideoSortFilterProxyModelData::mDoSortingCallCount, 0);
   726     QCOMPARE(VideoSortFilterProxyModelData::mSortRole, -1);
   708     QCOMPARE(VideoSortFilterProxyModelData::mSortRole, -1);
   727 	cleanup();
   709 	cleanup();
   728 
   710 
   729 	// Good	case.
   711     // View is not activated.
   730 	init();
   712     init();
   731 	action = mUiLoader->mMenuActions[VideoCollectionUiLoader::EActionSortBy];
   713     connect(this, SIGNAL(testSignal(int)), mTestView, SLOT(startSorting()));
       
   714     emit testSignal(0);
       
   715     QCOMPARE(VideoSortFilterProxyModelData::mDoSortingCallCount, 0);
       
   716     QCOMPARE(VideoSortFilterProxyModelData::mSortRole, -1);
       
   717     cleanup();
       
   718 
       
   719     // Active action is not sort by.
       
   720     init();
       
   721     mTestView->activateView(TMPXItemId::InvalidId());
       
   722     action = mUiLoader->findObject<HbAction>(DOCML_NAME_DELETE_MULTIPLE);
       
   723     QVERIFY(action != 0);
       
   724     mUiLoader->findWidget<HbMenu>(DOCML_NAME_OPTIONS_MENU)->setActiveAction(action);
       
   725     sortMenu = mUiLoader->findWidget<HbMenu>(DOCML_NAME_SORT_MENU);
       
   726     sortMenuAction->setMenu(sortMenu);
       
   727     HbMenuData::mMenuAction = sortMenuAction;
       
   728     connect(this, SIGNAL(testSignal(int)), mTestView, SLOT(startSorting()));
       
   729     emit testSignal(0);
       
   730     QCOMPARE(VideoSortFilterProxyModelData::mDoSortingCallCount, 0);
       
   731     QCOMPARE(VideoSortFilterProxyModelData::mSortRole, -1);
       
   732     cleanup();
       
   733 
       
   734 	// Good	cases.
       
   735 	init();
       
   736     mTestView->activateView(TMPXItemId::InvalidId());
       
   737     sortMenu = mUiLoader->findWidget<HbMenu>(DOCML_NAME_SORT_MENU);
       
   738     sortMenuAction->setMenu(sortMenu);
       
   739     HbMenuData::mMenuAction = sortMenuAction;
       
   740     VideoSortFilterProxyModel& model = mTestView->mCurrentList->getModel();
   732 	QVERIFY(action != 0);
   741 	QVERIFY(action != 0);
   733 	mUiLoader->findWidget<HbMenu>(DOCML_NAME_OPTIONS_MENU)->setActiveAction(action);
   742 	mUiLoader->findWidget<HbMenu>(DOCML_NAME_OPTIONS_MENU)->setActiveAction(sortMenuAction);
   734 	HbAction* sortAction = mUiLoader->mMenuActions[VideoCollectionUiLoader::EActionSortByName];
   743 	HbAction* sortAction = mUiLoader->findObject<HbAction>(DOCML_NAME_SORT_BY_NAME);
   735 	QVERIFY(sortAction != 0);
   744 	QVERIFY(sortAction != 0);
   736 	action->menu()->setActiveAction(sortAction);
   745 	sortMenu->setActiveAction(sortAction);
       
   746 	model.setSortRole(1);
       
   747 	connect(this, SIGNAL(testObjectReadySignal(QObject*, const QString)), mTestView, SLOT(objectReadySlot(QObject*, const QString)));
       
   748 	emit testObjectReadySignal(mUiLoader->findObject<QObject>(DOCML_NAME_SORT_BY_DATE), DOCML_NAME_SORT_BY_DATE);
       
   749     emit testObjectReadySignal(mUiLoader->findObject<QObject>(DOCML_NAME_SORT_BY_NAME), DOCML_NAME_SORT_BY_NAME);
       
   750     emit testObjectReadySignal(mUiLoader->findObject<QObject>(DOCML_NAME_SORT_BY_NUMBER_OF_ITEMS), DOCML_NAME_SORT_BY_NUMBER_OF_ITEMS);
       
   751     emit testObjectReadySignal(mUiLoader->findObject<QObject>(DOCML_NAME_SORT_BY_SIZE), DOCML_NAME_SORT_BY_SIZE);
       
   752     disconnect(this, SIGNAL(testObjectReadySignal(QObject*, const QString)), mTestView, SLOT(objectReadySlot(QObject*, const QString)));
   737 
   753 
   738 	connect(this, SIGNAL(testSignal(int)), mTestView, SLOT(startSorting()));
   754 	connect(this, SIGNAL(testSignal(int)), mTestView, SLOT(startSorting()));
   739 	emit testSignal(0);
   755 	emit testSignal(0);
   740 	QCOMPARE(VideoSortFilterProxyModelData::mDoSortingCallCount, 1);
   756 	QCOMPARE(VideoSortFilterProxyModelData::mDoSortingCallCount, 1);
   741 	QCOMPARE(VideoSortFilterProxyModelData::mSortRole, (int)Qt::DisplayRole);
   757 	QCOMPARE(VideoSortFilterProxyModelData::mSortRole, (int)VideoCollectionCommon::KeyTitle);
   742 	QCOMPARE(VideoSortFilterProxyModelData::mSortOrder, Qt::AscendingOrder);
   758 	QCOMPARE(VideoSortFilterProxyModelData::mSortOrder, Qt::AscendingOrder);
   743     QVERIFY(VideoSortFilterProxyModelData::mSortAsync);
   759     QVERIFY(VideoSortFilterProxyModelData::mSortAsync);
   744 
   760 
   745     // emit test signal again, with same parameters. Sorting should be switched to
   761     // emit test signal again, with same parameters. Sorting should be switched to
   746     // descending order.
   762     // descending order.
   747     emit testSignal(0);
   763     emit testSignal(0);
   748     QCOMPARE(VideoSortFilterProxyModelData::mDoSortingCallCount, 2);
   764     QCOMPARE(VideoSortFilterProxyModelData::mDoSortingCallCount, 2);
   749     QCOMPARE(VideoSortFilterProxyModelData::mSortRole, (int)Qt::DisplayRole);
   765     QCOMPARE(VideoSortFilterProxyModelData::mSortRole, (int)VideoCollectionCommon::KeyTitle);
   750     QCOMPARE(VideoSortFilterProxyModelData::mSortOrder, Qt::DescendingOrder);
   766     QCOMPARE(VideoSortFilterProxyModelData::mSortOrder, Qt::DescendingOrder);
   751     QVERIFY(VideoSortFilterProxyModelData::mSortAsync);
   767     QVERIFY(VideoSortFilterProxyModelData::mSortAsync);
   752 
   768 
   753     // on third emit, sorting should be switched back to ascending
   769     // on third emit, sorting should be switched back to ascending
   754     emit testSignal(0);
   770     emit testSignal(0);
   755     QCOMPARE(VideoSortFilterProxyModelData::mDoSortingCallCount, 3);
   771     QCOMPARE(VideoSortFilterProxyModelData::mDoSortingCallCount, 3);
   756     QCOMPARE(VideoSortFilterProxyModelData::mSortRole, (int)Qt::DisplayRole);
   772     QCOMPARE(VideoSortFilterProxyModelData::mSortRole, (int)VideoCollectionCommon::KeyTitle);
   757     QCOMPARE(VideoSortFilterProxyModelData::mSortOrder, Qt::AscendingOrder);
   773     QCOMPARE(VideoSortFilterProxyModelData::mSortOrder, Qt::AscendingOrder);
   758     QVERIFY(VideoSortFilterProxyModelData::mSortAsync);
   774     QVERIFY(VideoSortFilterProxyModelData::mSortAsync);
   759 
   775 
   760     // test that after changing the sort role, the order is also switched to ascending.
   776     // test that after changing the sort role, the order is also switched to ascending.
   761     VideoSortFilterProxyModelData::mSortOrder = Qt::DescendingOrder;
   777     model.doSorting(model.sortRole(), Qt::DescendingOrder);
   762     sortAction = mUiLoader->mMenuActions[VideoCollectionUiLoader::EActionSortByDate];
   778     sortAction = mUiLoader->findObject<HbAction>(DOCML_NAME_SORT_BY_DATE);
   763     QVERIFY(sortAction != 0);
   779     QVERIFY(sortAction != 0);
   764     action->menu()->setActiveAction(sortAction);
   780     sortMenu->setActiveAction(sortAction);
   765 
   781 
   766     emit testSignal(0);
   782     emit testSignal(0);
   767     QCOMPARE(VideoSortFilterProxyModelData::mDoSortingCallCount, 4);
   783     QCOMPARE(VideoSortFilterProxyModelData::mDoSortingCallCount, 5);
   768     QCOMPARE(VideoSortFilterProxyModelData::mSortRole, (int)VideoCollectionCommon::KeyDateTime);
   784     QCOMPARE(VideoSortFilterProxyModelData::mSortRole, (int)VideoCollectionCommon::KeyDateTime);
   769     QCOMPARE(VideoSortFilterProxyModelData::mSortOrder, Qt::AscendingOrder);
   785     QCOMPARE(VideoSortFilterProxyModelData::mSortOrder, Qt::AscendingOrder);
   770     QVERIFY(VideoSortFilterProxyModelData::mSortAsync);
   786     QVERIFY(VideoSortFilterProxyModelData::mSortAsync);
   771 
   787 
   772 	cleanup();
   788 	cleanup();
   809 void TestListView::testDeleteItemsSlot()
   825 void TestListView::testDeleteItemsSlot()
   810 {
   826 {
   811     init();
   827     init();
   812     connect( this, SIGNAL(testSignal()), mTestView, SLOT(deleteItemsSlot()) );
   828     connect( this, SIGNAL(testSignal()), mTestView, SLOT(deleteItemsSlot()) );
   813     ////////////
   829     ////////////
   814     // no model
   830     // no current list
   815     ////////////
   831     ////////////
   816     emit testSignal();
   832     emit testSignal();
   817     QVERIFY(VideoListSelectionDialogData::mMultiSelectionLaunchCount == 0);
   833     QCOMPARE(VideoListSelectionDialogData::mMultiSelectionLaunchCount, 0);
   818     QVERIFY(VideoListSelectionDialogData::mMultiSelectionItemSelectionCount == 0);
   834     
   819 
   835     mTestView->activateView(TMPXItemId::InvalidId());
   820     cleanup();
   836     
   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     ////////////
   837     ////////////
   836     // dialog loading fails
   838     // dialog loading fails
   837     ////////////
   839     ////////////
   838     VideoCollectionUiLoaderData::mFailDialogLoad = true;
   840     VideoCollectionUiLoaderData::mFailDialogLoad = true;
   839     emit testSignal();
   841     emit testSignal();
   840     QVERIFY(VideoListSelectionDialogData::mMultiSelectionLaunchCount == 0);
   842     QCOMPARE(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 
   843 
   850     ////////////
   844     ////////////
   851     // selection dialog exists
   845     // selection dialog exists
   852     ////////////
   846     ////////////
   853     emit testSignal();
   847     VideoCollectionUiLoaderData::mFailDialogLoad = false;
   854     QVERIFY(VideoListSelectionDialogData::mMultiSelectionLaunchCount == 1);
   848     VideoSortFilterProxyModelData::mOpenedItemId = TMPXItemId(2, 3);
   855     QVERIFY(VideoListSelectionDialogData::mMultiSelectionItemSelectionCount == 0);
   849     emit testSignal();
   856     emit testSignal();
   850     QCOMPARE(VideoListSelectionDialogData::mMultiSelectionLaunchCount, 1);
   857     QVERIFY(VideoListSelectionDialogData::mMultiSelectionLaunchCount == 2);
   851     QCOMPARE(VideoListSelectionDialogData::mSelectionType, (int)VideoListSelectionDialog::EDeleteVideos);
   858     QVERIFY(VideoListSelectionDialogData::mMultiSelectionItemSelectionCount == 0);
   852     QVERIFY(VideoListSelectionDialogData::mSettedMpxId == VideoSortFilterProxyModelData::mOpenedItemId);
   859 
   853     
   860     cleanup();
       
   861     init();
       
   862     connect( this, SIGNAL(testSignal()), mTestView, SLOT(deleteItemsSlot()) );
       
   863 
       
   864     ////////////
   854     ////////////
   865     // exec returns primary key (just for the coverity's sake)
   855     // test second successful activation.
   866     ////////////
   856     ////////////
   867     VideoListSelectionDialogData::mExecReturnPrimary = true;
   857     VideoSortFilterProxyModelData::mOpenedItemId = TMPXItemId(3, 2);
   868     VideoListSelectionDialogData::mSelectionCount = 5;
   858     emit testSignal();
   869     emit testSignal();
   859     QCOMPARE(VideoListSelectionDialogData::mMultiSelectionLaunchCount, 2);
   870     QVERIFY(VideoListSelectionDialogData::mMultiSelectionLaunchCount == 1);
   860     QCOMPARE(VideoListSelectionDialogData::mSelectionType, (int)VideoListSelectionDialog::EDeleteVideos);
   871     QVERIFY(VideoListSelectionDialogData::mMultiSelectionItemSelectionCount == 5);
   861     QVERIFY(VideoListSelectionDialogData::mSettedMpxId == VideoSortFilterProxyModelData::mOpenedItemId);
   872 
   862 
   873     cleanup();
   863     cleanup();
   874 }
   864 }
   875 
   865 
   876 // ---------------------------------------------------------------------------
   866 // ---------------------------------------------------------------------------
   877 // testAboutToShowMainMenuSlot
   867 // testAboutToShowMainMenuSlot
   878 // ---------------------------------------------------------------------------
   868 // ---------------------------------------------------------------------------
   879 //
   869 //
   880 void TestListView::testAboutToShowMainMenuSlot()
   870 void TestListView::testAboutToShowMainMenuSlot()
   881 {
   871 {
   882 	// All ok.
   872     XQServiceUtilXtra *serviceUtil = XQServiceUtilXtra::instance();
   883 	init();
   873     VideoServices *videoServices = VideoServices::instance();
   884 	setRowCount(1);
   874 
   885 	mUiLoader->findWidget<HbMenu>(DOCML_NAME_OPTIONS_MENU)->show();
   875     // View	is not initialized.
   886 	QVERIFY(visibleMenuActions() ==	6);
       
   887 	cleanup();
       
   888 
       
   889 	// View	is not initialized.
       
   890 	init(false);
   876 	init(false);
   891 	connect( this, SIGNAL(testSignal(int)),	mTestView, SLOT(aboutToShowMainMenuSlot()) );
   877 	connect( this, SIGNAL(testSignal(int)),	mTestView, SLOT(aboutToShowMainMenuSlot()) );
   892 	emit testSignal(0);
   878 	emit testSignal(0);
   893 	cleanup();
   879 	cleanup();
   894 
   880 
   895 	HbAction *action(0);
   881 	HbAction *action(0);
   896 
   882 
   897 	// Collections is triggered	from toolbar.
   883 	// Collections is triggered	from toolbar.
   898 	init();
   884 	init();
       
   885 	connect(this, SIGNAL(testSignal()), mTestView, SLOT(aboutToShowMainMenuSlot()));
       
   886 	mTestView->activateView(TMPXItemId::InvalidId());
   899 	setRowCount(1);
   887 	setRowCount(1);
   900 	action = mTestView->mToolbarActions[VideoListView::ETBActionCollections];
   888 	action = mTestView->mToolbarActions[VideoListView::ETBActionCollections];
   901 	QVERIFY(action != 0);
   889 	QVERIFY(action != 0);
   902 	action->setChecked(false);
   890 	action->setChecked(false);
   903 	action->trigger();
   891 	action->trigger();
   904 	mUiLoader->findWidget<HbMenu>(DOCML_NAME_OPTIONS_MENU)->show();
   892 	emit testSignal();
   905 	int visible = visibleMenuActions();
   893 	int visible = visibleMenuActions();
   906 	QCOMPARE(visible,	5);
   894 	QCOMPARE(visible, 3);
   907 	cleanup();
   895 	cleanup();
   908 
   896 
   909 	// All videos is triggered from	toolbar.
   897 	// All videos is triggered from	toolbar.
   910 	init();
   898 	init();
       
   899     connect(this, SIGNAL(testSignal()), mTestView, SLOT(aboutToShowMainMenuSlot()));
       
   900     mTestView->activateView(TMPXItemId::InvalidId());
   911     setRowCount(1);
   901     setRowCount(1);
   912 	action = mTestView->mToolbarActions[VideoListView::ETBActionAllVideos];
   902 	action = mTestView->mToolbarActions[VideoListView::ETBActionAllVideos];
   913 	QVERIFY(action != 0);
   903 	QVERIFY(action != 0);
   914 	action->setChecked(false);
   904 	action->setChecked(false);
   915 	action->trigger();
   905 	action->trigger();
   916 	mUiLoader->findWidget<HbMenu>(DOCML_NAME_OPTIONS_MENU)->show();
   906     emit testSignal();
   917 	visible = visibleMenuActions();
   907 	visible = visibleMenuActions();
   918 	QCOMPARE(visible,	6);
   908 	QCOMPARE(visible, 5);
   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();
   909 	cleanup();
   932 
   910 
   933 	// Add videos action is	visible.
   911 	// Add videos action is	visible.
   934 	init();
   912 	init();
   935     mTestView->activateView();
   913     connect(this, SIGNAL(testSignal()), mTestView, SLOT(aboutToShowMainMenuSlot()));
       
   914     mTestView->activateView(TMPXItemId::InvalidId());
   936 	mTestView->toolBar()->clearActions();
   915 	mTestView->toolBar()->clearActions();
   937 	mTestView->toolBar()->addActions( mTestView->mToolbarCollectionActionGroup->actions() );
   916 	mTestView->toolBar()->addActions( mTestView->mToolbarCollectionActionGroup->actions() );
   938 	setRowCount(1);
   917 	setRowCount(1);
   939 	QVERIFY(action != 0);
   918 	QVERIFY(action != 0);
   940 	mUiLoader->findWidget<HbMenu>(DOCML_NAME_OPTIONS_MENU)->show();
   919     emit testSignal();
   941 	visible = visibleMenuActions();
   920 	visible = visibleMenuActions();
   942 	QCOMPARE(visible,	1);
   921 	QCOMPARE(visible, 4);
   943 	cleanup();
   922 	cleanup();
   944 
   923 
   945 	// Menu	action is null
   924 	// Model has no	items.
   946 	init();
   925 	init();
   947     setRowCount(1);
   926     connect(this, SIGNAL(testSignal()), mTestView, SLOT(aboutToShowMainMenuSlot()));
   948 	action = mUiLoader->mMenuActions.take(VideoCollectionUiLoader::EActionSortBy);
   927     mTestView->activateView(TMPXItemId::InvalidId());
   949 	delete action;
   928 	setRowCount(0);
   950 	action = NULL;
   929     emit testSignal();
   951 	mUiLoader->mMenuActions[VideoCollectionUiLoader::EActionSortBy] =	action;
       
   952 	mUiLoader->findWidget<HbMenu>(DOCML_NAME_OPTIONS_MENU)->show();
       
   953 	visible = visibleMenuActions();
   930 	visible = visibleMenuActions();
   954 	QCOMPARE(visible,	0);
   931 	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();
   932 	cleanup();
   974 
   933 
   975 	// Toolbar action group	is null
   934 	// Toolbar action group	is null
   976 	init();
   935 	init();
       
   936     connect(this, SIGNAL(testSignal()), mTestView, SLOT(aboutToShowMainMenuSlot()));
       
   937     mTestView->activateView(TMPXItemId::InvalidId());
   977 	setRowCount(1);
   938 	setRowCount(1);
   978 	QActionGroup* actionGroup =	mTestView->mToolbarViewsActionGroup;
   939 	QActionGroup* actionGroup =	mTestView->mToolbarViewsActionGroup;
   979 	mTestView->mToolbarViewsActionGroup = NULL;
   940 	mTestView->mToolbarViewsActionGroup = NULL;
   980 	mUiLoader->findWidget<HbMenu>(DOCML_NAME_OPTIONS_MENU)->show();
   941     emit testSignal();
   981 	mTestView->mToolbarViewsActionGroup = actionGroup;
   942 	mTestView->mToolbarViewsActionGroup = actionGroup;
   982 	cleanup();
   943 	cleanup();
   983 }
   944 	
   984 
   945 	// about to show main menu:
   985 // ---------------------------------------------------------------------------
   946 	// -is service
   986 // testOpenSortByMenuSlot
   947 	// -current service is browse
   987 // ---------------------------------------------------------------------------
   948 	// -no current list
   988 //
   949     serviceUtil->setCurrentService(true);
   989 void TestListView::testOpenSortByMenuSlot()
   950     videoServices->mCurrentService = VideoServices::EBrowse;
   990 {
   951     init(true);
   991     HbMenu *optionsMenu = 0;
   952     connect(this, SIGNAL(testSignal()), mTestView, SLOT(aboutToShowMainMenuSlot()));
   992     HbMenu *sortMenu = 0;
   953     emit testSignal();
   993 
   954     visible = visibleMenuActions();
   994     // All ok.
   955     QCOMPARE(visible, 0);
   995     init();
   956     cleanup();
   996     sortMenu = mUiLoader->findWidget<HbMenu>(DOCML_NAME_SORT_MENU);
   957 
   997     connect( this, SIGNAL(testSignal(int)), mTestView, SLOT(openSortByMenuSlot()) );
   958     // about to show main menu:
   998     setRowCount(1);
   959     // -is service
   999     mUiLoader->findWidget<HbMenu>(DOCML_NAME_OPTIONS_MENU)->hide();
   960     // -current service is browse
  1000     emit testSignal(0);
   961     // -no items
  1001     // sorting menu should be visible
   962     serviceUtil->setCurrentService(true);
  1002     QVERIFY(visibleMenuActions() == 4);
   963     videoServices->mCurrentService = VideoServices::EBrowse;
  1003     cleanup();
   964     init(true);
  1004 
   965     connect(this, SIGNAL(testSignal()), mTestView, SLOT(aboutToShowMainMenuSlot()));
  1005     // View is not initialized.
   966     mTestView->activateView(TMPXItemId::InvalidId());
  1006     init(false);
   967     emit testSignal();
  1007     sortMenu = mUiLoader->findWidget<HbMenu>(DOCML_NAME_SORT_MENU);
   968     visible = visibleMenuActions();
  1008     optionsMenu = mUiLoader->findWidget<HbMenu>(DOCML_NAME_OPTIONS_MENU);
   969     QCOMPARE(visible, 0);
  1009     connect( this, SIGNAL(testSignal(int)), mTestView, SLOT(openSortByMenuSlot()) );
   970     cleanup();
  1010     setRowCount(1);
   971 
  1011     optionsMenu->hide();
   972     // about to show main menu:
  1012     emit testSignal(0);
   973     // -is service
  1013     QCOMPARE(visibleMenuActions(),   0);
   974     // -current service is browse
  1014     cleanup();
   975     serviceUtil->setCurrentService(true);
  1015 
   976     videoServices->mCurrentService = VideoServices::EBrowse;
  1016     // no items
   977 	init(true);
  1017     init();
   978 	connect(this, SIGNAL(testSignal()), mTestView, SLOT(aboutToShowMainMenuSlot()));
  1018     sortMenu = mUiLoader->findWidget<HbMenu>(DOCML_NAME_SORT_MENU);
   979     mTestView->activateView(TMPXItemId::InvalidId());
  1019     optionsMenu = mUiLoader->findWidget<HbMenu>(DOCML_NAME_OPTIONS_MENU);
   980     setRowCount(3, &mTestView->mCurrentList->getModel());
  1020     connect( this, SIGNAL(testSignal(int)), mTestView, SLOT(openSortByMenuSlot()) );
   981     emit testSignal();
  1021     setRowCount(0);
   982     QVERIFY(isActionVisible(DOCML_NAME_DELETE_MULTIPLE));
  1022     mUiLoader->findWidget<HbMenu>(DOCML_NAME_OPTIONS_MENU)->hide();
   983     QVERIFY(isActionVisible(DOCML_NAME_SORT_BY_DATE));
  1023     emit testSignal(0);
   984     QVERIFY(isActionVisible(DOCML_NAME_SORT_BY_NAME));
  1024     QCOMPARE(visibleMenuActions(),   0);
   985     QVERIFY(isActionVisible(DOCML_NAME_SORT_BY_SIZE));
  1025     cleanup();
   986 	cleanup();
       
   987 
       
   988 	// final cleanup
       
   989     serviceUtil->decreaseReferenceCount();
       
   990     videoServices->decreaseReferenceCount();
  1026 }
   991 }
  1027 
   992 
  1028 // ---------------------------------------------------------------------------
   993 // ---------------------------------------------------------------------------
  1029 // testHandleErrorSlot
   994 // testHandleErrorSlot
  1030 // ---------------------------------------------------------------------------
   995 // ---------------------------------------------------------------------------
  1075 // testCollectionOpenedSlot
  1040 // testCollectionOpenedSlot
  1076 // ---------------------------------------------------------------------------
  1041 // ---------------------------------------------------------------------------
  1077 //
  1042 //
  1078 void TestListView::testCollectionOpenedSlot()
  1043 void TestListView::testCollectionOpenedSlot()
  1079 {
  1044 {
  1080 	HbAction* removeVideosAction;
       
  1081 	HbAction* allVideosAction;
       
  1082 	HbAction* collectionsAction;
       
  1083 	HbAction* servicesAction;
       
  1084 	HbAction* addVideosAction;
       
  1085 	HbAction* sortVideosAction;
       
  1086 
       
  1087 	QString testString;
  1045 	QString testString;
  1088 
  1046 
  1089 	// View	is not initialized.
  1047 	// View	is not initialized.
  1090 	init(false);
  1048 	init(false);
  1091 	connect(this, SIGNAL(testCollectionOpenedSignal(bool, const QString&)),	mTestView, SLOT(collectionOpenedSlot(bool, const QString&)));
  1049 	connect(this, SIGNAL(testCollectionOpenedSignal(bool, const QString&, const QModelIndex&)),
  1092 	emit testCollectionOpenedSignal(false, testString);
  1050 	    mTestView, SLOT(collectionOpenedSlot(bool, const QString&, const QModelIndex&)));
       
  1051 	emit testCollectionOpenedSignal(false, testString, QModelIndex());
  1093 	cleanup();
  1052 	cleanup();
  1094 
  1053 
  1095 	// No toolbar actions.
  1054 	// No toolbar actions.
  1096 	init(true);
  1055 	init(true);
       
  1056 	mUiLoader->findWidget<VideoListWidget>(DOCML_NAME_VC_COLLECTIONWIDGET); // load model
       
  1057 	QModelIndex index = VideoCollectionWrapperData::mCollectionsModel->index(0, 0);
  1097 	// Clear actions.
  1058 	// Clear actions.
  1098 	QMap<VideoListView::TViewActionIds,	HbAction*> backupActions =
  1059 	QMap<VideoListView::TViewActionIds,	HbAction*> backupActions =
  1099 		QMap<VideoListView::TViewActionIds,	HbAction*>(mTestView->mToolbarActions);
  1060 		QMap<VideoListView::TViewActionIds,	HbAction*>(mTestView->mToolbarActions);
  1100 	mTestView->mToolbarActions.clear();
  1061 	mTestView->mToolbarActions.clear();
  1101 	connect(this, SIGNAL(testCollectionOpenedSignal(bool, const QString&)),	mTestView, SLOT(collectionOpenedSlot(bool, const QString&)));
  1062 	connect(this, SIGNAL(testCollectionOpenedSignal(bool, const QString&, const QModelIndex&)), 
  1102 	emit testCollectionOpenedSignal(true, testString);
  1063 	    mTestView, SLOT(collectionOpenedSlot(bool, const QString&, const QModelIndex&)));
       
  1064 	emit testCollectionOpenedSignal(true, testString, index);
  1103 	mTestView->mToolbarActions.unite(backupActions);
  1065 	mTestView->mToolbarActions.unite(backupActions);
  1104 	cleanup();
  1066 	cleanup();
  1105 
  1067 
  1106 	// One of the toolbar actions is null.
  1068 	// index is invalid
  1107 	init();
  1069 	init();
  1108 	removeVideosAction = mTestView->mToolbarActions[VideoListView::ETBActionRemoveVideos];
  1070 	cleanup();
  1109 	mTestView->mToolbarActions[VideoListView::ETBActionRemoveVideos] = NULL;
  1071 	
  1110 	connect(this, SIGNAL(testCollectionOpenedSignal(bool, const QString&)),	mTestView, SLOT(collectionOpenedSlot(bool, const QString&)));
  1072 	// current list is null
  1111 	emit testCollectionOpenedSignal(true, testString);
  1073 	init();
       
  1074 	cleanup();
       
  1075 	
       
  1076 	// current list is collectioncontentwidget
       
  1077 	init();
       
  1078 	cleanup();
       
  1079 	
       
  1080 	// index is for video item and not for collection.
       
  1081 	init();
       
  1082 	cleanup();
       
  1083 	
       
  1084 	// non-error cases:
       
  1085 	testString = "Test text string";
       
  1086 
       
  1087 	// Collection opened with default collection.
       
  1088 	init();
       
  1089     mTestView->mCurrentList = mUiLoader->findWidget<VideoListWidget>(DOCML_NAME_VC_COLLECTIONWIDGET);
       
  1090     index = VideoCollectionWrapperData::mCollectionsModel->index(0, 0);
       
  1091 	connect(this, SIGNAL(testCollectionOpenedSignal(bool, const QString&, const QModelIndex&)), 
       
  1092 	    mTestView, SLOT(collectionOpenedSlot(bool, const QString&, const QModelIndex&)));
       
  1093 	emit testCollectionOpenedSignal(true, testString, index);
  1112 	// Verify checkable	and	visible	toolbar	actions.
  1094 	// Verify checkable	and	visible	toolbar	actions.
  1113 	mTestView->mToolbarActions[VideoListView::ETBActionRemoveVideos] = removeVideosAction;
  1095 	cleanup();
  1114 	allVideosAction	= mTestView->mToolbarActions[VideoListView::ETBActionAllVideos];
  1096 	
  1115 	collectionsAction =	mTestView->mToolbarActions[VideoListView::ETBActionCollections];
  1097 	// Collection opened with userdefined album.
  1116 	servicesAction = mTestView->mToolbarActions[VideoListView::ETBActionServices];
  1098 	init();
  1117 	addVideosAction	= mTestView->mToolbarActions[VideoListView::ETBActionAddVideos];
  1099 	cleanup();
  1118 	sortVideosAction = mTestView->mToolbarActions[VideoListView::ETBActionSortVideos];
  1100 	
  1119 	// Remove videos is	not	checked	because	it was used	as null	action.
  1101 	// Collection closed.
  1120 	QCOMPARE( mTestView->mCollectionName, testString );
  1102 	init();
  1121 	QCOMPARE( mTestView->toolBar()->actions().count(), 3 );
  1103 	connect(this, SIGNAL(testCollectionOpenedSignal(bool, const QString&, const QModelIndex&)), 
  1122 	QVERIFY( allVideosAction !=	0 && allVideosAction->isCheckable());
  1104 	    mTestView, SLOT(collectionOpenedSlot(bool, const QString&, const QModelIndex&)));
  1123 	QVERIFY( collectionsAction != 0	&& collectionsAction->isCheckable());
  1105 	emit testCollectionOpenedSignal(false, testString, QModelIndex());
  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&)));
       
  1135 	emit testCollectionOpenedSignal(true, testString);
       
  1136 	// Verify checkable	and	visible	toolbar	actions.
       
  1137 	allVideosAction	= mTestView->mToolbarActions[VideoListView::ETBActionAllVideos];
       
  1138 	collectionsAction =	mTestView->mToolbarActions[VideoListView::ETBActionCollections];
       
  1139 	servicesAction = mTestView->mToolbarActions[VideoListView::ETBActionServices];
       
  1140 	addVideosAction	= mTestView->mToolbarActions[VideoListView::ETBActionAddVideos];
       
  1141 	removeVideosAction = mTestView->mToolbarActions[VideoListView::ETBActionRemoveVideos];
       
  1142 	sortVideosAction = mTestView->mToolbarActions[VideoListView::ETBActionSortVideos];
       
  1143 	QCOMPARE(mTestView->mCollectionName, testString);
       
  1144 	QCOMPARE( mTestView->toolBar()->actions().count(), 3 );
       
  1145 	QVERIFY( allVideosAction !=	0 && allVideosAction->isCheckable());
       
  1146 	QVERIFY( collectionsAction != 0	&& collectionsAction->isCheckable());
       
  1147 	QVERIFY( servicesAction	!= 0 &&	servicesAction->isCheckable());
       
  1148 	QVERIFY( addVideosAction !=	0 && !addVideosAction->isCheckable() );
       
  1149 	QVERIFY( removeVideosAction	!= 0 &&	!removeVideosAction->isCheckable() );
       
  1150 	QVERIFY( sortVideosAction != 0 && !sortVideosAction->isCheckable() );
       
  1151 	cleanup();
       
  1152 
       
  1153 	testString = "Test text string 2";
       
  1154 
       
  1155 	// Collection not opened.
       
  1156 	init();
       
  1157 	connect(this, SIGNAL(testCollectionOpenedSignal(bool, const QString&)),	mTestView, SLOT(collectionOpenedSlot(bool, const QString&)));
       
  1158 	emit testCollectionOpenedSignal(false, testString);
       
  1159 	// Verify checkable	and	visible	toolbar	actions.
       
  1160 	allVideosAction	= mTestView->mToolbarActions[VideoListView::ETBActionAllVideos];
       
  1161 	collectionsAction =	mTestView->mToolbarActions[VideoListView::ETBActionCollections];
       
  1162 	servicesAction = mTestView->mToolbarActions[VideoListView::ETBActionServices];
       
  1163 	addVideosAction	= mTestView->mToolbarActions[VideoListView::ETBActionAddVideos];
       
  1164 	removeVideosAction = mTestView->mToolbarActions[VideoListView::ETBActionRemoveVideos];
       
  1165 	sortVideosAction = mTestView->mToolbarActions[VideoListView::ETBActionSortVideos];
       
  1166 	QCOMPARE(mTestView->mCollectionName, testString);
       
  1167 	QCOMPARE( mTestView->toolBar()->actions().count(), 3 );
       
  1168 	QVERIFY( allVideosAction !=	0 && allVideosAction->isCheckable());
       
  1169 	QVERIFY( collectionsAction != 0	&& collectionsAction->isCheckable());
       
  1170 	QVERIFY( servicesAction	!= 0 &&	servicesAction->isCheckable());
       
  1171 	QVERIFY( addVideosAction !=	0 && !addVideosAction->isCheckable() );
       
  1172 	QVERIFY( removeVideosAction	!= 0 &&	!removeVideosAction->isCheckable() );
       
  1173 	QVERIFY( sortVideosAction != 0 && !sortVideosAction->isCheckable() );
       
  1174 	cleanup();
  1106 	cleanup();
  1175 }
  1107 }
  1176 
  1108 
  1177 // ---------------------------------------------------------------------------
  1109 // ---------------------------------------------------------------------------
  1178 // testUpdateSubLabel
  1110 // testUpdateSubLabel
  1181 void TestListView::testUpdateSubLabel()
  1113 void TestListView::testUpdateSubLabel()
  1182 {
  1114 {
  1183 	init(true);
  1115 	init(true);
  1184     setRowCount(1);
  1116     setRowCount(1);
  1185 	connect(this, SIGNAL(testLayoutChangedSignal()), mTestView, SLOT(layoutChangedSlot()));
  1117 	connect(this, SIGNAL(testLayoutChangedSignal()), mTestView, SLOT(layoutChangedSlot()));
  1186 	connect(this, SIGNAL(testCollectionOpenedSignal(bool, const QString&)), mTestView, SLOT(collectionOpenedSlot(bool, const QString&)));
  1118 	connect(this, SIGNAL(testCollectionOpenedSignal(bool, const QString&, const QModelIndex&)), 
       
  1119 	    mTestView, SLOT(collectionOpenedSlot(bool, const QString&, const QModelIndex&)));
  1187 
  1120 
  1188     VideoListWidget *videoListWidget = mUiLoader->findWidget<VideoListWidget>(DOCML_NAME_VC_VIDEOLISTWIDGET);   
  1121     VideoListWidget *videoListWidget = mUiLoader->findWidget<VideoListWidget>(DOCML_NAME_VC_VIDEOLISTWIDGET);   
  1189     VideoListWidget *collectionWidget = mUiLoader->findWidget<VideoListWidget>(DOCML_NAME_VC_COLLECTIONWIDGET);   
  1122     VideoListWidget *collectionWidget = mUiLoader->findWidget<VideoListWidget>(DOCML_NAME_VC_COLLECTIONWIDGET);   
  1190     VideoListWidget *collectionContentWidget = mUiLoader->findWidget<VideoListWidget>(DOCML_NAME_VC_COLLECTIONCONTENTWIDGET);   
  1123     VideoListWidget *collectionContentWidget = mUiLoader->findWidget<VideoListWidget>(DOCML_NAME_VC_COLLECTIONCONTENTWIDGET);   
  1191 	
  1124 	
       
  1125     videoListWidget->mCurrentLevel = VideoCollectionCommon::ELevelVideos;
       
  1126     collectionWidget->mCurrentLevel = VideoCollectionCommon::ELevelCategory;
       
  1127     collectionContentWidget->mCurrentLevel = VideoCollectionCommon::ELevelAlbum;
       
  1128     
       
  1129     HbGroupBox* label = mUiLoader->findWidget<HbGroupBox>(DOCML_NAME_VC_HEADINGBANNER);
       
  1130     
  1192 	mTestView->mCurrentList = videoListWidget; 
  1131 	mTestView->mCurrentList = videoListWidget; 
  1193 	mTestView->mCurrentList->mCurrentLevel = VideoCollectionCommon::ELevelVideos;
       
  1194 	emit testLayoutChangedSignal();
  1132 	emit testLayoutChangedSignal();
  1195 	HbGroupBox* label = mUiLoader->findWidget<HbGroupBox>(DOCML_NAME_VC_HEADINGBANNER);
  1133 	QCOMPARE( label->heading(), QString("txt_videos_subtitle_ln_videos") );
  1196 	QString returnString = label->heading();
  1134 
  1197 	QString expectedString = "txt_videos_subtitle_ln_videos";
  1135     mTestView->mCurrentList = collectionWidget; 
  1198 	QCOMPARE(returnString, expectedString);
       
  1199 
       
  1200     mTestView->mCurrentList = 0; 
       
  1201     mTestView->mCurrentList->mCurrentLevel = VideoCollectionCommon::ELevelVideos;
       
  1202 	emit testLayoutChangedSignal();
  1136 	emit testLayoutChangedSignal();
  1203 	returnString = label->heading();
  1137     QCOMPARE( label->heading(), QString("txt_videos_subtitle_ln_collections") );
  1204 	expectedString = "txt_videos_subtitle_ln_videos";
  1138 
  1205 	QCOMPARE(returnString, expectedString);
  1139     mTestView->mCurrentList = collectionContentWidget; 
  1206 
       
  1207     mTestView->mCurrentList = collectionWidget; 
       
  1208     mTestView->mCurrentList->mCurrentLevel = VideoCollectionCommon::ELevelCategory;
       
  1209 	emit testLayoutChangedSignal();
  1140 	emit testLayoutChangedSignal();
  1210 	returnString = label->heading();
  1141     QCOMPARE( label->heading(), QString("txt_videos_subtitle_1_l2") );
  1211 	expectedString = "txt_videos_subtitle_l1_collections";
  1142 
  1212 	QCOMPARE(returnString, expectedString);
  1143     // how to test the collection name?
  1213 
       
  1214     mTestView->mCurrentList = 0; 
       
  1215     mTestView->mCurrentList->mCurrentLevel = VideoCollectionCommon::ELevelVideos;
       
  1216 	emit testLayoutChangedSignal();
       
  1217 	returnString = label->heading();
       
  1218 	expectedString = "txt_videos_subtitle_l1_collections";
       
  1219 	QCOMPARE(returnString, expectedString);
       
  1220 
       
  1221     mTestView->mCurrentList = collectionContentWidget; 
       
  1222     mTestView->mCurrentList->mCurrentLevel = VideoCollectionCommon::ELevelAlbum;
       
  1223 	emit testLayoutChangedSignal();
       
  1224 	returnString = label->heading();
       
  1225 	expectedString = "txt_videos_subtitle_1_l2";
       
  1226 	QCOMPARE(returnString, expectedString);
       
  1227 
       
  1228     mTestView->mCurrentList = 0; 
       
  1229     mTestView->mCurrentList->mCurrentLevel = VideoCollectionCommon::ELevelVideos;
       
  1230 	expectedString = "txt_videos_subtitle_1_l2";
       
  1231 	emit testLayoutChangedSignal();
       
  1232 	returnString = label->heading();
       
  1233 	QCOMPARE(returnString, expectedString);
       
  1234 	
  1144 	
  1235     mTestView->mCurrentList = collectionContentWidget; 
  1145 	cleanup();
  1236     mTestView->mCurrentList->mCurrentLevel = VideoCollectionCommon::ELevelAlbum;
       
  1237 	emit testCollectionOpenedSignal(true, QString("NAME"));
       
  1238 	emit testLayoutChangedSignal();
       
  1239 	returnString = label->heading();
       
  1240 	expectedString = "txt_videos_subtitle_1_l2";
       
  1241 	QCOMPARE(returnString, expectedString);
       
  1242 }
  1146 }
  1243 
  1147 
  1244 // ---------------------------------------------------------------------------
  1148 // ---------------------------------------------------------------------------
  1245 // testShowHint
  1149 // testShowHint
  1246 // ---------------------------------------------------------------------------
  1150 // ---------------------------------------------------------------------------
  1247 //
  1151 //
  1248 void TestListView::testShowHint()
  1152 void TestListView::testShowHint()
  1249 {
  1153 {
  1250     VideoHintWidget *hintWidget = 0;
       
  1251     
       
  1252     init(true);
  1154     init(true);
  1253     connect(this, SIGNAL(testLayoutChangedSignal()), mTestView, SLOT(layoutChangedSlot()));
  1155     connect(this, SIGNAL(testLayoutChangedSignal()), mTestView, SLOT(layoutChangedSlot()));
  1254     
  1156     mTestView->mModelReady = true;
  1255     setRowCount(1);    
  1157     
  1256     hintWidget = mUiLoader->findWidget<VideoHintWidget>(DOCML_NAME_VC_VIDEOHINTWIDGET);    
  1158     // current list is null. (cannot be verified, run for coverity    
       
  1159     emit testLayoutChangedSignal();   
       
  1160     mTestView->activateView(TMPXItemId::InvalidId());
       
  1161   
       
  1162     // hint widget cannot be loaded. (cannot be tested, run for coverity)
       
  1163     VideoCollectionUiLoaderData::mFindFailureNameList.append(DOCML_NAME_VC_VIDEOHINTWIDGET);
       
  1164     emit testLayoutChangedSignal();
       
  1165     VideoCollectionUiLoaderData::mFindFailureNameList.clear();
       
  1166     
       
  1167     VideoHintWidget *hintWidget = mUiLoader->findWidget<VideoHintWidget>(DOCML_NAME_VC_VIDEOHINTWIDGET);    
       
  1168     
       
  1169     /////
       
  1170     // hint widget showing
       
  1171     // model not ready (need to use another slot for this)
  1257     mTestView->mModelReady = false;
  1172     mTestView->mModelReady = false;
  1258     hintWidget->setVisible(true);    
  1173     mTestView->mCurrentList =  mUiLoader->findWidget<VideoListWidget>(DOCML_NAME_VC_COLLECTIONWIDGET);
       
  1174     connect(this, SIGNAL(testSignal()), mTestView, SLOT(openAllVideosViewSlot()));
       
  1175     emit testSignal();
       
  1176     QVERIFY(hintWidget->isVisible() == false );
       
  1177     QVERIFY(VideoHintWidgetData::mSettedButtonShowLevel);
       
  1178     disconnect(this, SIGNAL(testSignal()), mTestView, SLOT(openAllVideosViewSlot()));
       
  1179     
       
  1180     // model ready, row count not zero
       
  1181     mTestView->mModelReady = true;
       
  1182     setRowCount(1);
       
  1183     emit testLayoutChangedSignal();    
       
  1184     QVERIFY(hintWidget->isVisible() == false );
       
  1185     QVERIFY(VideoHintWidgetData::mSettedButtonShowLevel);
       
  1186 
       
  1187     // model ready, row count is zero
       
  1188     setRowCount(0);
       
  1189     emit testLayoutChangedSignal();    
       
  1190     QVERIFY(hintWidget->isVisible() == true );
       
  1191     QVERIFY(VideoHintWidgetData::mSettedButtonShowLevel);
       
  1192 
       
  1193     // model ready, row count is zero show to be false
       
  1194     connect(this, SIGNAL(testSignal()), mTestView, SLOT(openCollectionViewSlot()));
       
  1195     emit testSignal();
       
  1196     QVERIFY(hintWidget->isVisible() == false );
       
  1197     QVERIFY(VideoHintWidgetData::mSettedButtonShowLevel);
       
  1198     disconnect(this, SIGNAL(testSignal()), mTestView, SLOT(openCollectionViewSlot()));
       
  1199    
       
  1200     mTestView->mCurrentList =  mUiLoader->findWidget<VideoListWidget>(DOCML_NAME_VC_VIDEOLISTWIDGET);
       
  1201     
       
  1202     ////////
       
  1203     // toolbar setup
       
  1204     mTestView->mToolbarActions[VideoListView::ETBActionRemoveVideos]->setVisible(true);
       
  1205     mTestView->mToolbarActions[VideoListView::ETBActionAddVideos]->setVisible(true);
       
  1206     // mToolbarViewsActionGroup is null
       
  1207     QActionGroup *tmp = mTestView->mToolbarViewsActionGroup;
       
  1208     mTestView->mToolbarViewsActionGroup = 0;
       
  1209     emit testLayoutChangedSignal();    
       
  1210     QVERIFY(mTestView->mToolbarActions[VideoListView::ETBActionRemoveVideos]->isVisible());
       
  1211     QVERIFY(mTestView->mToolbarActions[VideoListView::ETBActionAddVideos]->isVisible());
       
  1212     mTestView->mToolbarViewsActionGroup = tmp;
       
  1213     
       
  1214     //  mToolbarCollectionActionGroup is null
       
  1215     tmp = mTestView->mToolbarCollectionActionGroup;
       
  1216     mTestView->mToolbarCollectionActionGroup = 0;
       
  1217     emit testLayoutChangedSignal();    
       
  1218     QVERIFY(mTestView->mToolbarActions[VideoListView::ETBActionRemoveVideos]->isVisible());
       
  1219     QVERIFY(mTestView->mToolbarActions[VideoListView::ETBActionAddVideos]->isVisible());
       
  1220     mTestView->mToolbarCollectionActionGroup = tmp;
       
  1221     
       
  1222     // mIsService is true
       
  1223     mTestView->mIsService = true;
       
  1224     emit testLayoutChangedSignal();    
       
  1225     QVERIFY(mTestView->mToolbarActions[VideoListView::ETBActionRemoveVideos]->isVisible());
       
  1226     QVERIFY(mTestView->mToolbarActions[VideoListView::ETBActionAddVideos]->isVisible());
       
  1227     mTestView->mIsService = false;
       
  1228     
       
  1229     // show -flag is true, currentlist level != VideoCollectionCommon::ELevelDefaultColl
       
  1230     mTestView->mCurrentList->activate(VideoCollectionCommon::ELevelAlbum);
       
  1231     emit testLayoutChangedSignal();    
       
  1232     QVERIFY(!mTestView->mToolbarActions[VideoListView::ETBActionRemoveVideos]->isVisible());
       
  1233     QVERIFY(mTestView->mToolbarActions[VideoListView::ETBActionAddVideos]->isVisible());
       
  1234     
       
  1235     mTestView->mToolbarActions[VideoListView::ETBActionRemoveVideos]->setVisible(true);
       
  1236     // show -flag is true, currentlist level == VideoCollectionCommon::ELevelDefaultColl
       
  1237     mTestView->mCurrentList->activate(VideoCollectionCommon::ELevelDefaultColl);
       
  1238     emit testLayoutChangedSignal();    
       
  1239     QVERIFY(!mTestView->mToolbarActions[VideoListView::ETBActionRemoveVideos]->isVisible());
       
  1240     QVERIFY(!mTestView->mToolbarActions[VideoListView::ETBActionAddVideos]->isVisible());
       
  1241        
       
  1242     // show -flag is false
       
  1243     setRowCount(1);
       
  1244     emit testLayoutChangedSignal();   
       
  1245     QVERIFY(mTestView->mToolbarActions[VideoListView::ETBActionRemoveVideos]->isVisible());
       
  1246     QVERIFY(mTestView->mToolbarActions[VideoListView::ETBActionAddVideos]->isVisible());
       
  1247     
       
  1248     ///////
       
  1249     // sub label
       
  1250     
       
  1251     // sub label cannot be found (cannot be verified, run for coverity)
       
  1252     VideoCollectionUiLoaderData::mFindFailureNameList.append(DOCML_NAME_VC_HEADINGBANNER);
  1259     emit testLayoutChangedSignal();
  1253     emit testLayoutChangedSignal();
  1260     QVERIFY(hintWidget->isVisible());
  1254     VideoCollectionUiLoaderData::mFindFailureNameList.clear();
  1261     
  1255     
  1262     VideoSortFilterProxyModel* model = mTestView->mCurrentList->mModel;
  1256     HbGroupBox *subLabel =
  1263     mTestView->mCurrentList->mModel = 0;
  1257             mUiLoader->findWidget<HbGroupBox>(
  1264     mTestView->mModelReady = true;    
  1258                 DOCML_NAME_VC_HEADINGBANNER);
  1265     emit testLayoutChangedSignal();
  1259     
  1266     QVERIFY(hintWidget->isVisible() == false);
  1260     // show -flag is false
  1267 
       
  1268     setRowCount(1);
  1261     setRowCount(1);
  1269     hintWidget->setVisible(true);
  1262     emit testLayoutChangedSignal();  
  1270     emit testLayoutChangedSignal();
  1263     QVERIFY(subLabel->isVisible());
  1271     QVERIFY(hintWidget->isVisible() == false);
  1264     
       
  1265     // show -flag is true, current list's level != ELevelVideos
       
  1266     setRowCount(0);
       
  1267     mTestView->mCurrentList->activate(VideoCollectionCommon::ELevelAlbum);
       
  1268     emit testLayoutChangedSignal();  
       
  1269     QVERIFY(subLabel->isVisible());
       
  1270     
       
  1271     // show -flag is true, current list's level == ELevelVideos
       
  1272     setRowCount(0);
       
  1273     mTestView->mCurrentList->activate(VideoCollectionCommon::ELevelVideos);
       
  1274     emit testLayoutChangedSignal();  
       
  1275     QVERIFY(!subLabel->isVisible());
       
  1276 }
       
  1277 
       
  1278 // ---------------------------------------------------------------------------
       
  1279 // testTitleReadySlot
       
  1280 // ---------------------------------------------------------------------------
       
  1281 //
       
  1282 void TestListView::testTitleReadySlot()
       
  1283 {
       
  1284     init(true);
       
  1285     
       
  1286     QVERIFY(connect(this, SIGNAL(testSignal(const QString &)), mTestView, SLOT(titleReadySlot(const QString &))));
       
  1287     
       
  1288     QString title("TEST");
       
  1289     
       
  1290     emit testSignal(title);
       
  1291     
       
  1292     QVERIFY(mTestView->mTitle == title);
       
  1293     
       
  1294     disconnect(this, SIGNAL(testSignal(const QString &)), mTestView, SLOT(titleReadySlot(const QString &)));
       
  1295     cleanup();
       
  1296 }
       
  1297 
       
  1298 // ---------------------------------------------------------------------------
       
  1299 // testDoDelayedSlot
       
  1300 // ---------------------------------------------------------------------------
       
  1301 //
       
  1302 void TestListView::testDoDelayedsSlot()
       
  1303 {
       
  1304     init(true);
       
  1305     
       
  1306     QVERIFY(connect(this, SIGNAL(testSignal()), mTestView, SLOT(doDelayedsSlot())));
       
  1307     
       
  1308     emit testSignal();
       
  1309     
       
  1310     QCOMPARE(VideoCollectionUiLoaderData::mLastLoadPhasedData, (int)VideoCollectionUiLoaderParam::LoadPhaseSecondary); 
       
  1311     
       
  1312     disconnect(this, SIGNAL(testSignal()), mTestView, SLOT(doDelayedsSlot()));
       
  1313     cleanup();
       
  1314 }
       
  1315 
       
  1316 // ---------------------------------------------------------------------------
       
  1317 // testOpenNewAlbumSlot
       
  1318 // ---------------------------------------------------------------------------
       
  1319 //
       
  1320 void TestListView::testOpenNewAlbumSlot()
       
  1321 {
       
  1322     init(false);
       
  1323     
       
  1324     QVERIFY(connect(this, SIGNAL(testSignal(const QModelIndex &, int, int)), mTestView, SLOT(openNewAlbumSlot(const QModelIndex &, int, int))));
       
  1325 
       
  1326     QModelIndex index;
       
  1327     
       
  1328     // Not initialized, no mCurrentList
       
  1329     emit testSignal(index, 0, 0);
       
  1330     // TODO verify
       
  1331     
       
  1332     // Good case
       
  1333     QVERIFY(mTestView->initializeView() == 0);
       
  1334     mTestView->activateView(TMPXItemId::InvalidId());
       
  1335     setRowCount(1);
       
  1336     emit testSignal(index, 0, 0);
       
  1337     // TODO verify
       
  1338     
       
  1339     // Invalid index
       
  1340     emit testSignal(index, -1, 0);
       
  1341     // TODO verify
       
  1342     
       
  1343     disconnect(this, SIGNAL(testSignal()), mTestView, SLOT(doDelayedsSlot()));
       
  1344     cleanup();
       
  1345 }
       
  1346 
       
  1347 // ---------------------------------------------------------------------------
       
  1348 // testAboutToChangeOrientationSlot
       
  1349 // ---------------------------------------------------------------------------
       
  1350 //
       
  1351 void TestListView::testAboutToChangeOrientationSlot()
       
  1352 {
       
  1353     init(false);
       
  1354     QVERIFY(connect(this, SIGNAL(testSignal()), mTestView, SLOT(aboutToChangeOrientationSlot())));
       
  1355 
       
  1356     emit testSignal();
       
  1357     
       
  1358     // nothing to verify
       
  1359     
       
  1360     disconnect(this, SIGNAL(testSignal()), mTestView, SLOT(aboutToChangeOrientationSlot()));
       
  1361     cleanup();
       
  1362 }
       
  1363 
       
  1364 // ---------------------------------------------------------------------------
       
  1365 // testOrientationChangedSlot
       
  1366 // ---------------------------------------------------------------------------
       
  1367 //
       
  1368 void TestListView::testOrientationChangedSlot()
       
  1369 {
       
  1370     init(false);
       
  1371     QVERIFY(connect(this, SIGNAL(testSignal(Qt::Orientation)), mTestView, 
       
  1372             SLOT(orientationChangedSlot(Qt::Orientation))));
       
  1373 
       
  1374     HbView::mSetItemVisibleLast = false;
       
  1375     
       
  1376     emit testSignal(Qt::Vertical);
       
  1377     QVERIFY(HbView::mSetItemVisibleLast == true);
       
  1378 
       
  1379     emit testSignal(Qt::Horizontal);
       
  1380     QVERIFY(HbView::mSetItemVisibleLast == false);
       
  1381     
       
  1382     disconnect(this, SIGNAL(testSignal(Qt::Orientation)), mTestView, 
       
  1383             SLOT(orientationChangedSlot(Qt::Orientation)));    
       
  1384     cleanup();
       
  1385 }
       
  1386 
       
  1387 // ---------------------------------------------------------------------------
       
  1388 // testCreateCollectionSlot
       
  1389 // ---------------------------------------------------------------------------
       
  1390 //
       
  1391 void TestListView::testCreateCollectionSlot()
       
  1392 {
       
  1393     init(false);
       
  1394     QVERIFY(connect(this, SIGNAL(testSignal()), mTestView, SLOT(createCollectionSlot())));
       
  1395 
       
  1396     // not initialized, no mCurrentList
       
  1397     emit testSignal();
       
  1398     QCOMPARE(HbInputDialog::mGetTextCallCount, 0);
       
  1399     QVERIFY(VideoSortFilterProxyModelData::mLastAddedAlbumName == "");
       
  1400 
       
  1401     QVERIFY(mTestView->initializeView() == 0);
       
  1402     mTestView->activateView(TMPXItemId::InvalidId());
       
  1403     
       
  1404     // dialog canceled
       
  1405     HbInputDialog::mGetTextFails = true;
       
  1406     emit testSignal();
       
  1407     QCOMPARE(HbInputDialog::mGetTextCallCount, 1);
       
  1408     QVERIFY(VideoSortFilterProxyModelData::mLastAddedAlbumName == "");
       
  1409     
       
  1410     // empty name
       
  1411     HbInputDialog::mGetTextFails = false;
       
  1412     HbInputDialog::mGetTextCallCount = 0;
       
  1413     HbInputDialog::mGetTextReturnValue = "";
       
  1414     emit testSignal();
       
  1415     QCOMPARE(HbInputDialog::mGetTextCallCount, 1);
       
  1416     QVERIFY(VideoSortFilterProxyModelData::mLastAddedAlbumName == "");
       
  1417     
       
  1418     // Good case.
       
  1419     HbInputDialog::mGetTextReturnValue = "testAlbum";
       
  1420     HbInputDialog::mGetTextCallCount = 0;
       
  1421     emit testSignal();
       
  1422     QCOMPARE(HbInputDialog::mGetTextCallCount, 1);
       
  1423     QVERIFY(VideoSortFilterProxyModelData::mLastAddedAlbumName == "testAlbum");
       
  1424     
       
  1425     HbInputDialog::mGetTextCallCount = 0;
       
  1426     HbInputDialog::mGetTextReturnValue = QString();
       
  1427     VideoSortFilterProxyModelData::mLastAddedAlbumName = "";
       
  1428     
       
  1429     disconnect(this, SIGNAL(testSignal()), mTestView, SLOT(createCollectionSlot()));
       
  1430     cleanup();
       
  1431 }
       
  1432 
       
  1433 // ---------------------------------------------------------------------------
       
  1434 // testAddVideosToCollectionSlot
       
  1435 // ---------------------------------------------------------------------------
       
  1436 //
       
  1437 void TestListView::testAddVideosToCollectionSlot()
       
  1438 {
       
  1439     init(false);
       
  1440     QVERIFY(connect(this, SIGNAL(testSignal()), mTestView, SLOT(addVideosToCollectionSlot())));
       
  1441 
       
  1442     VideoSortFilterProxyModelData::mOpenedItemId = TMPXItemId(0, 2);
       
  1443     
       
  1444     // Not initalized, no mCurrentList
       
  1445     emit testSignal();
       
  1446     QVERIFY(VideoListSelectionDialogData::mSelectionType == -1);
       
  1447     QVERIFY(VideoListSelectionDialogData::mSettedMpxId == TMPXItemId::InvalidId());
       
  1448     QCOMPARE(VideoCollectionViewUtilsData::mLastError, 0);
       
  1449     
       
  1450     QVERIFY(mTestView->initializeView() == 0);
       
  1451     mTestView->activateView(TMPXItemId::InvalidId());
       
  1452     
       
  1453     // Selection dialog widget loading fails.
       
  1454     VideoCollectionUiLoaderData::mFindFailure = true;
       
  1455     emit testSignal();
       
  1456     QVERIFY(VideoListSelectionDialogData::mSelectionType == -1);
       
  1457     QVERIFY(VideoListSelectionDialogData::mSettedMpxId == TMPXItemId::InvalidId());
       
  1458     QCOMPARE(VideoCollectionViewUtilsData::mLastError, 0);
       
  1459     
       
  1460     // Current level is not album
       
  1461     VideoListSelectionDialogData::reset();
       
  1462     VideoCollectionViewUtilsData::reset();
       
  1463     VideoCollectionUiLoaderData::mFindFailure = false;
       
  1464     mTestView->mCurrentList->mCurrentLevel = VideoCollectionCommon::ELevelCategory;
       
  1465     emit testSignal();
       
  1466     QVERIFY(VideoListSelectionDialogData::mSelectionType == VideoListSelectionDialog::EAddToCollection);
       
  1467     QVERIFY(VideoListSelectionDialogData::mSettedMpxId == VideoSortFilterProxyModelData::mOpenedItemId);
       
  1468     QCOMPARE(VideoCollectionViewUtilsData::mLastError, 0);
       
  1469 
       
  1470     // Current level is album, video list widget load fails.
       
  1471     VideoListSelectionDialogData::reset();
       
  1472     VideoCollectionViewUtilsData::reset();
       
  1473     VideoCollectionUiLoaderData::reset();
       
  1474     HbDocumentLoader::mVideoListWidgetFailure = true;
       
  1475     mTestView->mCurrentList->mCurrentLevel = VideoCollectionCommon::ELevelAlbum;
       
  1476     emit testSignal();
       
  1477     QVERIFY(VideoListSelectionDialogData::mSelectionType == VideoListSelectionDialog::EAddToCollection);
       
  1478     QVERIFY(VideoListSelectionDialogData::mSettedMpxId == VideoSortFilterProxyModelData::mOpenedItemId);
       
  1479     QCOMPARE(VideoCollectionViewUtilsData::mLastError, 0);
       
  1480     
       
  1481     // Current level is album, but model is empty.
       
  1482     HbDocumentLoader::mVideoListWidgetFailure = false;
       
  1483     VideoListSelectionDialogData::reset();
       
  1484     VideoCollectionViewUtilsData::reset();
       
  1485     VideoCollectionUiLoaderData::reset();
       
  1486     mTestView->mCurrentList->mCurrentLevel = VideoCollectionCommon::ELevelAlbum;
       
  1487     emit testSignal();
       
  1488     QVERIFY(VideoListSelectionDialogData::mSelectionType == -1);
       
  1489     QVERIFY(VideoListSelectionDialogData::mSettedMpxId == TMPXItemId::InvalidId());
       
  1490     QCOMPARE(VideoCollectionViewUtilsData::mLastError, 0);
       
  1491 
       
  1492     // Current level is album, all videos are in the album 
       
  1493     VideoListSelectionDialogData::reset();
       
  1494     VideoListDataModelData::reset();
       
  1495     VideoCollectionViewUtilsData::reset();
       
  1496     mTestView->mCurrentList->mCurrentLevel = VideoCollectionCommon::ELevelAlbum;
       
  1497     VideoListWidget *allVideos = mUiLoader->findWidget<VideoListWidget>(
       
  1498                 DOCML_NAME_VC_VIDEOLISTWIDGET);
       
  1499     QVERIFY(allVideos);
       
  1500     setRowCount(3, allVideos->mModel);
       
  1501     emit testSignal();
       
  1502     QVERIFY(VideoListSelectionDialogData::mSelectionType == -1);
       
  1503     QVERIFY(VideoListSelectionDialogData::mSettedMpxId == TMPXItemId::InvalidId());
       
  1504     QVERIFY(VideoCollectionViewUtilsData::mLastError == 
       
  1505             VideoCollectionCommon::statusAllVideosAlreadyInCollection);
       
  1506     
       
  1507     // Current level is album, all videos are not in the album
       
  1508     VideoListSelectionDialogData::reset();
       
  1509     VideoCollectionViewUtilsData::reset();
       
  1510     VideoListDataModelData::reset();
       
  1511     QVERIFY(allVideos);
       
  1512     setRowCount(3, allVideos->mModel);
       
  1513     // Must have different model than selection dialog has. Otherwise Qt optimizes rowCount calls 
       
  1514     // to source model and VideoListDataModelData::mRowCountDecrement hack doesn't work.
       
  1515     QVERIFY(connect(this, SIGNAL(testSignal2()), mTestView, SLOT(openCollectionViewSlot())));
       
  1516     emit testSignal2();
       
  1517     disconnect(this, SIGNAL(testSignal2()), mTestView, SLOT(openCollectionViewSlot()));
       
  1518     QVERIFY(mTestView->initializeView() == 0);
       
  1519     mTestView->activateView(TMPXItemId::InvalidId());
       
  1520     VideoListDataModelData::mRowCountDecrement = 1;
       
  1521     mTestView->mCurrentList->mCurrentLevel = VideoCollectionCommon::ELevelAlbum;
       
  1522     setRowCount(1);
       
  1523     emit testSignal();
       
  1524     QVERIFY(VideoListSelectionDialogData::mSelectionType == VideoListSelectionDialog::EAddToCollection);
       
  1525     QVERIFY(VideoListSelectionDialogData::mSettedMpxId == VideoSortFilterProxyModelData::mOpenedItemId);
       
  1526     QCOMPARE(VideoCollectionViewUtilsData::mLastError, 0);
       
  1527     
       
  1528     disconnect(this, SIGNAL(testSignal()), mTestView, SLOT(addVideosToCollectionSlot()));
       
  1529     
       
  1530     cleanup();
       
  1531 }
       
  1532 
       
  1533 // ---------------------------------------------------------------------------
       
  1534 // testRemoveVideosFromCollectionSlot
       
  1535 // ---------------------------------------------------------------------------
       
  1536 //
       
  1537 void TestListView::testRemoveVideosFromCollectionSlot()
       
  1538 {
       
  1539     VideoListSelectionDialogData::reset();
       
  1540     VideoCollectionViewUtilsData::reset();
       
  1541     VideoCollectionUiLoaderData::reset();
       
  1542     HbDocumentLoader::mVideoListWidgetFailure = false;
       
  1543     
       
  1544     init(false);
       
  1545     
       
  1546     QVERIFY(connect(this, SIGNAL(testSignal()), mTestView, SLOT(removeVideosFromCollectionSlot())));
       
  1547     
       
  1548     // Not initialized, no current list
       
  1549     emit testSignal();
       
  1550     
       
  1551     QVERIFY(mTestView->initializeView() == 0);
       
  1552     mTestView->activateView(TMPXItemId::InvalidId());
       
  1553     setRowCount(1);
       
  1554     
       
  1555     // Wrong level.
       
  1556     mTestView->mCurrentList->mCurrentLevel = VideoCollectionCommon::ELevelCategory;
       
  1557     emit testSignal();
       
  1558     
       
  1559     // No items in model.
       
  1560     mTestView->mCurrentList->mCurrentLevel = VideoCollectionCommon::ELevelDefaultColl;
       
  1561     emit testSignal();
       
  1562 
       
  1563     // Fail to load selection dialog.
       
  1564     VideoCollectionUiLoaderData::mFindFailure = true;
       
  1565     emit testSignal();
       
  1566     
       
  1567     // Open item is invalid
       
  1568     VideoCollectionUiLoaderData::mFindFailure = false;
       
  1569     VideoSortFilterProxyModelData::mOpenedItemId = TMPXItemId::InvalidId();
       
  1570     emit testSignal();
       
  1571     
       
  1572     // Open item is video!
       
  1573     VideoSortFilterProxyModelData::mOpenedItemId = TMPXItemId(0, KVcxMvcMediaTypeVideo);
       
  1574     emit testSignal();
       
  1575     
       
  1576     // Good case.
       
  1577     VideoSortFilterProxyModelData::mOpenedItemId = TMPXItemId(0, KVcxMvcMediaTypeAlbum);
       
  1578     emit testSignal();
       
  1579     
       
  1580     disconnect(this, SIGNAL(testSignal()), mTestView, SLOT(removeVideosFromCollectionSlot()));
       
  1581     
       
  1582     cleanup();
       
  1583 }
       
  1584 
       
  1585 // ---------------------------------------------------------------------------
       
  1586 // testFinishCollectionOpenedSlot
       
  1587 // ---------------------------------------------------------------------------
       
  1588 //
       
  1589 void TestListView::testFinishCollectionOpenedSlot()
       
  1590 {
       
  1591     XQServiceUtilXtra *serviceUtil = XQServiceUtilXtra::instance();
       
  1592     serviceUtil->setCurrentService(false);
       
  1593     
       
  1594     init(false);
       
  1595     
       
  1596     QVERIFY(connect(this, SIGNAL(testSignal(const HbEffect::EffectStatus &)), mTestView, 
       
  1597             SLOT(finishCollectionOpenedSlot(const HbEffect::EffectStatus &))));
       
  1598     
       
  1599     QVERIFY(mTestView->initializeView() == 0);
       
  1600     mTestView->activateView(TMPXItemId::InvalidId());
       
  1601 
       
  1602     HbEffect::EffectStatus status;
       
  1603     
       
  1604     // Invalid status.userData
       
  1605     mTestView->mTransitionOngoing = true;
       
  1606     emit testSignal(status);
       
  1607     QVERIFY(!mTestView->mTransitionOngoing);
       
  1608     // TODO: verify
       
  1609     
       
  1610     // Category is not album
       
  1611     QVERIFY(mTestView->toolBar());
       
  1612     mTestView->toolBar()->clearActions();
       
  1613     mTestView->mTransitionOngoing = true;
       
  1614     status.userData = QVariant(static_cast<int>(VideoCollectionCommon::ELevelCategory));
       
  1615     emit testSignal(status);
       
  1616     QVERIFY(!mTestView->mTransitionOngoing);
       
  1617     QVERIFY(mTestView->toolBar()->actions().count() == 0);
       
  1618     
       
  1619     // Category is album
       
  1620     QVERIFY(mTestView->toolBar());
       
  1621     mTestView->toolBar()->clearActions();
       
  1622     mTestView->mTransitionOngoing = true;
       
  1623     status.userData = QVariant(static_cast<int>(VideoCollectionCommon::ELevelAlbum));
       
  1624     emit testSignal(status);
       
  1625     QVERIFY(!mTestView->mTransitionOngoing);
       
  1626     QVERIFY(mTestView->toolBar()->actions().count() > 0);
       
  1627     
       
  1628     disconnect(this, SIGNAL(testSignal(const HbEffect::EffectStatus &)), mTestView, 
       
  1629             SLOT(finishCollectionOpenedSlot(const HbEffect::EffectStatus &)));
       
  1630     
       
  1631     cleanup();
       
  1632     
       
  1633     // final cleanup
       
  1634     serviceUtil->decreaseReferenceCount();
       
  1635 }
       
  1636 
       
  1637 // ---------------------------------------------------------------------------
       
  1638 // testFinishCollectionOpenedSlot
       
  1639 // ---------------------------------------------------------------------------
       
  1640 //
       
  1641 void TestListView::testFinishCollectionClosedSlot()
       
  1642 {
       
  1643     init(false);
       
  1644     
       
  1645     QVERIFY(connect(this, SIGNAL(testSignal(const HbEffect::EffectStatus &)), mTestView, 
       
  1646             SLOT(finishCollectionClosedSlot(const HbEffect::EffectStatus &))));
       
  1647     
       
  1648     QVERIFY(mTestView->initializeView() == 0);
       
  1649     mTestView->activateView(TMPXItemId::InvalidId());
       
  1650 
       
  1651     HbEffect::EffectStatus status;
       
  1652     
       
  1653     mTestView->mTransitionOngoing = true;
       
  1654     emit testSignal(status);
       
  1655     QVERIFY(!mTestView->mTransitionOngoing);
       
  1656 
       
  1657     mTestView->mTransitionOngoing = true;
       
  1658     QActionGroup *tmp = mTestView->mToolbarViewsActionGroup;
       
  1659     mTestView->mToolbarViewsActionGroup = 0;
       
  1660     emit testSignal(status);
       
  1661     QVERIFY(!mTestView->mTransitionOngoing);
       
  1662     mTestView->mToolbarViewsActionGroup = tmp;
       
  1663 
       
  1664     
       
  1665     disconnect(this, SIGNAL(testSignal(const HbEffect::EffectStatus &)), mTestView, 
       
  1666             SLOT(finishCollectionClosedSlot(const HbEffect::EffectStatus &)));
       
  1667     
       
  1668     cleanup();
  1272 }
  1669 }
  1273 
  1670 
  1274 // End of file
  1671 // End of file