videocollection/videocollectionwrapper/tsrc/testvideomodel_p/src/testvideomodel_p.cpp
author hgs
Fri, 16 Apr 2010 18:13:14 +0300
changeset 36 8aed59de29f9
parent 35 3738fe97f027
child 38 ff53afa8ad05
permissions -rw-r--r--
201015
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
30
hgs
parents:
diff changeset
     1
/*
hgs
parents:
diff changeset
     2
* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
hgs
parents:
diff changeset
     3
* All rights reserved.
hgs
parents:
diff changeset
     4
* This component and the accompanying materials are made available
hgs
parents:
diff changeset
     5
* under the terms of "Eclipse Public License v1.0"
hgs
parents:
diff changeset
     6
* which accompanies this distribution, and is available
hgs
parents:
diff changeset
     7
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
hgs
parents:
diff changeset
     8
*
hgs
parents:
diff changeset
     9
* Initial Contributors:
hgs
parents:
diff changeset
    10
* Nokia Corporation - initial contribution.
hgs
parents:
diff changeset
    11
*
hgs
parents:
diff changeset
    12
* Contributors:
hgs
parents:
diff changeset
    13
*
hgs
parents:
diff changeset
    14
* Description: 
hgs
parents:
diff changeset
    15
*
hgs
parents:
diff changeset
    16
*/
hgs
parents:
diff changeset
    17
hgs
parents:
diff changeset
    18
// INCLUDES
36
hgs
parents: 35
diff changeset
    19
#include <hbglobal.h>
hgs
parents: 35
diff changeset
    20
#include <hbextendedlocale.h>
30
hgs
parents:
diff changeset
    21
#include <mpxmediageneraldefs.h>
hgs
parents:
diff changeset
    22
#include <mpxmediaarray.h>
hgs
parents:
diff changeset
    23
#include <mpxmedia.h>
hgs
parents:
diff changeset
    24
#include <vcxmyvideosdefs.h>
hgs
parents:
diff changeset
    25
#include <qabstractitemmodel.h>
34
hgs
parents: 30
diff changeset
    26
#include "testvideomodel_p.h"
hgs
parents: 30
diff changeset
    27
30
hgs
parents:
diff changeset
    28
#include "videocollectionutils.h"
hgs
parents:
diff changeset
    29
#include "videothumbnaildata.h"
hgs
parents:
diff changeset
    30
#include "videolistdatamodel.h"
34
hgs
parents: 30
diff changeset
    31
30
hgs
parents:
diff changeset
    32
#include "mediaobjectfactory.h"
hgs
parents:
diff changeset
    33
#include "videocollectioncommon.h"
hgs
parents:
diff changeset
    34
#include "videocollectionutils.h"
36
hgs
parents: 35
diff changeset
    35
#include "metadatasignalspy.h"
30
hgs
parents:
diff changeset
    36
hgs
parents:
diff changeset
    37
#define private public
hgs
parents:
diff changeset
    38
#include "videolistdatamodel_p.h"
hgs
parents:
diff changeset
    39
#undef private
hgs
parents:
diff changeset
    40
hgs
parents:
diff changeset
    41
const int MEDIA_COUNT = 10;
hgs
parents:
diff changeset
    42
hgs
parents:
diff changeset
    43
inline uint qHash(TMPXItemId key) 
hgs
parents:
diff changeset
    44
{ 
hgs
parents:
diff changeset
    45
    QPair<uint, uint> keyPair(key.iId1, key.iId2); 
hgs
parents:
diff changeset
    46
hgs
parents:
diff changeset
    47
    return qHash(keyPair);
hgs
parents:
diff changeset
    48
}
hgs
parents:
diff changeset
    49
hgs
parents:
diff changeset
    50
hgs
parents:
diff changeset
    51
int main(int argc, char *argv[])
hgs
parents:
diff changeset
    52
{
hgs
parents:
diff changeset
    53
    Q_UNUSED(argc);
hgs
parents:
diff changeset
    54
    
hgs
parents:
diff changeset
    55
    TestVideoModel_p tv;
hgs
parents:
diff changeset
    56
34
hgs
parents: 30
diff changeset
    57
    int res;
hgs
parents: 30
diff changeset
    58
    if(argc > 1)
hgs
parents: 30
diff changeset
    59
    {   
hgs
parents: 30
diff changeset
    60
        res = QTest::qExec(&tv, argc, argv);
hgs
parents: 30
diff changeset
    61
    }
hgs
parents: 30
diff changeset
    62
    else
hgs
parents: 30
diff changeset
    63
    {
hgs
parents: 30
diff changeset
    64
        char *pass[3];
hgs
parents: 30
diff changeset
    65
        pass[0] = argv[0];
hgs
parents: 30
diff changeset
    66
        pass[1] = "-o";
hgs
parents: 30
diff changeset
    67
        pass[2] = "c:\\data\\testvideomodel_p.txt";
hgs
parents: 30
diff changeset
    68
        res = QTest::qExec(&tv, 3, pass);
hgs
parents: 30
diff changeset
    69
    }    
30
hgs
parents:
diff changeset
    70
hgs
parents:
diff changeset
    71
    return res;
hgs
parents:
diff changeset
    72
}
hgs
parents:
diff changeset
    73
hgs
parents:
diff changeset
    74
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
    75
// initTestCase
hgs
parents:
diff changeset
    76
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
    77
//
34
hgs
parents: 30
diff changeset
    78
30
hgs
parents:
diff changeset
    79
void TestVideoModel_p::initTestCase()
hgs
parents:
diff changeset
    80
{
34
hgs
parents: 30
diff changeset
    81
    qRegisterMetaType<TMPXItemId>("TMPXItemId");
30
hgs
parents:
diff changeset
    82
    mTestObject = 0;
hgs
parents:
diff changeset
    83
    mMediaFactory = new MediaObjectFactory();
hgs
parents:
diff changeset
    84
    
hgs
parents:
diff changeset
    85
    mStubModel = new VideoListDataModel();
hgs
parents:
diff changeset
    86
}
hgs
parents:
diff changeset
    87
hgs
parents:
diff changeset
    88
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
    89
// init
hgs
parents:
diff changeset
    90
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
    91
//
hgs
parents:
diff changeset
    92
void TestVideoModel_p::init()
hgs
parents:
diff changeset
    93
{
hgs
parents:
diff changeset
    94
    qRegisterMetaType<QModelIndex>("QModelIndex");
hgs
parents:
diff changeset
    95
    mTestObject = new VideoListDataModelPrivate(mStubModel);
hgs
parents:
diff changeset
    96
    QVERIFY(mTestObject);
hgs
parents:
diff changeset
    97
    VideoCollectionUtils::mPrepareLengthStringReturnValue = "test duration";
34
hgs
parents: 30
diff changeset
    98
    VideoCollectionUtils::mPrepareSizeStringReturnValue = "test size";   
30
hgs
parents:
diff changeset
    99
}
hgs
parents:
diff changeset
   100
hgs
parents:
diff changeset
   101
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
   102
// cleanup
hgs
parents:
diff changeset
   103
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
   104
//
hgs
parents:
diff changeset
   105
void TestVideoModel_p::cleanup()
hgs
parents:
diff changeset
   106
{
hgs
parents:
diff changeset
   107
    if(mTestObject)
hgs
parents:
diff changeset
   108
    {
hgs
parents:
diff changeset
   109
        delete mTestObject;
hgs
parents:
diff changeset
   110
        mTestObject = 0;
hgs
parents:
diff changeset
   111
    }  
hgs
parents:
diff changeset
   112
}
hgs
parents:
diff changeset
   113
hgs
parents:
diff changeset
   114
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
   115
// cleanupTestCase
hgs
parents:
diff changeset
   116
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
   117
//
hgs
parents:
diff changeset
   118
void TestVideoModel_p::cleanupTestCase()
hgs
parents:
diff changeset
   119
{
hgs
parents:
diff changeset
   120
    delete mMediaFactory;
hgs
parents:
diff changeset
   121
    delete mStubModel;
hgs
parents:
diff changeset
   122
}
hgs
parents:
diff changeset
   123
hgs
parents:
diff changeset
   124
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
   125
// testInitTNFails
hgs
parents:
diff changeset
   126
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
   127
//
34
hgs
parents: 30
diff changeset
   128
30
hgs
parents:
diff changeset
   129
void TestVideoModel_p::testInitialize()
hgs
parents:
diff changeset
   130
{   
hgs
parents:
diff changeset
   131
    // Succeeds.
hgs
parents:
diff changeset
   132
    QVERIFY(mTestObject->initialize() == 0);
hgs
parents:
diff changeset
   133
    
hgs
parents:
diff changeset
   134
    // Initialize already called.
hgs
parents:
diff changeset
   135
    QVERIFY(mTestObject->initialize() == 0);
hgs
parents:
diff changeset
   136
}
hgs
parents:
diff changeset
   137
hgs
parents:
diff changeset
   138
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
   139
// testItemCount
hgs
parents:
diff changeset
   140
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
   141
//
hgs
parents:
diff changeset
   142
void TestVideoModel_p::testItemCount()
hgs
parents:
diff changeset
   143
{    
hgs
parents:
diff changeset
   144
    QVERIFY(mTestObject->getVideoCount() == 0);
hgs
parents:
diff changeset
   145
    
hgs
parents:
diff changeset
   146
    QVERIFY(connect(this, SIGNAL(signalNewVideoList(CMPXMediaArray*)), mTestObject, SLOT(newVideoListSlot(CMPXMediaArray*))));    
hgs
parents:
diff changeset
   147
    
hgs
parents:
diff changeset
   148
    mMediaFactory->removeArray();
hgs
parents:
diff changeset
   149
    mMediaFactory->createMediaItems(MEDIA_COUNT);
hgs
parents:
diff changeset
   150
    emit signalNewVideoList(mMediaFactory->copyOfMediaArray());
hgs
parents:
diff changeset
   151
        
hgs
parents:
diff changeset
   152
    QVERIFY( mTestObject->getVideoCount() == MEDIA_COUNT);
hgs
parents:
diff changeset
   153
hgs
parents:
diff changeset
   154
    disconnect(this, SIGNAL(signalNewVideoList(CMPXMediaArray*)), mTestObject, SLOT(newVideoListSlot(CMPXMediaArray*)));
hgs
parents:
diff changeset
   155
}
hgs
parents:
diff changeset
   156
hgs
parents:
diff changeset
   157
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
   158
// testGetMediaIdFromIndex
hgs
parents:
diff changeset
   159
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
   160
//
hgs
parents:
diff changeset
   161
void TestVideoModel_p::testGetMediaIdFromIndex()
hgs
parents:
diff changeset
   162
{
hgs
parents:
diff changeset
   163
    QVERIFY(mTestObject->getMediaIdFromIndex(0) == -1);
hgs
parents:
diff changeset
   164
    QVERIFY(mTestObject->getMediaIdFromIndex(-1) == -1);
hgs
parents:
diff changeset
   165
    
hgs
parents:
diff changeset
   166
    mMediaFactory->removeArray();
hgs
parents:
diff changeset
   167
    QVERIFY(connect(this, SIGNAL(signalNewVideoList(CMPXMediaArray*)), mTestObject, SLOT(newVideoListSlot(CMPXMediaArray*))));          
hgs
parents:
diff changeset
   168
    mMediaFactory->createMediaItems(MEDIA_COUNT);
hgs
parents:
diff changeset
   169
    emit signalNewVideoList(mMediaFactory->copyOfMediaArray());
hgs
parents:
diff changeset
   170
    
hgs
parents:
diff changeset
   171
    QVERIFY(mTestObject->getMediaIdFromIndex(-1) == -1);
hgs
parents:
diff changeset
   172
    
hgs
parents:
diff changeset
   173
    QVERIFY(mTestObject->getMediaIdFromIndex(MEDIA_COUNT) == -1);
hgs
parents:
diff changeset
   174
    
hgs
parents:
diff changeset
   175
    QVERIFY(mTestObject->getMediaIdFromIndex(0) == 0);
hgs
parents:
diff changeset
   176
    
hgs
parents:
diff changeset
   177
    QVERIFY(mTestObject->getMediaIdFromIndex(MEDIA_COUNT - 1) == MEDIA_COUNT - 1);
hgs
parents:
diff changeset
   178
    
hgs
parents:
diff changeset
   179
    // no data
34
hgs
parents: 30
diff changeset
   180
    mTestObject->mMediaData.clear();
30
hgs
parents:
diff changeset
   181
    mMediaFactory->removeArray();
hgs
parents:
diff changeset
   182
    mMediaFactory->createMediaItems(MEDIA_COUNT, MediaDataNone);    
hgs
parents:
diff changeset
   183
    emit signalNewVideoList(mMediaFactory->copyOfMediaArray());
hgs
parents:
diff changeset
   184
    
hgs
parents:
diff changeset
   185
    QVERIFY(mTestObject->getMediaIdFromIndex(-1) == -1);
hgs
parents:
diff changeset
   186
        
hgs
parents:
diff changeset
   187
    QVERIFY(mTestObject->getMediaIdFromIndex(MEDIA_COUNT) == -1);
hgs
parents:
diff changeset
   188
    
hgs
parents:
diff changeset
   189
    QVERIFY(mTestObject->getMediaIdFromIndex(0) == -1);
hgs
parents:
diff changeset
   190
    
hgs
parents:
diff changeset
   191
    QVERIFY(mTestObject->getMediaIdFromIndex(MEDIA_COUNT - 1) == - 1);
hgs
parents:
diff changeset
   192
       
hgs
parents:
diff changeset
   193
              
hgs
parents:
diff changeset
   194
    disconnect(this, SIGNAL(signalNewVideoList(CMPXMediaArray*)), mTestObject, SLOT(newVideoListSlot(CMPXMediaArray*)));  
hgs
parents:
diff changeset
   195
}
hgs
parents:
diff changeset
   196
hgs
parents:
diff changeset
   197
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
   198
// testGetVideoNameFromIndex
hgs
parents:
diff changeset
   199
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
   200
//
hgs
parents:
diff changeset
   201
void TestVideoModel_p::testGetVideoNameFromIndex()
hgs
parents:
diff changeset
   202
{
hgs
parents:
diff changeset
   203
    QString expectedName = "";
hgs
parents:
diff changeset
   204
        
hgs
parents:
diff changeset
   205
    QVERIFY(mTestObject->getVideoNameFromIndex(0) == expectedName);
hgs
parents:
diff changeset
   206
    QVERIFY(mTestObject->getVideoNameFromIndex(-1) == expectedName);
hgs
parents:
diff changeset
   207
    
hgs
parents:
diff changeset
   208
    mMediaFactory->removeArray();
hgs
parents:
diff changeset
   209
    QVERIFY(connect(this, SIGNAL(signalNewVideoList(CMPXMediaArray*)), mTestObject, SLOT(newVideoListSlot(CMPXMediaArray*))));          
hgs
parents:
diff changeset
   210
    mMediaFactory->createMediaItems(MEDIA_COUNT);
hgs
parents:
diff changeset
   211
    emit signalNewVideoList(mMediaFactory->copyOfMediaArray());
hgs
parents:
diff changeset
   212
    
hgs
parents:
diff changeset
   213
    QVERIFY(mTestObject->getVideoNameFromIndex(-1) == expectedName);
hgs
parents:
diff changeset
   214
            
hgs
parents:
diff changeset
   215
    QVERIFY(mTestObject->getVideoNameFromIndex(MEDIA_COUNT) == expectedName);
hgs
parents:
diff changeset
   216
    
hgs
parents:
diff changeset
   217
    expectedName = gQTMediaNamePrefix + "0";
hgs
parents:
diff changeset
   218
    QVERIFY(mTestObject->getVideoNameFromIndex(0) == expectedName);
hgs
parents:
diff changeset
   219
    
hgs
parents:
diff changeset
   220
    expectedName = gQTMediaNamePrefix + QString::number(MEDIA_COUNT - 1);
hgs
parents:
diff changeset
   221
    QVERIFY(mTestObject->getVideoNameFromIndex(MEDIA_COUNT - 1) == expectedName);
hgs
parents:
diff changeset
   222
    
hgs
parents:
diff changeset
   223
    // no data
hgs
parents:
diff changeset
   224
    expectedName = "";
34
hgs
parents: 30
diff changeset
   225
    mTestObject->mMediaData.clear();
30
hgs
parents:
diff changeset
   226
    mMediaFactory->removeArray();
hgs
parents:
diff changeset
   227
    mMediaFactory->createMediaItems(MEDIA_COUNT, MediaDataId);    
hgs
parents:
diff changeset
   228
    emit signalNewVideoList(mMediaFactory->copyOfMediaArray());
hgs
parents:
diff changeset
   229
    
hgs
parents:
diff changeset
   230
    QVERIFY(mTestObject->getVideoNameFromIndex(-1) == expectedName);
hgs
parents:
diff changeset
   231
        
hgs
parents:
diff changeset
   232
    QVERIFY(mTestObject->getVideoNameFromIndex(MEDIA_COUNT) == expectedName);
hgs
parents:
diff changeset
   233
    
hgs
parents:
diff changeset
   234
    QVERIFY(mTestObject->getVideoNameFromIndex(0) == expectedName);
hgs
parents:
diff changeset
   235
    
hgs
parents:
diff changeset
   236
    QVERIFY(mTestObject->getVideoNameFromIndex(MEDIA_COUNT - 1) == expectedName);
hgs
parents:
diff changeset
   237
    
hgs
parents:
diff changeset
   238
    disconnect(this, SIGNAL(signalNewVideoList(CMPXMediaArray*)), mTestObject, SLOT(newVideoListSlot(CMPXMediaArray*))); 
hgs
parents:
diff changeset
   239
}
hgs
parents:
diff changeset
   240
hgs
parents:
diff changeset
   241
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
   242
// testGetVideoThumbnailFromIndex
hgs
parents:
diff changeset
   243
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
   244
//
hgs
parents:
diff changeset
   245
void TestVideoModel_p::testGetVideoThumbnailFromIndex()
hgs
parents:
diff changeset
   246
{
hgs
parents:
diff changeset
   247
    QVERIFY(mTestObject->getVideoThumbnailFromIndex(0) == 0);
hgs
parents:
diff changeset
   248
    
hgs
parents:
diff changeset
   249
    mMediaFactory->removeArray();
hgs
parents:
diff changeset
   250
    QVERIFY(connect(this, SIGNAL(signalNewVideoList(CMPXMediaArray*)), mTestObject, SLOT(newVideoListSlot(CMPXMediaArray*))));          
hgs
parents:
diff changeset
   251
    mMediaFactory->createMediaItems(MEDIA_COUNT);
hgs
parents:
diff changeset
   252
    emit signalNewVideoList(mMediaFactory->copyOfMediaArray());
hgs
parents:
diff changeset
   253
    
hgs
parents:
diff changeset
   254
    QVERIFY(mTestObject->initialize() == 0);
hgs
parents:
diff changeset
   255
    
hgs
parents:
diff changeset
   256
    // invalid indexes
hgs
parents:
diff changeset
   257
    QVERIFY(mTestObject->getVideoThumbnailFromIndex(-1) == 0);
hgs
parents:
diff changeset
   258
    
hgs
parents:
diff changeset
   259
    QVERIFY(mTestObject->getVideoThumbnailFromIndex(MEDIA_COUNT) == 0);
hgs
parents:
diff changeset
   260
    
hgs
parents:
diff changeset
   261
    // correct indexes
hgs
parents:
diff changeset
   262
    QVERIFY(mTestObject->getVideoThumbnailFromIndex(0) != 0);
hgs
parents:
diff changeset
   263
    QVERIFY(mTestObject->getVideoThumbnailFromIndex(MEDIA_COUNT/2) != 0);
hgs
parents:
diff changeset
   264
    QVERIFY(mTestObject->getVideoThumbnailFromIndex(MEDIA_COUNT - 1) != 0);
hgs
parents:
diff changeset
   265
      
hgs
parents:
diff changeset
   266
    disconnect(this, SIGNAL(signalNewVideoList(CMPXMediaArray*)), mTestObject, SLOT(newVideoListSlot(CMPXMediaArray*))); 
hgs
parents:
diff changeset
   267
}
hgs
parents:
diff changeset
   268
hgs
parents:
diff changeset
   269
// -----------------------------------------------------------------------------
35
hgs
parents: 34
diff changeset
   270
// testGetCategoryVideoCountFromIndex
hgs
parents: 34
diff changeset
   271
// -----------------------------------------------------------------------------
hgs
parents: 34
diff changeset
   272
//
hgs
parents: 34
diff changeset
   273
void TestVideoModel_p::testGetCategoryVideoCountFromIndex()
hgs
parents: 34
diff changeset
   274
{
hgs
parents: 34
diff changeset
   275
    QVERIFY(mTestObject->getCategoryVideoCountFromIndex(0) == 0);
hgs
parents: 34
diff changeset
   276
    
hgs
parents: 34
diff changeset
   277
    mMediaFactory->removeArray();
hgs
parents: 34
diff changeset
   278
    QVERIFY(connect(this, SIGNAL(signalNewVideoList(CMPXMediaArray*)), mTestObject, SLOT(newVideoListSlot(CMPXMediaArray*))));          
hgs
parents: 34
diff changeset
   279
    mMediaFactory->createMediaItems(MEDIA_COUNT, MediaDataName | MediaDataId | MediaDetailCategoryVideoCount);
hgs
parents: 34
diff changeset
   280
    emit signalNewVideoList(mMediaFactory->copyOfMediaArray());
hgs
parents: 34
diff changeset
   281
hgs
parents: 34
diff changeset
   282
    QVERIFY(mTestObject->initialize() == 0);
hgs
parents: 34
diff changeset
   283
    
hgs
parents: 34
diff changeset
   284
    // invalid indexes
hgs
parents: 34
diff changeset
   285
    QVERIFY(mTestObject->getCategoryVideoCountFromIndex(-1) == 0);
hgs
parents: 34
diff changeset
   286
    
hgs
parents: 34
diff changeset
   287
    QVERIFY(mTestObject->getCategoryVideoCountFromIndex(MEDIA_COUNT) == 0);
hgs
parents: 34
diff changeset
   288
    
hgs
parents: 34
diff changeset
   289
    // correct indexes
hgs
parents: 34
diff changeset
   290
    QCOMPARE((int)(mTestObject->getCategoryVideoCountFromIndex(0)), 1);
hgs
parents: 34
diff changeset
   291
    QCOMPARE((int)(mTestObject->getCategoryVideoCountFromIndex(MEDIA_COUNT/2)), 1);
hgs
parents: 34
diff changeset
   292
    QCOMPARE((int)(mTestObject->getCategoryVideoCountFromIndex(MEDIA_COUNT - 1)), 5);
hgs
parents: 34
diff changeset
   293
hgs
parents: 34
diff changeset
   294
    disconnect(this, SIGNAL(signalNewVideoList(CMPXMediaArray*)), mTestObject, SLOT(newVideoListSlot(CMPXMediaArray*))); 
hgs
parents: 34
diff changeset
   295
}
hgs
parents: 34
diff changeset
   296
hgs
parents: 34
diff changeset
   297
// -----------------------------------------------------------------------------
30
hgs
parents:
diff changeset
   298
// testGetVideoSizeFromIndex
hgs
parents:
diff changeset
   299
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
   300
//
hgs
parents:
diff changeset
   301
void TestVideoModel_p::testGetVideoSizeFromIndex()
hgs
parents:
diff changeset
   302
{
hgs
parents:
diff changeset
   303
    QVERIFY(mTestObject->getVideoSizeFromIndex(0) == 0);
hgs
parents:
diff changeset
   304
    QVERIFY(mTestObject->getVideoSizeFromIndex(-1) == 0);
hgs
parents:
diff changeset
   305
    
hgs
parents:
diff changeset
   306
    mMediaFactory->removeArray();
hgs
parents:
diff changeset
   307
    QVERIFY(connect(this, SIGNAL(signalNewVideoList(CMPXMediaArray*)), mTestObject, SLOT(newVideoListSlot(CMPXMediaArray*))));           
hgs
parents:
diff changeset
   308
    mMediaFactory->createMediaItems(MEDIA_COUNT);
hgs
parents:
diff changeset
   309
    emit signalNewVideoList(mMediaFactory->copyOfMediaArray());
hgs
parents:
diff changeset
   310
    
hgs
parents:
diff changeset
   311
    QVERIFY(mTestObject->getVideoSizeFromIndex(-1) == 0);
hgs
parents:
diff changeset
   312
        
hgs
parents:
diff changeset
   313
    QVERIFY(mTestObject->getVideoSizeFromIndex(MEDIA_COUNT) == 0);
hgs
parents:
diff changeset
   314
    
hgs
parents:
diff changeset
   315
    QVERIFY(mTestObject->getVideoSizeFromIndex(0) == 1);
hgs
parents:
diff changeset
   316
    
hgs
parents:
diff changeset
   317
    QVERIFY(mTestObject->getVideoSizeFromIndex(MEDIA_COUNT - 1) == MEDIA_COUNT);
hgs
parents:
diff changeset
   318
    
hgs
parents:
diff changeset
   319
    // data does not exist
34
hgs
parents: 30
diff changeset
   320
    mTestObject->mMediaData.clear();
30
hgs
parents:
diff changeset
   321
    mMediaFactory->removeArray();
hgs
parents:
diff changeset
   322
    mMediaFactory->createMediaItems(MEDIA_COUNT, MediaDataId);    
hgs
parents:
diff changeset
   323
    emit signalNewVideoList(mMediaFactory->copyOfMediaArray());
hgs
parents:
diff changeset
   324
    
hgs
parents:
diff changeset
   325
    QVERIFY(mTestObject->getVideoSizeFromIndex(-1) == 0);
hgs
parents:
diff changeset
   326
            
hgs
parents:
diff changeset
   327
    QVERIFY(mTestObject->getVideoSizeFromIndex(MEDIA_COUNT) == 0);
hgs
parents:
diff changeset
   328
    
hgs
parents:
diff changeset
   329
    QVERIFY(mTestObject->getVideoSizeFromIndex(0) == 0);
hgs
parents:
diff changeset
   330
    
hgs
parents:
diff changeset
   331
    QVERIFY(mTestObject->getVideoSizeFromIndex(MEDIA_COUNT - 1) == 0);
hgs
parents:
diff changeset
   332
    
hgs
parents:
diff changeset
   333
    disconnect(this, SIGNAL(signalNewVideoList(CMPXMediaArray*)), mTestObject, SLOT(newVideoListSlot(CMPXMediaArray*)));  
hgs
parents:
diff changeset
   334
}
hgs
parents:
diff changeset
   335
hgs
parents:
diff changeset
   336
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
   337
// testGetVideoAgeProfileFromIndex
hgs
parents:
diff changeset
   338
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
   339
//
hgs
parents:
diff changeset
   340
void TestVideoModel_p::testGetVideoAgeProfileFromIndex()
hgs
parents:
diff changeset
   341
{
hgs
parents:
diff changeset
   342
    QVERIFY(mTestObject->getVideoAgeProfileFromIndex(0) == 0);
hgs
parents:
diff changeset
   343
    QVERIFY(mTestObject->getVideoAgeProfileFromIndex(-1) == 0);
hgs
parents:
diff changeset
   344
    
hgs
parents:
diff changeset
   345
    mMediaFactory->removeArray();
hgs
parents:
diff changeset
   346
    QVERIFY(connect(this, SIGNAL(signalNewVideoList(CMPXMediaArray*)), mTestObject, SLOT(newVideoListSlot(CMPXMediaArray*))));           
hgs
parents:
diff changeset
   347
    mMediaFactory->createMediaItems(MEDIA_COUNT);
hgs
parents:
diff changeset
   348
    emit signalNewVideoList(mMediaFactory->copyOfMediaArray());
hgs
parents:
diff changeset
   349
        
hgs
parents:
diff changeset
   350
    QVERIFY(mTestObject->getVideoAgeProfileFromIndex(-1) == 0);
hgs
parents:
diff changeset
   351
            
hgs
parents:
diff changeset
   352
    QVERIFY(mTestObject->getVideoAgeProfileFromIndex(MEDIA_COUNT) == 0);
hgs
parents:
diff changeset
   353
    
hgs
parents:
diff changeset
   354
    quint32 excepted = (0%5) + 1;
hgs
parents:
diff changeset
   355
    
hgs
parents:
diff changeset
   356
    QVERIFY(mTestObject->getVideoAgeProfileFromIndex(0) == excepted);
hgs
parents:
diff changeset
   357
    
hgs
parents:
diff changeset
   358
    excepted = ((MEDIA_COUNT - 1)%5) + 1;
hgs
parents:
diff changeset
   359
    QVERIFY(mTestObject->getVideoAgeProfileFromIndex(MEDIA_COUNT - 1) == excepted);
hgs
parents:
diff changeset
   360
    
hgs
parents:
diff changeset
   361
    // data does not exist
34
hgs
parents: 30
diff changeset
   362
    mTestObject->mMediaData.clear();
30
hgs
parents:
diff changeset
   363
    mMediaFactory->removeArray();
hgs
parents:
diff changeset
   364
    mMediaFactory->createMediaItems(MEDIA_COUNT, MediaDataId);    
hgs
parents:
diff changeset
   365
    emit signalNewVideoList(mMediaFactory->copyOfMediaArray());
hgs
parents:
diff changeset
   366
    
hgs
parents:
diff changeset
   367
    QVERIFY(mTestObject->getVideoAgeProfileFromIndex(-1) == 0);
hgs
parents:
diff changeset
   368
                
hgs
parents:
diff changeset
   369
    QVERIFY(mTestObject->getVideoAgeProfileFromIndex(MEDIA_COUNT) == 0);
hgs
parents:
diff changeset
   370
    
hgs
parents:
diff changeset
   371
    QVERIFY(mTestObject->getVideoAgeProfileFromIndex(0) == 0);
hgs
parents:
diff changeset
   372
hgs
parents:
diff changeset
   373
    QVERIFY(mTestObject->getVideoAgeProfileFromIndex(MEDIA_COUNT - 1) == 0);
hgs
parents:
diff changeset
   374
         
hgs
parents:
diff changeset
   375
    disconnect(this, SIGNAL(signalNewVideoList(CMPXMediaArray*)), mTestObject, SLOT(newVideoListSlot(CMPXMediaArray*)));
hgs
parents:
diff changeset
   376
}
hgs
parents:
diff changeset
   377
hgs
parents:
diff changeset
   378
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
   379
// testGetVideodurationFromIndex
hgs
parents:
diff changeset
   380
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
   381
//
hgs
parents:
diff changeset
   382
void TestVideoModel_p::testGetVideodurationFromIndex()
hgs
parents:
diff changeset
   383
{
hgs
parents:
diff changeset
   384
    QVERIFY(mTestObject->getVideodurationFromIndex(0) == 0);
hgs
parents:
diff changeset
   385
    QVERIFY(mTestObject->getVideodurationFromIndex(-1) == 0);
hgs
parents:
diff changeset
   386
    
hgs
parents:
diff changeset
   387
    mMediaFactory->removeArray();
hgs
parents:
diff changeset
   388
    QVERIFY(connect(this, SIGNAL(signalNewVideoList(CMPXMediaArray*)), mTestObject, SLOT(newVideoListSlot(CMPXMediaArray*))));           
hgs
parents:
diff changeset
   389
    mMediaFactory->createMediaItems(MEDIA_COUNT);
hgs
parents:
diff changeset
   390
    emit signalNewVideoList(mMediaFactory->copyOfMediaArray());
hgs
parents:
diff changeset
   391
    
hgs
parents:
diff changeset
   392
    QVERIFY(mTestObject->getVideodurationFromIndex(-1) == 0);
hgs
parents:
diff changeset
   393
        
hgs
parents:
diff changeset
   394
    QVERIFY(mTestObject->getVideodurationFromIndex(MEDIA_COUNT) == 0);
hgs
parents:
diff changeset
   395
    
hgs
parents:
diff changeset
   396
    QVERIFY(mTestObject->getVideodurationFromIndex(0) == 1);
hgs
parents:
diff changeset
   397
    
hgs
parents:
diff changeset
   398
    QVERIFY(mTestObject->getVideodurationFromIndex(MEDIA_COUNT - 1) == MEDIA_COUNT );
hgs
parents:
diff changeset
   399
    
hgs
parents:
diff changeset
   400
    // data does not exist
34
hgs
parents: 30
diff changeset
   401
    mTestObject->mMediaData.clear();
30
hgs
parents:
diff changeset
   402
    mMediaFactory->removeArray();
hgs
parents:
diff changeset
   403
    mMediaFactory->createMediaItems(MEDIA_COUNT, MediaDataId);    
hgs
parents:
diff changeset
   404
    emit signalNewVideoList(mMediaFactory->copyOfMediaArray());
hgs
parents:
diff changeset
   405
    
hgs
parents:
diff changeset
   406
    QVERIFY(mTestObject->getVideodurationFromIndex(-1) == 0);
hgs
parents:
diff changeset
   407
            
hgs
parents:
diff changeset
   408
    QVERIFY(mTestObject->getVideodurationFromIndex(MEDIA_COUNT) == 0);
hgs
parents:
diff changeset
   409
    
hgs
parents:
diff changeset
   410
    QVERIFY(mTestObject->getVideodurationFromIndex(0) == 0);
hgs
parents:
diff changeset
   411
    
hgs
parents:
diff changeset
   412
    QVERIFY(mTestObject->getVideodurationFromIndex(MEDIA_COUNT - 1) == 0);
hgs
parents:
diff changeset
   413
    
hgs
parents:
diff changeset
   414
    disconnect(this, SIGNAL(signalNewVideoList(CMPXMediaArray*)), mTestObject, SLOT(newVideoListSlot(CMPXMediaArray*)));
hgs
parents:
diff changeset
   415
}
hgs
parents:
diff changeset
   416
hgs
parents:
diff changeset
   417
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
   418
// testGetVideoDateFromIndex
hgs
parents:
diff changeset
   419
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
   420
//
hgs
parents:
diff changeset
   421
void TestVideoModel_p::testGetVideoDateFromIndex()
hgs
parents:
diff changeset
   422
{
hgs
parents:
diff changeset
   423
    QDateTime excepted;
hgs
parents:
diff changeset
   424
    QVERIFY(mTestObject->getVideoDateFromIndex(0) == excepted);
hgs
parents:
diff changeset
   425
    QVERIFY(mTestObject->getVideoDateFromIndex(-1) == excepted);
hgs
parents:
diff changeset
   426
  
hgs
parents:
diff changeset
   427
    // test when data exists
hgs
parents:
diff changeset
   428
    mMediaFactory->removeArray();
hgs
parents:
diff changeset
   429
    QVERIFY(connect(this, SIGNAL(signalNewVideoList(CMPXMediaArray*)), mTestObject, SLOT(newVideoListSlot(CMPXMediaArray*))));          
hgs
parents:
diff changeset
   430
    mMediaFactory->createMediaItems(MEDIA_COUNT);
hgs
parents:
diff changeset
   431
    emit signalNewVideoList(mMediaFactory->copyOfMediaArray());
hgs
parents:
diff changeset
   432
      
hgs
parents:
diff changeset
   433
    QVERIFY(mTestObject->getVideoDateFromIndex(-1) == excepted);
hgs
parents:
diff changeset
   434
          
hgs
parents:
diff changeset
   435
    QVERIFY(mTestObject->getVideoDateFromIndex(MEDIA_COUNT) == excepted);
hgs
parents:
diff changeset
   436
  
hgs
parents:
diff changeset
   437
    excepted = QDateTime(QDate(2009, 1, 1), QTime(1,1,1,1));
hgs
parents:
diff changeset
   438
  
hgs
parents:
diff changeset
   439
    QCOMPARE(mTestObject->getVideoDateFromIndex(0), excepted);
hgs
parents:
diff changeset
   440
  
hgs
parents:
diff changeset
   441
    excepted = QDateTime(QDate(2009, MEDIA_COUNT, MEDIA_COUNT), QTime(MEDIA_COUNT,MEDIA_COUNT,MEDIA_COUNT,MEDIA_COUNT));
hgs
parents:
diff changeset
   442
    
hgs
parents:
diff changeset
   443
    QCOMPARE(mTestObject->getVideoDateFromIndex(MEDIA_COUNT - 1), excepted);
hgs
parents:
diff changeset
   444
  
hgs
parents:
diff changeset
   445
    // data does not exist
34
hgs
parents: 30
diff changeset
   446
    mTestObject->mMediaData.clear();
30
hgs
parents:
diff changeset
   447
    mMediaFactory->removeArray();
hgs
parents:
diff changeset
   448
    mMediaFactory->createMediaItems(MEDIA_COUNT, MediaDataId);    
hgs
parents:
diff changeset
   449
    emit signalNewVideoList(mMediaFactory->copyOfMediaArray());
hgs
parents:
diff changeset
   450
    
hgs
parents:
diff changeset
   451
    excepted = QDateTime();
hgs
parents:
diff changeset
   452
    QVERIFY(mTestObject->getVideoDateFromIndex(-1) == excepted);         
hgs
parents:
diff changeset
   453
    QVERIFY(mTestObject->getVideoDateFromIndex(MEDIA_COUNT) == excepted);
hgs
parents:
diff changeset
   454
    QVERIFY(mTestObject->getVideoDateFromIndex(0) == excepted);
hgs
parents:
diff changeset
   455
    QVERIFY(mTestObject->getVideoDateFromIndex(MEDIA_COUNT - 1) == excepted);
hgs
parents:
diff changeset
   456
    disconnect(this, SIGNAL(signalNewVideoList(CMPXMediaArray*)), mTestObject, SLOT(newVideoListSlot(CMPXMediaArray*)));
hgs
parents:
diff changeset
   457
}
hgs
parents:
diff changeset
   458
hgs
parents:
diff changeset
   459
// -----------------------------------------------------------------------------
34
hgs
parents: 30
diff changeset
   460
// testVideoMarkAndRestoreDeleted
hgs
parents: 30
diff changeset
   461
// -----------------------------------------------------------------------------
hgs
parents: 30
diff changeset
   462
//
hgs
parents: 30
diff changeset
   463
void TestVideoModel_p::testVideoMarkAndRestoreDeleted()
hgs
parents: 30
diff changeset
   464
{
hgs
parents: 30
diff changeset
   465
    
hgs
parents: 30
diff changeset
   466
    QVERIFY(connect(this, SIGNAL(signalNewVideoList(CMPXMediaArray*)), mTestObject, SLOT(newVideoListSlot(CMPXMediaArray*))));   
hgs
parents: 30
diff changeset
   467
    mMediaFactory->removeArray();
hgs
parents: 30
diff changeset
   468
    mMediaFactory->createMediaItems(MEDIA_COUNT);
hgs
parents: 30
diff changeset
   469
    emit signalNewVideoList(mMediaFactory->copyOfMediaArray());
hgs
parents: 30
diff changeset
   470
    
hgs
parents: 30
diff changeset
   471
    VideoListDataModel::mFirstInserted = -1;
hgs
parents: 30
diff changeset
   472
    VideoListDataModel::mLastInserted = -1;
hgs
parents: 30
diff changeset
   473
    QList<TMPXItemId> idsToRestore;
hgs
parents: 30
diff changeset
   474
    // mark few items to be removed then restore them 
hgs
parents: 30
diff changeset
   475
    // NOTE: since item marking decreases item count by one,
hgs
parents: 30
diff changeset
   476
    //       we need to mark items starting from biggest index,
hgs
parents: 30
diff changeset
   477
    //       otherwise we might end up to mark invalid items
hgs
parents: 30
diff changeset
   478
    QModelIndex index = mStubModel->index(MEDIA_COUNT-1, 0, QModelIndex());
hgs
parents: 30
diff changeset
   479
    idsToRestore.append(mTestObject->markVideoRemoved(index));    
hgs
parents: 30
diff changeset
   480
    index = mStubModel->index(MEDIA_COUNT / 2, 0, QModelIndex());
hgs
parents: 30
diff changeset
   481
    idsToRestore.append(mTestObject->markVideoRemoved(index));
hgs
parents: 30
diff changeset
   482
    index = mStubModel->index(0, 0, QModelIndex());
hgs
parents: 30
diff changeset
   483
    idsToRestore.append(mTestObject->markVideoRemoved(index));
hgs
parents: 30
diff changeset
   484
    
hgs
parents: 30
diff changeset
   485
    QVERIFY(mTestObject->getVideoCount() == (MEDIA_COUNT - 3) );
hgs
parents: 30
diff changeset
   486
    
hgs
parents: 30
diff changeset
   487
    mTestObject->restoreRemoved(&idsToRestore);
hgs
parents: 30
diff changeset
   488
    QVERIFY(VideoListDataModel::mFirstInserted == MEDIA_COUNT - 3);
hgs
parents: 30
diff changeset
   489
    QVERIFY(VideoListDataModel::mLastInserted == MEDIA_COUNT - 1);
hgs
parents: 30
diff changeset
   490
    QVERIFY(mTestObject->getVideoCount() == MEDIA_COUNT);
hgs
parents: 30
diff changeset
   491
    
hgs
parents: 30
diff changeset
   492
    idsToRestore.clear();
hgs
parents: 30
diff changeset
   493
    mMediaFactory->removeArray();
hgs
parents: 30
diff changeset
   494
    mMediaFactory->createMediaItems(MEDIA_COUNT);
hgs
parents: 30
diff changeset
   495
    emit signalNewVideoList(mMediaFactory->copyOfMediaArray());
hgs
parents: 30
diff changeset
   496
    VideoListDataModel::mFirstInserted = -1;
hgs
parents: 30
diff changeset
   497
    VideoListDataModel::mLastInserted = -1;
hgs
parents: 30
diff changeset
   498
    
hgs
parents: 30
diff changeset
   499
    // mark few items to be removed then restore them 
hgs
parents: 30
diff changeset
   500
    index = mStubModel->index(MEDIA_COUNT-1, 0, QModelIndex());
hgs
parents: 30
diff changeset
   501
    idsToRestore.append(mTestObject->markVideoRemoved(index));    
hgs
parents: 30
diff changeset
   502
    index = mStubModel->index(MEDIA_COUNT / 2, 0, QModelIndex());
hgs
parents: 30
diff changeset
   503
    idsToRestore.append(mTestObject->markVideoRemoved(index));
hgs
parents: 30
diff changeset
   504
    index = mStubModel->index(0, 0, QModelIndex());
hgs
parents: 30
diff changeset
   505
    idsToRestore.append(mTestObject->markVideoRemoved(index));
hgs
parents: 30
diff changeset
   506
 
hgs
parents: 30
diff changeset
   507
    QVERIFY(mTestObject->getVideoCount() == (MEDIA_COUNT - 3) );
hgs
parents: 30
diff changeset
   508
    mTestObject->restoreRemoved(&idsToRestore);
hgs
parents: 30
diff changeset
   509
    QVERIFY(VideoListDataModel::mFirstInserted == MEDIA_COUNT - 3);
hgs
parents: 30
diff changeset
   510
    QVERIFY(VideoListDataModel::mLastInserted == MEDIA_COUNT - 1);
hgs
parents: 30
diff changeset
   511
    
hgs
parents: 30
diff changeset
   512
    VideoListDataModel::mFirstInserted = -1;
hgs
parents: 30
diff changeset
   513
    VideoListDataModel::mLastInserted = -1;
hgs
parents: 30
diff changeset
   514
    idsToRestore.clear();
hgs
parents: 30
diff changeset
   515
    index = mStubModel->index(MEDIA_COUNT, 0, QModelIndex());
hgs
parents: 30
diff changeset
   516
    idsToRestore.append(mTestObject->markVideoRemoved(index));    
hgs
parents: 30
diff changeset
   517
    mTestObject->restoreRemoved(&idsToRestore);
hgs
parents: 30
diff changeset
   518
    QVERIFY(VideoListDataModel::mFirstInserted == -1);
hgs
parents: 30
diff changeset
   519
    QVERIFY(VideoListDataModel::mLastInserted == -1);
hgs
parents: 30
diff changeset
   520
    
hgs
parents: 30
diff changeset
   521
    disconnect(this, SIGNAL(signalNewVideoList(CMPXMediaArray*)), mTestObject, SLOT(newVideoListSlot(CMPXMediaArray*)));
hgs
parents: 30
diff changeset
   522
}
hgs
parents: 30
diff changeset
   523
hgs
parents: 30
diff changeset
   524
// -----------------------------------------------------------------------------
30
hgs
parents:
diff changeset
   525
// testGetFilePathFromIndex
hgs
parents:
diff changeset
   526
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
   527
//
34
hgs
parents: 30
diff changeset
   528
30
hgs
parents:
diff changeset
   529
void TestVideoModel_p::testGetFilePathFromIndex()
hgs
parents:
diff changeset
   530
{
hgs
parents:
diff changeset
   531
    QString path = mTestObject->getFilePathFromIndex(0);
hgs
parents:
diff changeset
   532
    QVERIFY(path.isNull());
hgs
parents:
diff changeset
   533
    path = mTestObject->getFilePathFromIndex(-1);
hgs
parents:
diff changeset
   534
    QVERIFY(path.isNull());
hgs
parents:
diff changeset
   535
    
hgs
parents:
diff changeset
   536
    mMediaFactory->removeArray();
hgs
parents:
diff changeset
   537
    QVERIFY(connect(this, SIGNAL(signalNewVideoList(CMPXMediaArray*)), mTestObject, SLOT(newVideoListSlot(CMPXMediaArray*))));           
hgs
parents:
diff changeset
   538
    mMediaFactory->createMediaItems(MEDIA_COUNT);
hgs
parents:
diff changeset
   539
    emit signalNewVideoList(mMediaFactory->copyOfMediaArray());
hgs
parents:
diff changeset
   540
    
hgs
parents:
diff changeset
   541
    path = mTestObject->getFilePathFromIndex(-1);
hgs
parents:
diff changeset
   542
    QVERIFY(path.isNull());
hgs
parents:
diff changeset
   543
    
hgs
parents:
diff changeset
   544
    path = mTestObject->getFilePathFromIndex(0);
hgs
parents:
diff changeset
   545
    QCOMPARE(path, gQTMediaPathPrefix + "0");
hgs
parents:
diff changeset
   546
    
hgs
parents:
diff changeset
   547
    // data does not exist
34
hgs
parents: 30
diff changeset
   548
    mTestObject->mMediaData.clear();
30
hgs
parents:
diff changeset
   549
    mMediaFactory->removeArray();
hgs
parents:
diff changeset
   550
    mMediaFactory->createMediaItems(MEDIA_COUNT, MediaDataId);    
hgs
parents:
diff changeset
   551
    emit signalNewVideoList(mMediaFactory->copyOfMediaArray());
hgs
parents:
diff changeset
   552
    
hgs
parents:
diff changeset
   553
    path = mTestObject->getFilePathFromIndex(0);
hgs
parents:
diff changeset
   554
    QVERIFY(path.isNull());
hgs
parents:
diff changeset
   555
    
hgs
parents:
diff changeset
   556
    disconnect(this, SIGNAL(signalNewVideoList(CMPXMediaArray*)), mTestObject, SLOT(newVideoListSlot(CMPXMediaArray*)));
hgs
parents:
diff changeset
   557
}
hgs
parents:
diff changeset
   558
hgs
parents:
diff changeset
   559
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
   560
// testGetFilePathForId
hgs
parents:
diff changeset
   561
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
   562
//
hgs
parents:
diff changeset
   563
void TestVideoModel_p::testGetFilePathForId()
hgs
parents:
diff changeset
   564
{
hgs
parents:
diff changeset
   565
    QString path = mTestObject->getFilePathForId(TMPXItemId(0,0));
hgs
parents:
diff changeset
   566
    QVERIFY(path.isNull());
hgs
parents:
diff changeset
   567
    path = mTestObject->getFilePathForId(TMPXItemId::InvalidId());
hgs
parents:
diff changeset
   568
    QVERIFY(path.isNull());
hgs
parents:
diff changeset
   569
    
hgs
parents:
diff changeset
   570
    mMediaFactory->removeArray();
hgs
parents:
diff changeset
   571
    QVERIFY(connect(this, SIGNAL(signalNewVideoList(CMPXMediaArray*)), mTestObject, SLOT(newVideoListSlot(CMPXMediaArray*))));           
hgs
parents:
diff changeset
   572
    mMediaFactory->createMediaItems(MEDIA_COUNT);
hgs
parents:
diff changeset
   573
    emit signalNewVideoList(mMediaFactory->copyOfMediaArray());
hgs
parents:
diff changeset
   574
    
hgs
parents:
diff changeset
   575
    path = mTestObject->getFilePathForId(TMPXItemId::InvalidId());
hgs
parents:
diff changeset
   576
    QVERIFY(path.isNull());
hgs
parents:
diff changeset
   577
    
hgs
parents:
diff changeset
   578
    path = mTestObject->getFilePathForId(TMPXItemId(0,0));
hgs
parents:
diff changeset
   579
    QCOMPARE(path, gQTMediaPathPrefix + "0");
hgs
parents:
diff changeset
   580
    
hgs
parents:
diff changeset
   581
    // data does not exist
34
hgs
parents: 30
diff changeset
   582
    mTestObject->mMediaData.clear();
30
hgs
parents:
diff changeset
   583
    mMediaFactory->removeArray();
36
hgs
parents: 35
diff changeset
   584
    mMediaFactory->createMediaItems(MEDIA_COUNT, MediaDataId);
30
hgs
parents:
diff changeset
   585
    emit signalNewVideoList(mMediaFactory->copyOfMediaArray());
hgs
parents:
diff changeset
   586
    
hgs
parents:
diff changeset
   587
    path = mTestObject->getFilePathForId(TMPXItemId(0,0));
hgs
parents:
diff changeset
   588
    QVERIFY(path.isNull());
hgs
parents:
diff changeset
   589
    
hgs
parents:
diff changeset
   590
    disconnect(this, SIGNAL(signalNewVideoList(CMPXMediaArray*)), mTestObject, SLOT(newVideoListSlot(CMPXMediaArray*)));
hgs
parents:
diff changeset
   591
}
hgs
parents:
diff changeset
   592
hgs
parents:
diff changeset
   593
// -----------------------------------------------------------------------------
35
hgs
parents: 34
diff changeset
   594
// testBelongsToAlbum
hgs
parents: 34
diff changeset
   595
// -----------------------------------------------------------------------------
hgs
parents: 34
diff changeset
   596
//
hgs
parents: 34
diff changeset
   597
void TestVideoModel_p::testBelongsToAlbum()
hgs
parents: 34
diff changeset
   598
{
hgs
parents: 34
diff changeset
   599
    TMPXItemId id(1,0);
hgs
parents: 34
diff changeset
   600
    // invalid id, no album setted
hgs
parents: 34
diff changeset
   601
    QVERIFY(!mTestObject->belongsToAlbum(id));
hgs
parents: 34
diff changeset
   602
    
hgs
parents: 34
diff changeset
   603
    mTestObject->setAlbumInUse(TMPXItemId(1,2));
hgs
parents: 34
diff changeset
   604
    
hgs
parents: 34
diff changeset
   605
    // invalid id, album setted
hgs
parents: 34
diff changeset
   606
    QVERIFY(!mTestObject->belongsToAlbum(id));
hgs
parents: 34
diff changeset
   607
    
hgs
parents: 34
diff changeset
   608
    QSet<TMPXItemId> items;
hgs
parents: 34
diff changeset
   609
    items.insert(id);
hgs
parents: 34
diff changeset
   610
    mTestObject->mAlbumData[TMPXItemId(1,2)] = items;
hgs
parents: 34
diff changeset
   611
    
hgs
parents: 34
diff changeset
   612
    // invalid id, album setted, items exist 
hgs
parents: 34
diff changeset
   613
    QVERIFY(mTestObject->belongsToAlbum(id));
hgs
parents: 34
diff changeset
   614
    
hgs
parents: 34
diff changeset
   615
    // no invalid id, item does not exist
hgs
parents: 34
diff changeset
   616
    QVERIFY(!mTestObject->belongsToAlbum(id, TMPXItemId(2,2)));
hgs
parents: 34
diff changeset
   617
    
hgs
parents: 34
diff changeset
   618
    // no invalid id, items exist 
hgs
parents: 34
diff changeset
   619
    QVERIFY(mTestObject->belongsToAlbum(id, TMPXItemId(1,2)));
hgs
parents: 34
diff changeset
   620
}
hgs
parents: 34
diff changeset
   621
    
hgs
parents: 34
diff changeset
   622
    
hgs
parents: 34
diff changeset
   623
// -----------------------------------------------------------------------------
hgs
parents: 34
diff changeset
   624
// testRemoveItemsFromAlbum
hgs
parents: 34
diff changeset
   625
// -----------------------------------------------------------------------------
hgs
parents: 34
diff changeset
   626
//
hgs
parents: 34
diff changeset
   627
void TestVideoModel_p::testRemoveItemsFromAlbum()
hgs
parents: 34
diff changeset
   628
{    
hgs
parents: 34
diff changeset
   629
    TMPXItemId albumId(1,2);
hgs
parents: 34
diff changeset
   630
    QList<TMPXItemId> ids;
hgs
parents: 34
diff changeset
   631
    // album does not exists
hgs
parents: 34
diff changeset
   632
    QVERIFY(mTestObject->removeItemsFromAlbum(albumId, ids) == 0);
hgs
parents: 34
diff changeset
   633
    
hgs
parents: 34
diff changeset
   634
    QSet<TMPXItemId> items;
hgs
parents: 34
diff changeset
   635
    items.insert(TMPXItemId(1,0));
hgs
parents: 34
diff changeset
   636
    items.insert(TMPXItemId(3,0));
hgs
parents: 34
diff changeset
   637
    mTestObject->mAlbumData[albumId] = items;
hgs
parents: 34
diff changeset
   638
    
hgs
parents: 34
diff changeset
   639
    ids.append(TMPXItemId(2,0));
hgs
parents: 34
diff changeset
   640
    ids.append(TMPXItemId(3,0));
hgs
parents: 34
diff changeset
   641
    // provided list contains and does not contain items in album
hgs
parents: 34
diff changeset
   642
    QVERIFY(mTestObject->removeItemsFromAlbum(albumId, ids) == 1);
hgs
parents: 34
diff changeset
   643
    
hgs
parents: 34
diff changeset
   644
}
hgs
parents: 34
diff changeset
   645
hgs
parents: 34
diff changeset
   646
// -----------------------------------------------------------------------------
30
hgs
parents:
diff changeset
   647
// testThumbnailsFetchedSlot
hgs
parents:
diff changeset
   648
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
   649
//
hgs
parents:
diff changeset
   650
void TestVideoModel_p::testThumbnailsFetchedSlot()
hgs
parents:
diff changeset
   651
{
hgs
parents:
diff changeset
   652
    QVERIFY(connect(this, SIGNAL(signalThumbnailsFetched(QList<TMPXItemId>)), mTestObject, SLOT(thumbnailsFetchedSlot(QList<TMPXItemId>))));      
hgs
parents:
diff changeset
   653
    
hgs
parents:
diff changeset
   654
    QSignalSpy spysignal(mTestObject, SIGNAL(dataChanged(const QModelIndex&, const QModelIndex&)));
hgs
parents:
diff changeset
   655
    mMediaFactory->removeArray();
hgs
parents:
diff changeset
   656
    
hgs
parents:
diff changeset
   657
    QList<TMPXItemId> mediaIds;
hgs
parents:
diff changeset
   658
    
hgs
parents:
diff changeset
   659
    // test no videos
hgs
parents:
diff changeset
   660
    mediaIds.append(TMPXItemId(0, 0));
hgs
parents:
diff changeset
   661
    emit signalThumbnailsFetched(mediaIds);
hgs
parents:
diff changeset
   662
    QVERIFY(spysignal.count() == 0);
hgs
parents:
diff changeset
   663
    mediaIds.clear();
hgs
parents:
diff changeset
   664
hgs
parents:
diff changeset
   665
    QVERIFY(connect(this, SIGNAL(signalNewVideoList(CMPXMediaArray*)), mTestObject, SLOT(newVideoListSlot(CMPXMediaArray*))));           
hgs
parents:
diff changeset
   666
    mMediaFactory->createMediaItems(MEDIA_COUNT);
hgs
parents:
diff changeset
   667
    emit signalNewVideoList(mMediaFactory->copyOfMediaArray());
hgs
parents:
diff changeset
   668
    
hgs
parents:
diff changeset
   669
    // test invalid ids
hgs
parents:
diff changeset
   670
    mediaIds.append(TMPXItemId::InvalidId());
hgs
parents:
diff changeset
   671
    emit signalThumbnailsFetched(mediaIds);
hgs
parents:
diff changeset
   672
    QVERIFY(spysignal.count() == 0);
hgs
parents:
diff changeset
   673
    spysignal.clear();
hgs
parents:
diff changeset
   674
    mediaIds.clear();
hgs
parents:
diff changeset
   675
    mediaIds.append(TMPXItemId(MEDIA_COUNT, 0));
hgs
parents:
diff changeset
   676
    emit signalThumbnailsFetched(mediaIds);
hgs
parents:
diff changeset
   677
    QVERIFY(spysignal.count() == 0);
hgs
parents:
diff changeset
   678
    mediaIds.clear();
hgs
parents:
diff changeset
   679
    mediaIds.append(TMPXItemId(MEDIA_COUNT + 1, 0));
hgs
parents:
diff changeset
   680
    emit signalThumbnailsFetched(mediaIds);
hgs
parents:
diff changeset
   681
    QVERIFY(spysignal.count() == 0);
hgs
parents:
diff changeset
   682
    mediaIds.clear();
hgs
parents:
diff changeset
   683
    
hgs
parents:
diff changeset
   684
    // test correct ids
hgs
parents:
diff changeset
   685
    mediaIds.append(TMPXItemId(0, 0));
hgs
parents:
diff changeset
   686
    emit signalThumbnailsFetched(mediaIds);
hgs
parents:
diff changeset
   687
    QVERIFY(spysignal.count() == 1);
hgs
parents:
diff changeset
   688
    QVERIFY(spysignal.value(0).at(0).toInt() == 0);
hgs
parents:
diff changeset
   689
    spysignal.clear();
hgs
parents:
diff changeset
   690
    mediaIds.clear();
hgs
parents:
diff changeset
   691
    mediaIds.append(TMPXItemId(1, 0));
hgs
parents:
diff changeset
   692
    emit signalThumbnailsFetched(mediaIds);
hgs
parents:
diff changeset
   693
    QVERIFY(spysignal.count() == 1);
hgs
parents:
diff changeset
   694
    spysignal.clear();
hgs
parents:
diff changeset
   695
    mediaIds.clear();
hgs
parents:
diff changeset
   696
    
hgs
parents:
diff changeset
   697
    mediaIds.append(TMPXItemId(MEDIA_COUNT/2, 0));
hgs
parents:
diff changeset
   698
    emit signalThumbnailsFetched(mediaIds);
hgs
parents:
diff changeset
   699
    QVERIFY(spysignal.count() == 1);
hgs
parents:
diff changeset
   700
    
hgs
parents:
diff changeset
   701
    disconnect(this, SIGNAL(signalNewVideoList(CMPXMediaArray*)), mTestObject, SLOT(newVideoListSlot(CMPXMediaArray*)));  
hgs
parents:
diff changeset
   702
    disconnect(this, SIGNAL(signalThumbnailsFetched(QList<TMPXItemId>)), mTestObject, SLOT(thumbnailsFetchedSlot(QList<TMPXItemId>)));
hgs
parents:
diff changeset
   703
}
hgs
parents:
diff changeset
   704
hgs
parents:
diff changeset
   705
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
   706
// testNewVideoListSlot
hgs
parents:
diff changeset
   707
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
   708
//
hgs
parents:
diff changeset
   709
void TestVideoModel_p::testNewVideoListSlot()
hgs
parents:
diff changeset
   710
{
hgs
parents:
diff changeset
   711
    QVERIFY(mTestObject->initialize() == 0);
hgs
parents:
diff changeset
   712
    
hgs
parents:
diff changeset
   713
    QVERIFY(connect(this, SIGNAL(signalNewVideoList(CMPXMediaArray*)), mTestObject, SLOT(newVideoListSlot(CMPXMediaArray*))));      
hgs
parents:
diff changeset
   714
34
hgs
parents: 30
diff changeset
   715
    VideoListDataModel::mFirstInserted = -1;
hgs
parents: 30
diff changeset
   716
    VideoListDataModel::mLastInserted = -1;
hgs
parents: 30
diff changeset
   717
    VideoListDataModel::mFirstRemoved = -1;
hgs
parents: 30
diff changeset
   718
    VideoListDataModel::mLastRemoved = -1;    
hgs
parents: 30
diff changeset
   719
    
30
hgs
parents:
diff changeset
   720
    QSignalSpy spyModelReady(mStubModel, SIGNAL(modelReady()));
hgs
parents:
diff changeset
   721
    
hgs
parents:
diff changeset
   722
    mMediaFactory->removeArray();
hgs
parents:
diff changeset
   723
    mMediaFactory->createMediaItems(MEDIA_COUNT);
hgs
parents:
diff changeset
   724
    // media-array does not exist
hgs
parents:
diff changeset
   725
    emit signalNewVideoList(mMediaFactory->copyOfMediaArray());
hgs
parents:
diff changeset
   726
34
hgs
parents: 30
diff changeset
   727
    QVERIFY(VideoListDataModel::mFirstInserted == 0);
hgs
parents: 30
diff changeset
   728
    QVERIFY(VideoListDataModel::mLastInserted == MEDIA_COUNT - 1);
hgs
parents: 30
diff changeset
   729
    QVERIFY(VideoListDataModel::mFirstRemoved == -1);
hgs
parents: 30
diff changeset
   730
    QVERIFY(VideoListDataModel::mLastRemoved == -1); 
30
hgs
parents:
diff changeset
   731
    QCOMPARE(spyModelReady.count(), 1);
hgs
parents:
diff changeset
   732
    spyModelReady.clear();
34
hgs
parents: 30
diff changeset
   733
    VideoListDataModel::mFirstInserted = -1;
hgs
parents: 30
diff changeset
   734
    VideoListDataModel::mLastInserted = -1;
hgs
parents: 30
diff changeset
   735
    VideoListDataModel::mFirstRemoved = -1;
hgs
parents: 30
diff changeset
   736
    VideoListDataModel::mLastRemoved = -1;   
30
hgs
parents:
diff changeset
   737
    
hgs
parents:
diff changeset
   738
    QVERIFY(mTestObject->initialize() == 0);
hgs
parents:
diff changeset
   739
    
hgs
parents:
diff changeset
   740
    // providing null videolist
hgs
parents:
diff changeset
   741
    emit signalNewVideoList(0);
34
hgs
parents: 30
diff changeset
   742
    QVERIFY(VideoListDataModel::mFirstInserted == -1);
hgs
parents: 30
diff changeset
   743
    QVERIFY(VideoListDataModel::mLastInserted == -1);
hgs
parents: 30
diff changeset
   744
    QVERIFY(VideoListDataModel::mFirstRemoved == -1);
hgs
parents: 30
diff changeset
   745
    QVERIFY(VideoListDataModel::mLastRemoved == -1); 
30
hgs
parents:
diff changeset
   746
    QCOMPARE(spyModelReady.count(), 0);
34
hgs
parents: 30
diff changeset
   747
    VideoListDataModel::mFirstInserted = -1;
hgs
parents: 30
diff changeset
   748
    VideoListDataModel::mLastInserted = -1;
hgs
parents: 30
diff changeset
   749
    VideoListDataModel::mFirstRemoved = -1;
hgs
parents: 30
diff changeset
   750
    VideoListDataModel::mLastRemoved = -1;  
30
hgs
parents:
diff changeset
   751
    
hgs
parents:
diff changeset
   752
    // empty media-array
hgs
parents:
diff changeset
   753
    mMediaFactory->removeArray();
hgs
parents:
diff changeset
   754
    mMediaFactory->createMediaItems(0);
hgs
parents:
diff changeset
   755
    emit signalNewVideoList(mMediaFactory->copyOfMediaArray());
34
hgs
parents: 30
diff changeset
   756
  
hgs
parents: 30
diff changeset
   757
    QVERIFY(VideoListDataModel::mFirstInserted == -1);
hgs
parents: 30
diff changeset
   758
    QVERIFY(VideoListDataModel::mLastInserted == -1);
hgs
parents: 30
diff changeset
   759
    QVERIFY(VideoListDataModel::mFirstRemoved == -1);
hgs
parents: 30
diff changeset
   760
    QVERIFY(VideoListDataModel::mLastRemoved == -1); 
30
hgs
parents:
diff changeset
   761
    QCOMPARE(spyModelReady.count(), 1);
hgs
parents:
diff changeset
   762
    spyModelReady.clear();
34
hgs
parents: 30
diff changeset
   763
    VideoListDataModel::mFirstInserted = -1;
hgs
parents: 30
diff changeset
   764
    VideoListDataModel::mLastInserted = -1;
hgs
parents: 30
diff changeset
   765
    VideoListDataModel::mFirstRemoved = -1;
hgs
parents: 30
diff changeset
   766
    VideoListDataModel::mLastRemoved = -1;   
30
hgs
parents:
diff changeset
   767
    
hgs
parents:
diff changeset
   768
    // media-array exits
hgs
parents:
diff changeset
   769
    mMediaFactory->removeArray();
hgs
parents:
diff changeset
   770
    mMediaFactory->createMediaItems(MEDIA_COUNT);
hgs
parents:
diff changeset
   771
    emit signalNewVideoList(mMediaFactory->copyOfMediaArray());
34
hgs
parents: 30
diff changeset
   772
    QVERIFY(VideoListDataModel::mFirstInserted == -1);
hgs
parents: 30
diff changeset
   773
    QVERIFY(VideoListDataModel::mLastInserted == -1);
hgs
parents: 30
diff changeset
   774
    QVERIFY(VideoListDataModel::mFirstRemoved == -1);
hgs
parents: 30
diff changeset
   775
    QVERIFY(VideoListDataModel::mLastRemoved == -1); 
30
hgs
parents:
diff changeset
   776
    QCOMPARE(spyModelReady.count(), 1);
hgs
parents:
diff changeset
   777
    spyModelReady.clear();
34
hgs
parents: 30
diff changeset
   778
    VideoListDataModel::mFirstInserted = -1;
hgs
parents: 30
diff changeset
   779
    VideoListDataModel::mLastInserted = -1;
hgs
parents: 30
diff changeset
   780
    VideoListDataModel::mFirstRemoved = -1;
hgs
parents: 30
diff changeset
   781
    VideoListDataModel::mLastRemoved = -1;   
30
hgs
parents:
diff changeset
   782
    
hgs
parents:
diff changeset
   783
    disconnect(this, SIGNAL(signalNewVideoList(CMPXMediaArray*)), mTestObject, SLOT(newVideoListSlot(CMPXMediaArray*)));  
hgs
parents:
diff changeset
   784
}
hgs
parents:
diff changeset
   785
hgs
parents:
diff changeset
   786
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
   787
// testAppendVideoListSlot
hgs
parents:
diff changeset
   788
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
   789
//
hgs
parents:
diff changeset
   790
void TestVideoModel_p::testAppendVideoListSlot()
hgs
parents:
diff changeset
   791
{
hgs
parents:
diff changeset
   792
    QVERIFY(mTestObject->initialize() == 0);
hgs
parents:
diff changeset
   793
        
hgs
parents:
diff changeset
   794
    QVERIFY(connect(this, SIGNAL(signalAppendVideoList(CMPXMediaArray*)), mTestObject, SLOT(appendVideoListSlot(CMPXMediaArray*))));      
hgs
parents:
diff changeset
   795
    QVERIFY(connect(this, SIGNAL(signalNewVideoList(CMPXMediaArray*)), mTestObject, SLOT(newVideoListSlot(CMPXMediaArray*))));  
hgs
parents:
diff changeset
   796
    
34
hgs
parents: 30
diff changeset
   797
    QSignalSpy spyModelChanged(mStubModel, SIGNAL(modelChanged()));
hgs
parents: 30
diff changeset
   798
    
hgs
parents: 30
diff changeset
   799
    VideoListDataModel::mFirstInserted = -1;
hgs
parents: 30
diff changeset
   800
    VideoListDataModel::mLastInserted = -1;
30
hgs
parents:
diff changeset
   801
    
hgs
parents:
diff changeset
   802
    // append null
36
hgs
parents: 35
diff changeset
   803
    emit signalAppendVideoList(0);
34
hgs
parents: 30
diff changeset
   804
    QVERIFY(VideoListDataModel::mFirstInserted == -1);
hgs
parents: 30
diff changeset
   805
    QVERIFY(VideoListDataModel::mLastInserted == -1);
30
hgs
parents:
diff changeset
   806
    QVERIFY(mTestObject->getVideoCount() == 0);
34
hgs
parents: 30
diff changeset
   807
    QVERIFY(spyModelChanged.count() == 0);
30
hgs
parents:
diff changeset
   808
    
hgs
parents:
diff changeset
   809
    // append empty videolist
hgs
parents:
diff changeset
   810
    mMediaFactory->removeArray();
hgs
parents:
diff changeset
   811
    mMediaFactory->createMediaItems(0);
hgs
parents:
diff changeset
   812
    emit signalAppendVideoList(mMediaFactory->copyOfMediaArray()); 
34
hgs
parents: 30
diff changeset
   813
    QVERIFY(VideoListDataModel::mFirstInserted == -1);
hgs
parents: 30
diff changeset
   814
    QVERIFY(VideoListDataModel::mLastInserted == -1);
30
hgs
parents:
diff changeset
   815
    QVERIFY(mTestObject->getVideoCount() == 0);
34
hgs
parents: 30
diff changeset
   816
    QVERIFY(spyModelChanged.count() == 0);
30
hgs
parents:
diff changeset
   817
    
hgs
parents:
diff changeset
   818
    // send 10 videos
hgs
parents:
diff changeset
   819
    mMediaFactory->createMediaItems(10);
hgs
parents:
diff changeset
   820
    emit signalNewVideoList(mMediaFactory->copyOfMediaArray());
34
hgs
parents: 30
diff changeset
   821
    VideoListDataModel::mFirstInserted = -1;
hgs
parents: 30
diff changeset
   822
    VideoListDataModel::mLastInserted = -1;
30
hgs
parents:
diff changeset
   823
    
hgs
parents:
diff changeset
   824
    // append videolist containing less than existing
hgs
parents:
diff changeset
   825
    mMediaFactory->removeArray();
hgs
parents:
diff changeset
   826
    mMediaFactory->createMediaItems(3);
hgs
parents:
diff changeset
   827
    emit signalAppendVideoList(mMediaFactory->copyOfMediaArray()); 
34
hgs
parents: 30
diff changeset
   828
    QVERIFY(VideoListDataModel::mFirstInserted == -1);
hgs
parents: 30
diff changeset
   829
    QVERIFY(VideoListDataModel::mLastInserted == -1);
30
hgs
parents:
diff changeset
   830
    QVERIFY(mTestObject->getVideoCount() == 10);
34
hgs
parents: 30
diff changeset
   831
    QVERIFY(spyModelChanged.count() == 0);
30
hgs
parents:
diff changeset
   832
    
hgs
parents:
diff changeset
   833
    // reset data
hgs
parents:
diff changeset
   834
    mTestObject->mMediaData.clear();
hgs
parents:
diff changeset
   835
    
hgs
parents:
diff changeset
   836
    // append items with invalid ids:
34
hgs
parents: 30
diff changeset
   837
    // signals emitted (begin inserting is called), but items are really not appended
30
hgs
parents:
diff changeset
   838
    mMediaFactory->removeArray();
hgs
parents:
diff changeset
   839
    mMediaFactory->createMediaItems(3, MediaDataNone);
34
hgs
parents: 30
diff changeset
   840
    emit signalAppendVideoList(mMediaFactory->copyOfMediaArray());
hgs
parents: 30
diff changeset
   841
    QVERIFY(VideoListDataModel::mFirstInserted == 0);
hgs
parents: 30
diff changeset
   842
    QVERIFY(VideoListDataModel::mLastInserted == 2);
30
hgs
parents:
diff changeset
   843
    QVERIFY(mTestObject->getVideoCount() == 0);
34
hgs
parents: 30
diff changeset
   844
    QVERIFY(spyModelChanged.count() == 1); 
hgs
parents: 30
diff changeset
   845
    spyModelChanged.clear();
30
hgs
parents:
diff changeset
   846
hgs
parents:
diff changeset
   847
    // append items with iId2 == 1 && iId1 != KVcxMvcCategoryIdDownloads (==1) && iId1 != KVcxMvcCategoryIdCaptured (== 3)
hgs
parents:
diff changeset
   848
    mMediaFactory->removeArray();
hgs
parents:
diff changeset
   849
    mMediaFactory->createMediaItems(0);
hgs
parents:
diff changeset
   850
    TRAP_IGNORE(mMediaFactory->mediaArray()->AppendL(mMediaFactory->getMediaWithWantedIds(4, 1)));
hgs
parents:
diff changeset
   851
    TRAP_IGNORE(mMediaFactory->mediaArray()->AppendL(mMediaFactory->getMediaWithWantedIds(5, 1)));
hgs
parents:
diff changeset
   852
    emit signalAppendVideoList(mMediaFactory->copyOfMediaArray()); 
34
hgs
parents: 30
diff changeset
   853
hgs
parents: 30
diff changeset
   854
    QVERIFY(VideoListDataModel::mFirstInserted == 0);
hgs
parents: 30
diff changeset
   855
    QVERIFY(VideoListDataModel::mLastInserted == 1);
30
hgs
parents:
diff changeset
   856
    QVERIFY(mTestObject->getVideoCount() == 0);
34
hgs
parents: 30
diff changeset
   857
    QVERIFY(spyModelChanged.count() == 1); 
hgs
parents: 30
diff changeset
   858
    spyModelChanged.clear();
30
hgs
parents:
diff changeset
   859
    
hgs
parents:
diff changeset
   860
    // append correct items
hgs
parents:
diff changeset
   861
    mMediaFactory->removeArray();
hgs
parents:
diff changeset
   862
    mMediaFactory->createMediaItems(3);
hgs
parents:
diff changeset
   863
    emit signalAppendVideoList(mMediaFactory->copyOfMediaArray()); 
34
hgs
parents: 30
diff changeset
   864
    QVERIFY(VideoListDataModel::mFirstInserted == 0);
hgs
parents: 30
diff changeset
   865
    QVERIFY(VideoListDataModel::mLastInserted == 2);
30
hgs
parents:
diff changeset
   866
    QVERIFY(mTestObject->getVideoCount() == 3);
34
hgs
parents: 30
diff changeset
   867
    QVERIFY(spyModelChanged.count() == 1); 
hgs
parents: 30
diff changeset
   868
    spyModelChanged.clear();   
30
hgs
parents:
diff changeset
   869
       
hgs
parents:
diff changeset
   870
    // append more to existing
hgs
parents:
diff changeset
   871
    mMediaFactory->removeArray();
hgs
parents:
diff changeset
   872
    mMediaFactory->createMediaItems(10);
hgs
parents:
diff changeset
   873
    emit signalAppendVideoList(mMediaFactory->copyOfMediaArray()); 
34
hgs
parents: 30
diff changeset
   874
hgs
parents: 30
diff changeset
   875
    QVERIFY(VideoListDataModel::mFirstInserted == 3);
hgs
parents: 30
diff changeset
   876
    QVERIFY(VideoListDataModel::mLastInserted == 9);
hgs
parents: 30
diff changeset
   877
30
hgs
parents:
diff changeset
   878
    QVERIFY(mTestObject->getVideoCount() == 10);
34
hgs
parents: 30
diff changeset
   879
    QVERIFY(spyModelChanged.count() == 1); 
hgs
parents: 30
diff changeset
   880
    spyModelChanged.clear();
hgs
parents: 30
diff changeset
   881
  
30
hgs
parents:
diff changeset
   882
      
hgs
parents:
diff changeset
   883
    disconnect(this, SIGNAL(signalNewVideoList(CMPXMediaArray*)), mTestObject, SLOT(newVideoListSlot(CMPXMediaArray*)));  
hgs
parents:
diff changeset
   884
    disconnect(this, SIGNAL(signalAppendVideoList(CMPXMediaArray*)), mTestObject, SLOT(appendVideoListSlot(CMPXMediaArray*)));  
hgs
parents:
diff changeset
   885
}
hgs
parents:
diff changeset
   886
hgs
parents:
diff changeset
   887
// -----------------------------------------------------------------------------
35
hgs
parents: 34
diff changeset
   888
// testAlbumListAvailableSlot
hgs
parents: 34
diff changeset
   889
// -----------------------------------------------------------------------------
hgs
parents: 34
diff changeset
   890
//
hgs
parents: 34
diff changeset
   891
void TestVideoModel_p::testAlbumListAvailableSlot()
hgs
parents: 34
diff changeset
   892
{ 
hgs
parents: 34
diff changeset
   893
hgs
parents: 34
diff changeset
   894
    QVERIFY(mTestObject->initialize() == 0);
hgs
parents: 34
diff changeset
   895
        
hgs
parents: 34
diff changeset
   896
    QVERIFY(connect(this, SIGNAL(signalAlbumListAvailable(TMPXItemId, CMPXMediaArray*)),
hgs
parents: 34
diff changeset
   897
            mTestObject, SLOT(albumListAvailableSlot(TMPXItemId, CMPXMediaArray*))));  
hgs
parents: 34
diff changeset
   898
    
hgs
parents: 34
diff changeset
   899
    TMPXItemId albumId(1,2);
hgs
parents: 34
diff changeset
   900
    
hgs
parents: 34
diff changeset
   901
    // null video array
hgs
parents: 34
diff changeset
   902
    emit signalAlbumListAvailable(albumId, 0);
hgs
parents: 34
diff changeset
   903
    QVERIFY(mTestObject->mAlbumData.count() == 0);
hgs
parents: 34
diff changeset
   904
    
hgs
parents: 34
diff changeset
   905
    mMediaFactory->removeArray();
hgs
parents: 34
diff changeset
   906
    mMediaFactory->createMediaItems(10);
hgs
parents: 34
diff changeset
   907
    // invalid album id
hgs
parents: 34
diff changeset
   908
    albumId = TMPXItemId::InvalidId();
hgs
parents: 34
diff changeset
   909
    emit signalAlbumListAvailable(albumId, mMediaFactory->mediaArray());
hgs
parents: 34
diff changeset
   910
    QVERIFY(mTestObject->mAlbumData.count() == 0);
hgs
parents: 34
diff changeset
   911
    
hgs
parents: 34
diff changeset
   912
    mMediaFactory->removeArray();
hgs
parents: 34
diff changeset
   913
    mMediaFactory->createMediaItems(0);
hgs
parents: 34
diff changeset
   914
    albumId = TMPXItemId(1,2);
hgs
parents: 34
diff changeset
   915
    
hgs
parents: 34
diff changeset
   916
    // empty videoarray
hgs
parents: 34
diff changeset
   917
    emit signalAlbumListAvailable(albumId, mMediaFactory->mediaArray());
hgs
parents: 34
diff changeset
   918
    QVERIFY(mTestObject->mAlbumData.count() == 1);
hgs
parents: 34
diff changeset
   919
    
hgs
parents: 34
diff changeset
   920
    mMediaFactory->removeArray();
hgs
parents: 34
diff changeset
   921
    mMediaFactory->createMediaItems(0);
hgs
parents: 34
diff changeset
   922
    TRAP_IGNORE(mMediaFactory->mediaArray()->AppendL(mMediaFactory->getMediaWithWantedIds(1, 0)));
hgs
parents: 34
diff changeset
   923
    TRAP_IGNORE(mMediaFactory->mediaArray()->AppendL(mMediaFactory->getMediaWithWantedIds(-1, -1)));
hgs
parents: 34
diff changeset
   924
    TRAP_IGNORE(mMediaFactory->mediaArray()->AppendL(mMediaFactory->getMediaWithWantedIds(2, 0)));
hgs
parents: 34
diff changeset
   925
    TRAP_IGNORE(mMediaFactory->mediaArray()->AppendL(mMediaFactory->getMediaWithWantedIds(3, 1)));
hgs
parents: 34
diff changeset
   926
    
hgs
parents: 34
diff changeset
   927
    // "normal" video array containing invalid ids.
hgs
parents: 34
diff changeset
   928
    emit signalAlbumListAvailable(albumId, mMediaFactory->mediaArray());
hgs
parents: 34
diff changeset
   929
    QVERIFY(mTestObject->mAlbumData.count() == 1);
hgs
parents: 34
diff changeset
   930
    QVERIFY(mTestObject->mAlbumData.find(albumId)->count() == 2);
hgs
parents: 34
diff changeset
   931
    TMPXItemId itemToCheck(1,0);
hgs
parents: 34
diff changeset
   932
    QVERIFY(mTestObject->belongsToAlbum(itemToCheck, albumId));    
hgs
parents: 34
diff changeset
   933
    
hgs
parents: 34
diff changeset
   934
    disconnect(this, SIGNAL(signalAlbumListAvailable(TMPXItemId, CMPXMediaArray*)),
hgs
parents: 34
diff changeset
   935
                mTestObject, SLOT(albumListAvailableSlot(TMPXItemId, CMPXMediaArray*)));
hgs
parents: 34
diff changeset
   936
}
hgs
parents: 34
diff changeset
   937
hgs
parents: 34
diff changeset
   938
// -----------------------------------------------------------------------------
36
hgs
parents: 35
diff changeset
   939
// testItemModifiedSlot
hgs
parents: 35
diff changeset
   940
// -----------------------------------------------------------------------------
hgs
parents: 35
diff changeset
   941
//
hgs
parents: 35
diff changeset
   942
void TestVideoModel_p::testItemModifiedSlot()
hgs
parents: 35
diff changeset
   943
{
hgs
parents: 35
diff changeset
   944
    mMediaFactory->removeArray();
hgs
parents: 35
diff changeset
   945
hgs
parents: 35
diff changeset
   946
    QVERIFY(connect(this, SIGNAL(signalItemModified(const TMPXItemId &)), mTestObject, SLOT(itemModifiedSlot(const TMPXItemId &))));  
hgs
parents: 35
diff changeset
   947
    
hgs
parents: 35
diff changeset
   948
    QSignalSpy spysignal(mTestObject, SIGNAL(dataChanged(const QModelIndex &, const QModelIndex &)));
hgs
parents: 35
diff changeset
   949
hgs
parents: 35
diff changeset
   950
    // invalid item id, no items
hgs
parents: 35
diff changeset
   951
    TMPXItemId id = TMPXItemId::InvalidId();
hgs
parents: 35
diff changeset
   952
    emit signalItemModified(id);
hgs
parents: 35
diff changeset
   953
    QVERIFY(spysignal.count() == 0);
hgs
parents: 35
diff changeset
   954
    
hgs
parents: 35
diff changeset
   955
    // invalid item id, model has items
hgs
parents: 35
diff changeset
   956
    QVERIFY(connect(this, SIGNAL(signalNewVideoList(CMPXMediaArray*)), mTestObject, SLOT(newVideoListSlot(CMPXMediaArray*))));           
hgs
parents: 35
diff changeset
   957
    mMediaFactory->createMediaItems(MEDIA_COUNT);
hgs
parents: 35
diff changeset
   958
    emit signalNewVideoList(mMediaFactory->copyOfMediaArray());
hgs
parents: 35
diff changeset
   959
hgs
parents: 35
diff changeset
   960
    emit signalItemModified(id);
hgs
parents: 35
diff changeset
   961
    QVERIFY(spysignal.count() == 0);
hgs
parents: 35
diff changeset
   962
    
hgs
parents: 35
diff changeset
   963
    // ok item id, model has items
hgs
parents: 35
diff changeset
   964
    id = TMPXItemId(0, 0);
hgs
parents: 35
diff changeset
   965
    emit signalItemModified(id);
hgs
parents: 35
diff changeset
   966
    QVERIFY(spysignal.count() == 1);
hgs
parents: 35
diff changeset
   967
    spysignal.clear();
hgs
parents: 35
diff changeset
   968
    
hgs
parents: 35
diff changeset
   969
    // ok item id, model has items but returns invalid index
hgs
parents: 35
diff changeset
   970
    VideoListDataModel::mIndexReturnsInvalid = true;
hgs
parents: 35
diff changeset
   971
    id = TMPXItemId(0, 0);
hgs
parents: 35
diff changeset
   972
    emit signalItemModified(id);
hgs
parents: 35
diff changeset
   973
    QVERIFY(spysignal.count() == 0);
hgs
parents: 35
diff changeset
   974
    spysignal.clear();
hgs
parents: 35
diff changeset
   975
hgs
parents: 35
diff changeset
   976
    disconnect(this, SIGNAL(signalItemModified(const TMPXItemId &)), mTestObject, SLOT(itemModifiedSlot(const TMPXItemId &)));    
hgs
parents: 35
diff changeset
   977
    VideoListDataModel::mIndexReturnsInvalid = false;
hgs
parents: 35
diff changeset
   978
}
hgs
parents: 35
diff changeset
   979
hgs
parents: 35
diff changeset
   980
// -----------------------------------------------------------------------------
30
hgs
parents:
diff changeset
   981
// testNewVideoAvailableSlot
hgs
parents:
diff changeset
   982
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
   983
//
hgs
parents:
diff changeset
   984
void TestVideoModel_p::testNewVideoAvailableSlot()
hgs
parents:
diff changeset
   985
{
36
hgs
parents: 35
diff changeset
   986
    VideoListDataModel::mIndexReturnsInvalid = false;
30
hgs
parents:
diff changeset
   987
    QVERIFY(mTestObject->initialize() == 0);
hgs
parents:
diff changeset
   988
    
34
hgs
parents: 30
diff changeset
   989
    connect(this, SIGNAL(signalNewVideoAvailable(CMPXMedia*)), mTestObject, SLOT(newVideoAvailableSlot(CMPXMedia*)));
hgs
parents: 30
diff changeset
   990
    connect(this, SIGNAL(signalNewVideoList(CMPXMediaArray*)), mTestObject, SLOT(newVideoListSlot(CMPXMediaArray*))); 
30
hgs
parents:
diff changeset
   991
    
34
hgs
parents: 30
diff changeset
   992
    QSignalSpy spyModelChanged(mStubModel, SIGNAL(modelChanged()));
30
hgs
parents:
diff changeset
   993
    
34
hgs
parents: 30
diff changeset
   994
    VideoListDataModel::mFirstInserted = -1;
hgs
parents: 30
diff changeset
   995
    VideoListDataModel::mLastInserted = -1;
hgs
parents: 30
diff changeset
   996
 
30
hgs
parents:
diff changeset
   997
    CMPXMedia *media = mMediaFactory->getMedia(MEDIA_COUNT + 100);
34
hgs
parents: 30
diff changeset
   998
    // succeed insert
30
hgs
parents:
diff changeset
   999
    emit signalNewVideoAvailable(media);
34
hgs
parents: 30
diff changeset
  1000
    QVERIFY(VideoListDataModel::mFirstInserted == 0);
hgs
parents: 30
diff changeset
  1001
    QVERIFY(VideoListDataModel::mLastInserted == 0);
hgs
parents: 30
diff changeset
  1002
    QVERIFY(spyModelChanged.count() == 1);
30
hgs
parents:
diff changeset
  1003
    
hgs
parents:
diff changeset
  1004
    QVERIFY(mTestObject->getVideoCount() == 1);
hgs
parents:
diff changeset
  1005
    delete media;
hgs
parents:
diff changeset
  1006
    media = 0;
34
hgs
parents: 30
diff changeset
  1007
    VideoListDataModel::mFirstInserted = -1;
hgs
parents: 30
diff changeset
  1008
    VideoListDataModel::mLastInserted = -1;
hgs
parents: 30
diff changeset
  1009
    spyModelChanged.clear();
30
hgs
parents:
diff changeset
  1010
    
hgs
parents:
diff changeset
  1011
    // null pointer provided
hgs
parents:
diff changeset
  1012
    emit signalNewVideoAvailable(media);
34
hgs
parents: 30
diff changeset
  1013
    QVERIFY(spyModelChanged.count() == 0);
hgs
parents: 30
diff changeset
  1014
    QVERIFY(VideoListDataModel::mFirstInserted == -1);
hgs
parents: 30
diff changeset
  1015
    QVERIFY(VideoListDataModel::mLastInserted == -1);
30
hgs
parents:
diff changeset
  1016
    QVERIFY(mTestObject->getVideoCount() == 1);
34
hgs
parents: 30
diff changeset
  1017
    spyModelChanged.clear();
30
hgs
parents:
diff changeset
  1018
    
hgs
parents:
diff changeset
  1019
    // invalid item
hgs
parents:
diff changeset
  1020
    media = mMediaFactory->getMedia(MEDIA_COUNT + 100, MediaDataNone);
hgs
parents:
diff changeset
  1021
    emit signalNewVideoAvailable(media);
34
hgs
parents: 30
diff changeset
  1022
    QVERIFY(VideoListDataModel::mFirstInserted == -1);
hgs
parents: 30
diff changeset
  1023
    QVERIFY(VideoListDataModel::mLastInserted == -1);
30
hgs
parents:
diff changeset
  1024
    QVERIFY(mTestObject->getVideoCount() == 1);
34
hgs
parents: 30
diff changeset
  1025
    QVERIFY(spyModelChanged.count() == 0);
30
hgs
parents:
diff changeset
  1026
    delete media;
hgs
parents:
diff changeset
  1027
    media = 0;
34
hgs
parents: 30
diff changeset
  1028
    spyModelChanged.clear();
hgs
parents: 30
diff changeset
  1029
    
hgs
parents: 30
diff changeset
  1030
    // item without name
hgs
parents: 30
diff changeset
  1031
    media = mMediaFactory->getMedia(MEDIA_COUNT + 100, MediaDataId);
hgs
parents: 30
diff changeset
  1032
    emit signalNewVideoAvailable(media);
hgs
parents: 30
diff changeset
  1033
    QVERIFY(VideoListDataModel::mFirstInserted == -1);
hgs
parents: 30
diff changeset
  1034
    QVERIFY(VideoListDataModel::mLastInserted == -1);
hgs
parents: 30
diff changeset
  1035
    QVERIFY(mTestObject->getVideoCount() == 1);
hgs
parents: 30
diff changeset
  1036
    QVERIFY(spyModelChanged.count() == 0);
hgs
parents: 30
diff changeset
  1037
    delete media;
hgs
parents: 30
diff changeset
  1038
    media = 0;
hgs
parents: 30
diff changeset
  1039
    spyModelChanged.clear();
30
hgs
parents:
diff changeset
  1040
    
hgs
parents:
diff changeset
  1041
    delete mTestObject;
hgs
parents:
diff changeset
  1042
    mTestObject = new VideoListDataModelPrivate(mStubModel);
hgs
parents:
diff changeset
  1043
    QVERIFY(mTestObject->initialize() == 0);
hgs
parents:
diff changeset
  1044
    QVERIFY(connect(this, SIGNAL(signalNewVideoList(CMPXMediaArray*)), mTestObject, SLOT(newVideoListSlot(CMPXMediaArray*))));  
hgs
parents:
diff changeset
  1045
    QVERIFY(connect(this, SIGNAL(signalNewVideoAvailable(CMPXMedia*)), mTestObject, SLOT(newVideoAvailableSlot(CMPXMedia*))));
hgs
parents:
diff changeset
  1046
hgs
parents:
diff changeset
  1047
    mMediaFactory->removeArray();
hgs
parents:
diff changeset
  1048
    mMediaFactory->createMediaItems(MEDIA_COUNT);
hgs
parents:
diff changeset
  1049
    emit signalNewVideoList(mMediaFactory->copyOfMediaArray());
34
hgs
parents: 30
diff changeset
  1050
    VideoListDataModel::mFirstInserted = -1;
hgs
parents: 30
diff changeset
  1051
    VideoListDataModel::mLastInserted = -1;
hgs
parents: 30
diff changeset
  1052
    spyModelChanged.clear();
30
hgs
parents:
diff changeset
  1053
    
hgs
parents:
diff changeset
  1054
    // succeed case
hgs
parents:
diff changeset
  1055
    CMPXMedia *media3 = mMediaFactory->getMedia(MEDIA_COUNT + 103 );
hgs
parents:
diff changeset
  1056
    emit signalNewVideoAvailable(media3);
34
hgs
parents: 30
diff changeset
  1057
    QVERIFY(VideoListDataModel::mFirstInserted == mTestObject->getVideoCount() - 1);
hgs
parents: 30
diff changeset
  1058
    QVERIFY(VideoListDataModel::mLastInserted == mTestObject->getVideoCount() - 1);
hgs
parents: 30
diff changeset
  1059
    QVERIFY(spyModelChanged.count() == 1);
30
hgs
parents:
diff changeset
  1060
    QVERIFY(mTestObject->getVideoCount() == MEDIA_COUNT + 1);
hgs
parents:
diff changeset
  1061
    
hgs
parents:
diff changeset
  1062
    disconnect(this, SIGNAL(signalNewVideoAvailable(CMPXMedia*)), mTestObject, SLOT(newVideoAvailableSlot(CMPXMedia*)));
hgs
parents:
diff changeset
  1063
    disconnect(this, SIGNAL(signalNewVideoList(CMPXMediaArray*)), mTestObject, SLOT(newVideoListSlot(CMPXMediaArray*))); 
hgs
parents:
diff changeset
  1064
}
hgs
parents:
diff changeset
  1065
hgs
parents:
diff changeset
  1066
// -----------------------------------------------------------------------------
35
hgs
parents: 34
diff changeset
  1067
// testItemDeletedSlot
30
hgs
parents:
diff changeset
  1068
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
  1069
//
35
hgs
parents: 34
diff changeset
  1070
void TestVideoModel_p::testItemDeletedSlot()
30
hgs
parents:
diff changeset
  1071
{
34
hgs
parents: 30
diff changeset
  1072
    mTestObject->initialize();
30
hgs
parents:
diff changeset
  1073
    mMediaFactory->removeArray();
34
hgs
parents: 30
diff changeset
  1074
    VideoListDataModel::mFirstRemoved = -1;
hgs
parents: 30
diff changeset
  1075
    VideoListDataModel::mLastRemoved = -1;
hgs
parents: 30
diff changeset
  1076
    QSignalSpy spyModelChanged(mStubModel, SIGNAL(modelChanged()));
30
hgs
parents:
diff changeset
  1077
    
hgs
parents:
diff changeset
  1078
    QVERIFY(connect(this, SIGNAL(signalNewVideoList(CMPXMediaArray*)), mTestObject, SLOT(newVideoListSlot(CMPXMediaArray*))));  
35
hgs
parents: 34
diff changeset
  1079
    QVERIFY(connect(this, SIGNAL(signalDeleteItem(TMPXItemId)), mTestObject, SLOT(itemDeletedSlot(TMPXItemId))));  
34
hgs
parents: 30
diff changeset
  1080
    
30
hgs
parents:
diff changeset
  1081
    // no videos
35
hgs
parents: 34
diff changeset
  1082
    emit signalDeleteItem(TMPXItemId(0,0));
34
hgs
parents: 30
diff changeset
  1083
    QVERIFY(VideoListDataModel::mFirstRemoved == -1);
hgs
parents: 30
diff changeset
  1084
    QVERIFY(VideoListDataModel::mFirstRemoved == -1);
hgs
parents: 30
diff changeset
  1085
    QVERIFY(spyModelChanged.count() == 0);
30
hgs
parents:
diff changeset
  1086
    
34
hgs
parents: 30
diff changeset
  1087
    // invalid id
35
hgs
parents: 34
diff changeset
  1088
    emit signalDeleteItem(TMPXItemId::InvalidId());
34
hgs
parents: 30
diff changeset
  1089
    QVERIFY(VideoListDataModel::mFirstRemoved == -1);
hgs
parents: 30
diff changeset
  1090
    QVERIFY(VideoListDataModel::mFirstRemoved == -1);
hgs
parents: 30
diff changeset
  1091
    QVERIFY(spyModelChanged.count() == 0);
30
hgs
parents:
diff changeset
  1092
    
hgs
parents:
diff changeset
  1093
    mMediaFactory->removeArray();
hgs
parents:
diff changeset
  1094
    mMediaFactory->createMediaItems(MEDIA_COUNT);
hgs
parents:
diff changeset
  1095
    emit signalNewVideoList(mMediaFactory->copyOfMediaArray());
34
hgs
parents: 30
diff changeset
  1096
    VideoListDataModel::mFirstRemoved = -1;
hgs
parents: 30
diff changeset
  1097
    VideoListDataModel::mLastRemoved = -1;
hgs
parents: 30
diff changeset
  1098
    spyModelChanged.clear();
hgs
parents: 30
diff changeset
  1099
    
hgs
parents: 30
diff changeset
  1100
    // not marked as removed
35
hgs
parents: 34
diff changeset
  1101
    emit signalDeleteItem(TMPXItemId(MEDIA_COUNT / 2,0));
34
hgs
parents: 30
diff changeset
  1102
    QVERIFY(VideoListDataModel::mFirstRemoved == MEDIA_COUNT / 2);
hgs
parents: 30
diff changeset
  1103
    QVERIFY(VideoListDataModel::mFirstRemoved == MEDIA_COUNT / 2);
hgs
parents: 30
diff changeset
  1104
    QVERIFY(spyModelChanged.count() == 1);
hgs
parents: 30
diff changeset
  1105
    
hgs
parents: 30
diff changeset
  1106
    VideoListDataModel::mFirstRemoved = -1;
hgs
parents: 30
diff changeset
  1107
    VideoListDataModel::mLastRemoved = -1;
hgs
parents: 30
diff changeset
  1108
    spyModelChanged.clear();
hgs
parents: 30
diff changeset
  1109
    
hgs
parents: 30
diff changeset
  1110
    QModelIndex index = mStubModel->index(MEDIA_COUNT / 2, 0, QModelIndex());
hgs
parents: 30
diff changeset
  1111
    TMPXItemId id = mTestObject->markVideoRemoved(index);
30
hgs
parents:
diff changeset
  1112
    
34
hgs
parents: 30
diff changeset
  1113
    // marked as removed
35
hgs
parents: 34
diff changeset
  1114
    emit signalDeleteItem(id);
34
hgs
parents: 30
diff changeset
  1115
    // item already removed from container, no notifications
hgs
parents: 30
diff changeset
  1116
    QVERIFY(VideoListDataModel::mFirstRemoved == -1);
hgs
parents: 30
diff changeset
  1117
    QVERIFY(VideoListDataModel::mFirstRemoved == -1);
hgs
parents: 30
diff changeset
  1118
    QVERIFY(spyModelChanged.count() == 0);
hgs
parents: 30
diff changeset
  1119
    
hgs
parents: 30
diff changeset
  1120
    // no thumbnail data (tested for coverity)
hgs
parents: 30
diff changeset
  1121
    VideoThumbnailData *tmp = mTestObject->mVideoThumbnailData;
hgs
parents: 30
diff changeset
  1122
    mTestObject->mVideoThumbnailData = 0;
30
hgs
parents:
diff changeset
  1123
    
34
hgs
parents: 30
diff changeset
  1124
    index = mStubModel->index(mTestObject->getVideoCount() - 1, 0, QModelIndex());
hgs
parents: 30
diff changeset
  1125
    id = mTestObject->markVideoRemoved(index);
35
hgs
parents: 34
diff changeset
  1126
    emit signalDeleteItem(id);
34
hgs
parents: 30
diff changeset
  1127
    // item already removed from container, no notifications
hgs
parents: 30
diff changeset
  1128
    QVERIFY(VideoListDataModel::mFirstRemoved == -1);
hgs
parents: 30
diff changeset
  1129
    QVERIFY(VideoListDataModel::mFirstRemoved == -1);
hgs
parents: 30
diff changeset
  1130
    QVERIFY(spyModelChanged.count() == 0);
30
hgs
parents:
diff changeset
  1131
    
34
hgs
parents: 30
diff changeset
  1132
    mTestObject->mVideoThumbnailData = tmp;
hgs
parents: 30
diff changeset
  1133
    
35
hgs
parents: 34
diff changeset
  1134
    // test albums
hgs
parents: 34
diff changeset
  1135
    mTestObject->mAlbumData.clear();
hgs
parents: 34
diff changeset
  1136
    mTestObject->mMediaData.clear();
hgs
parents: 34
diff changeset
  1137
       
hgs
parents: 34
diff changeset
  1138
    TMPXItemId album1 = TMPXItemId(2,2);
hgs
parents: 34
diff changeset
  1139
    TMPXItemId album2 = TMPXItemId(3,2);
hgs
parents: 34
diff changeset
  1140
    mMediaFactory->removeArray();
hgs
parents: 34
diff changeset
  1141
    mMediaFactory->createMediaItems(5);
hgs
parents: 34
diff changeset
  1142
    TRAP_IGNORE(mMediaFactory->mediaArray()->AppendL(mMediaFactory->getMediaWithWantedIds(album1.iId1, album1.iId2)));
hgs
parents: 34
diff changeset
  1143
    TRAP_IGNORE(mMediaFactory->mediaArray()->AppendL(mMediaFactory->getMediaWithWantedIds(album2.iId1, album2.iId2)));
hgs
parents: 34
diff changeset
  1144
    emit signalNewVideoList(mMediaFactory->copyOfMediaArray());
hgs
parents: 34
diff changeset
  1145
    VideoListDataModel::mFirstRemoved = -1;
hgs
parents: 34
diff changeset
  1146
    VideoListDataModel::mLastRemoved = -1;
hgs
parents: 34
diff changeset
  1147
    spyModelChanged.clear();
hgs
parents: 34
diff changeset
  1148
    
hgs
parents: 34
diff changeset
  1149
    QSet<TMPXItemId> items;
hgs
parents: 34
diff changeset
  1150
    mTestObject->mAlbumData[album1] = items;
hgs
parents: 34
diff changeset
  1151
    items.insert(mTestObject->getMediaIdFromIndex(0));
hgs
parents: 34
diff changeset
  1152
    items.insert(mTestObject->getMediaIdFromIndex(1));
hgs
parents: 34
diff changeset
  1153
    mTestObject->mAlbumData[album2] = items;
hgs
parents: 34
diff changeset
  1154
    
hgs
parents: 34
diff changeset
  1155
    // not existing album
hgs
parents: 34
diff changeset
  1156
    emit signalDeleteItem(TMPXItemId(1,2));
hgs
parents: 34
diff changeset
  1157
    QVERIFY(VideoListDataModel::mFirstRemoved == -1);
hgs
parents: 34
diff changeset
  1158
    QVERIFY(spyModelChanged.count() == 0);
hgs
parents: 34
diff changeset
  1159
    QVERIFY( mTestObject->mAlbumData.count() == 2);
hgs
parents: 34
diff changeset
  1160
    
hgs
parents: 34
diff changeset
  1161
    // existing
hgs
parents: 34
diff changeset
  1162
    emit signalDeleteItem(album2);
hgs
parents: 34
diff changeset
  1163
    QVERIFY(VideoListDataModel::mFirstRemoved == 6);
hgs
parents: 34
diff changeset
  1164
    QVERIFY(spyModelChanged.count() == 1);
hgs
parents: 34
diff changeset
  1165
    QVERIFY( mTestObject->mAlbumData.count() == 1);
hgs
parents: 34
diff changeset
  1166
    
hgs
parents: 34
diff changeset
  1167
    VideoListDataModel::mFirstRemoved = -1;
hgs
parents: 34
diff changeset
  1168
    spyModelChanged.clear();
hgs
parents: 34
diff changeset
  1169
    
hgs
parents: 34
diff changeset
  1170
    // no tn object
hgs
parents: 34
diff changeset
  1171
    VideoThumbnailData *pTmp = mTestObject->mVideoThumbnailData;
hgs
parents: 34
diff changeset
  1172
    mTestObject->mVideoThumbnailData = 0;
hgs
parents: 34
diff changeset
  1173
    emit signalDeleteItem(album1);
hgs
parents: 34
diff changeset
  1174
    QVERIFY(VideoListDataModel::mFirstRemoved == 5);
hgs
parents: 34
diff changeset
  1175
    QVERIFY(spyModelChanged.count() == 1);
hgs
parents: 34
diff changeset
  1176
    QVERIFY( mTestObject->mAlbumData.count() == 0);
hgs
parents: 34
diff changeset
  1177
    mTestObject->mVideoThumbnailData  = pTmp;
hgs
parents: 34
diff changeset
  1178
    
hgs
parents: 34
diff changeset
  1179
    disconnect(this, SIGNAL(signalDeleteItem(TMPXItemId)), mTestObject, SLOT(itemDeletedSlot(TMPXItemId)));
30
hgs
parents:
diff changeset
  1180
    disconnect(this, SIGNAL(signalNewVideoList(CMPXMediaArray*)), mTestObject, SLOT(newVideoListSlot(CMPXMediaArray*)));
34
hgs
parents: 30
diff changeset
  1181
    
30
hgs
parents:
diff changeset
  1182
}
hgs
parents:
diff changeset
  1183
hgs
parents:
diff changeset
  1184
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
  1185
// testVideoDeleteCompletedSlot
hgs
parents:
diff changeset
  1186
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
  1187
//
34
hgs
parents: 30
diff changeset
  1188
30
hgs
parents:
diff changeset
  1189
void TestVideoModel_p::testVideoDeleteCompletedSlot()
hgs
parents:
diff changeset
  1190
{
hgs
parents:
diff changeset
  1191
    QVERIFY(connect(this, SIGNAL(signalNewVideoList(CMPXMediaArray*)), mTestObject, SLOT(newVideoListSlot(CMPXMediaArray*))));  
hgs
parents:
diff changeset
  1192
    QVERIFY(connect(this, SIGNAL(signalDeleteCompleted(int, QList<TMPXItemId>*)), mTestObject, SLOT(videoDeleteCompletedSlot(int, QList<TMPXItemId>*))));  
34
hgs
parents: 30
diff changeset
  1193
   
hgs
parents: 30
diff changeset
  1194
    mMediaFactory->removeArray();
30
hgs
parents:
diff changeset
  1195
    mMediaFactory->createMediaItems(MEDIA_COUNT);
hgs
parents:
diff changeset
  1196
    emit signalNewVideoList(mMediaFactory->copyOfMediaArray());
hgs
parents:
diff changeset
  1197
34
hgs
parents: 30
diff changeset
  1198
    QSignalSpy spysignal(mStubModel, SIGNAL(modelChanged()));
hgs
parents: 30
diff changeset
  1199
    VideoListDataModel::mStatus = -1;
hgs
parents: 30
diff changeset
  1200
    VideoListDataModel::mStatusData = QVariant();
hgs
parents: 30
diff changeset
  1201
    
hgs
parents: 30
diff changeset
  1202
    QList<TMPXItemId> idList;
hgs
parents: 30
diff changeset
  1203
    
hgs
parents: 30
diff changeset
  1204
    // null list
30
hgs
parents:
diff changeset
  1205
    emit signalDeleteCompleted(0, 0);
hgs
parents:
diff changeset
  1206
    QVERIFY(spysignal.count() == 0);
34
hgs
parents: 30
diff changeset
  1207
    QVERIFY(VideoListDataModel::mStatus == -1);
hgs
parents: 30
diff changeset
  1208
    QVERIFY(!VideoListDataModel::mStatusData.isValid());
30
hgs
parents:
diff changeset
  1209
    
34
hgs
parents: 30
diff changeset
  1210
    // empty list
hgs
parents: 30
diff changeset
  1211
    emit signalDeleteCompleted(0, &idList);
hgs
parents: 30
diff changeset
  1212
    int count =spysignal.count();
hgs
parents: 30
diff changeset
  1213
    QVERIFY(spysignal.count() == 1);
hgs
parents: 30
diff changeset
  1214
    QVERIFY(VideoListDataModel::mStatus == VideoCollectionCommon::statusDeleteSucceed);
hgs
parents: 30
diff changeset
  1215
    QVERIFY(!VideoListDataModel::mStatusData.isValid());
hgs
parents: 30
diff changeset
  1216
    VideoListDataModel::mStatus = -1;
hgs
parents: 30
diff changeset
  1217
    VideoListDataModel::mStatusData = QVariant();
hgs
parents: 30
diff changeset
  1218
    spysignal.clear();
30
hgs
parents:
diff changeset
  1219
    
34
hgs
parents: 30
diff changeset
  1220
    // one failed (no item)
hgs
parents: 30
diff changeset
  1221
    idList.append(TMPXItemId(0,0));
hgs
parents: 30
diff changeset
  1222
    emit signalDeleteCompleted(0, &idList);
30
hgs
parents:
diff changeset
  1223
    QVERIFY(spysignal.count() == 1);
34
hgs
parents: 30
diff changeset
  1224
    QVERIFY(VideoListDataModel::mStatus == VideoCollectionCommon::statusSingleDeleteFail);
hgs
parents: 30
diff changeset
  1225
    QVERIFY(VideoListDataModel::mStatusData.isValid());
hgs
parents: 30
diff changeset
  1226
           
hgs
parents: 30
diff changeset
  1227
    VideoListDataModel::mStatus = -1;
hgs
parents: 30
diff changeset
  1228
    VideoListDataModel::mStatusData = QVariant();
30
hgs
parents:
diff changeset
  1229
    spysignal.clear();
34
hgs
parents: 30
diff changeset
  1230
hgs
parents: 30
diff changeset
  1231
    idList.append(TMPXItemId(1,0));
hgs
parents: 30
diff changeset
  1232
    // multiple failed
hgs
parents: 30
diff changeset
  1233
    emit signalDeleteCompleted(0, &idList);
hgs
parents: 30
diff changeset
  1234
    QVERIFY(spysignal.count() == 1);
hgs
parents: 30
diff changeset
  1235
    QVERIFY(VideoListDataModel::mStatus == VideoCollectionCommon::statusMultipleDeleteFail);
hgs
parents: 30
diff changeset
  1236
    QVERIFY(VideoListDataModel::mStatusData.isValid());
30
hgs
parents:
diff changeset
  1237
    
hgs
parents:
diff changeset
  1238
    disconnect(this, SIGNAL(signalNewVideoList(CMPXMediaArray*)), mTestObject, SLOT(newVideoListSlot(CMPXMediaArray*)));  
hgs
parents:
diff changeset
  1239
    disconnect(this, SIGNAL(signalDeleteCompleted(int, QList<TMPXItemId>*)), mTestObject, SLOT(videoDeleteCompletedSlot(int, QList<TMPXItemId>*)));
34
hgs
parents: 30
diff changeset
  1240
30
hgs
parents:
diff changeset
  1241
}
hgs
parents:
diff changeset
  1242
hgs
parents:
diff changeset
  1243
// -----------------------------------------------------------------------------
35
hgs
parents: 34
diff changeset
  1244
// testAlbumRemoveFailureSlot
hgs
parents: 34
diff changeset
  1245
// -----------------------------------------------------------------------------
hgs
parents: 34
diff changeset
  1246
//
hgs
parents: 34
diff changeset
  1247
void TestVideoModel_p::testAlbumRemoveFailureSlot()
hgs
parents: 34
diff changeset
  1248
{
hgs
parents: 34
diff changeset
  1249
    QVERIFY(connect(this, SIGNAL(signalNewVideoList(CMPXMediaArray*)), mTestObject, SLOT(newVideoListSlot(CMPXMediaArray*))));  
hgs
parents: 34
diff changeset
  1250
    QVERIFY(connect(this, SIGNAL(signalAlbumDeleteFailure(QList<TMPXItemId>*)), mTestObject, SLOT(albumRemoveFailureSlot(QList<TMPXItemId>*)))); 
hgs
parents: 34
diff changeset
  1251
    
hgs
parents: 34
diff changeset
  1252
    TRAP_IGNORE(mMediaFactory->mediaArray()->AppendL(mMediaFactory->getMediaWithWantedIds(1, 2)));
hgs
parents: 34
diff changeset
  1253
    TRAP_IGNORE(mMediaFactory->mediaArray()->AppendL(mMediaFactory->getMediaWithWantedIds(2, 2)));
hgs
parents: 34
diff changeset
  1254
    emit signalNewVideoList(mMediaFactory->copyOfMediaArray());
hgs
parents: 34
diff changeset
  1255
    
hgs
parents: 34
diff changeset
  1256
    VideoListDataModel::mStatus = -1;
hgs
parents: 34
diff changeset
  1257
    VideoListDataModel::mStatusData = QVariant();
hgs
parents: 34
diff changeset
  1258
    // null list
hgs
parents: 34
diff changeset
  1259
    emit signalAlbumDeleteFailure(0);
hgs
parents: 34
diff changeset
  1260
    QVERIFY(VideoListDataModel::mStatus == -1);
hgs
parents: 34
diff changeset
  1261
    QVERIFY(!(VideoListDataModel::mStatusData.isValid()));
hgs
parents: 34
diff changeset
  1262
    
hgs
parents: 34
diff changeset
  1263
    QList<TMPXItemId> ids;
hgs
parents: 34
diff changeset
  1264
    
hgs
parents: 34
diff changeset
  1265
    // empty list
hgs
parents: 34
diff changeset
  1266
    emit signalAlbumDeleteFailure(&ids);
hgs
parents: 34
diff changeset
  1267
    QVERIFY(VideoListDataModel::mStatus == VideoCollectionCommon::statusRemoveSucceed);
hgs
parents: 34
diff changeset
  1268
    QVERIFY(!(VideoListDataModel::mStatusData.isValid()));
hgs
parents: 34
diff changeset
  1269
    
hgs
parents: 34
diff changeset
  1270
    ids.append(TMPXItemId(1,2));
hgs
parents: 34
diff changeset
  1271
    
hgs
parents: 34
diff changeset
  1272
    // list contains one item
hgs
parents: 34
diff changeset
  1273
    emit signalAlbumDeleteFailure(&ids);
hgs
parents: 34
diff changeset
  1274
    QVERIFY(VideoListDataModel::mStatus == VideoCollectionCommon::statusSingleRemoveFail);    
hgs
parents: 34
diff changeset
  1275
    QVERIFY(VideoListDataModel::mStatusData.isValid());
hgs
parents: 34
diff changeset
  1276
    
hgs
parents: 34
diff changeset
  1277
    // list contains more than one
hgs
parents: 34
diff changeset
  1278
    ids.append(TMPXItemId(2,2));
hgs
parents: 34
diff changeset
  1279
    emit signalAlbumDeleteFailure(&ids);
hgs
parents: 34
diff changeset
  1280
    QVERIFY(VideoListDataModel::mStatus == VideoCollectionCommon::statusMultiRemoveFail);    
hgs
parents: 34
diff changeset
  1281
    QVERIFY(VideoListDataModel::mStatusData.isValid());
hgs
parents: 34
diff changeset
  1282
    
hgs
parents: 34
diff changeset
  1283
    disconnect(this, SIGNAL(signalNewVideoList(CMPXMediaArray*)), mTestObject, SLOT(newVideoListSlot(CMPXMediaArray*)));
hgs
parents: 34
diff changeset
  1284
    disconnect(this, SIGNAL(signalAlbumDeleteFailure(QList<TMPXItemId>*)), mTestObject, SLOT(albumRemoveFailureSlot(QList<TMPXItemId>*)));
hgs
parents: 34
diff changeset
  1285
}
hgs
parents: 34
diff changeset
  1286
hgs
parents: 34
diff changeset
  1287
// -----------------------------------------------------------------------------
30
hgs
parents:
diff changeset
  1288
// testVideoDetailsCompletedSlot
hgs
parents:
diff changeset
  1289
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
  1290
//
hgs
parents:
diff changeset
  1291
void TestVideoModel_p::testVideoDetailsCompletedSlot()
hgs
parents:
diff changeset
  1292
{
36
hgs
parents: 35
diff changeset
  1293
    using namespace VideoCollectionCommon;
hgs
parents: 35
diff changeset
  1294
    
30
hgs
parents:
diff changeset
  1295
    mMediaFactory->removeArray();
36
hgs
parents: 35
diff changeset
  1296
//    QVERIFY(connect(this, SIGNAL(signalNewVideoList(CMPXMediaArray*)), mTestObject, SLOT(newVideoListSlot(CMPXMediaArray*))));  
hgs
parents: 35
diff changeset
  1297
    QVERIFY(connect(this, SIGNAL(signalVideoDetailsCompleted(CMPXMedia*)), mTestObject, SLOT(videoDetailsCompletedSlot(CMPXMedia*))));      
hgs
parents: 35
diff changeset
  1298
    
hgs
parents: 35
diff changeset
  1299
    HbExtendedLocale locale = HbExtendedLocale::system();
hgs
parents: 35
diff changeset
  1300
    
hgs
parents: 35
diff changeset
  1301
    MetaDataSignalSpy spysignal(mTestObject, SIGNAL(videoDetailsReady(QVariant&)));
hgs
parents: 35
diff changeset
  1302
    
hgs
parents: 35
diff changeset
  1303
    // check with NULL media.
hgs
parents: 35
diff changeset
  1304
    emit signalVideoDetailsCompleted(0);
hgs
parents: 35
diff changeset
  1305
    QCOMPARE(spysignal.count, 0);
hgs
parents: 35
diff changeset
  1306
    
hgs
parents: 35
diff changeset
  1307
    // setup medias.
hgs
parents: 35
diff changeset
  1308
    mMediaFactory->createMediaItems(2);
hgs
parents: 35
diff changeset
  1309
    CMPXMedia* media = mMediaFactory->mediaArray()->operator [](0);
30
hgs
parents:
diff changeset
  1310
    
36
hgs
parents: 35
diff changeset
  1311
    // ok case
hgs
parents: 35
diff changeset
  1312
    emit signalVideoDetailsCompleted(media);
hgs
parents: 35
diff changeset
  1313
    QCOMPARE(spysignal.count, 1);
hgs
parents: 35
diff changeset
  1314
    QMap<QString, QVariant> map = spysignal.arg.toMap();
hgs
parents: 35
diff changeset
  1315
    
hgs
parents: 35
diff changeset
  1316
    QVERIFY(map.contains(MetaKeyDate));
hgs
parents: 35
diff changeset
  1317
    QVERIFY(map.contains(MetaKeyDurationString));
hgs
parents: 35
diff changeset
  1318
    QVERIFY(map.contains(MetaKeySizeString));
hgs
parents: 35
diff changeset
  1319
    QVERIFY(map.contains(MetaKeyStarRating));
hgs
parents: 35
diff changeset
  1320
    QVERIFY(map.contains(MetaKeyDescription));
hgs
parents: 35
diff changeset
  1321
    QVERIFY(map.contains(MetaKeyModifiedDate));
hgs
parents: 35
diff changeset
  1322
    QVERIFY(map.contains(MetaKeyAuthor));
hgs
parents: 35
diff changeset
  1323
    QVERIFY(map.contains(MetaKeyCopyright));
hgs
parents: 35
diff changeset
  1324
    QVERIFY(map.contains(MetaKeyLanguageString));
hgs
parents: 35
diff changeset
  1325
    QVERIFY(map.contains(MetaKeyFormat));
hgs
parents: 35
diff changeset
  1326
    QVERIFY(map.contains(MetaKeyVideoResolutionString));
hgs
parents: 35
diff changeset
  1327
    QVERIFY(map.contains(MetaKeyBitRate));
30
hgs
parents:
diff changeset
  1328
    
36
hgs
parents: 35
diff changeset
  1329
    // one or several of these will fail, when rest of the metadata is implemented.
hgs
parents: 35
diff changeset
  1330
    QVERIFY(map.contains(MetaKeyDRMInfo) == false);
hgs
parents: 35
diff changeset
  1331
    QVERIFY(map.contains(MetaKeyServiceURL) == false);
hgs
parents: 35
diff changeset
  1332
    QVERIFY(map.contains(MetaKeyShotLocation) == false);
hgs
parents: 35
diff changeset
  1333
    QVERIFY(map.contains(MetaKeyAudioType) == false);
hgs
parents: 35
diff changeset
  1334
    QVERIFY(map.contains(MetaKeyKeywords) == false);
30
hgs
parents:
diff changeset
  1335
    
36
hgs
parents: 35
diff changeset
  1336
    QCOMPARE(map[MetaKeyDate].toString(), locale.format(QDate(2009, 1, 1), r_qtn_date_usual));
hgs
parents: 35
diff changeset
  1337
    QVERIFY(map[MetaKeyDurationString].toString().isEmpty() == false);
hgs
parents: 35
diff changeset
  1338
    QVERIFY(map[MetaKeySizeString].toString().isEmpty() == false);
hgs
parents: 35
diff changeset
  1339
    QCOMPARE(map[MetaKeyStarRating].toUInt(), (uint)1);
hgs
parents: 35
diff changeset
  1340
    QCOMPARE(map[MetaKeyDescription].toString(), gQTMediaDescPrefix + "0");
hgs
parents: 35
diff changeset
  1341
    QCOMPARE(map[MetaKeyModifiedDate].toString(), locale.format(QDate::currentDate().addDays(2), r_qtn_date_usual));
hgs
parents: 35
diff changeset
  1342
    QCOMPARE(map[MetaKeyAuthor].toString(), gQTMediaAuthorPrefix + "0");
hgs
parents: 35
diff changeset
  1343
    QCOMPARE(map[MetaKeyCopyright].toString(), gQTMediaCopyrightPrefix + "0");
hgs
parents: 35
diff changeset
  1344
    QCOMPARE(map[MetaKeyLanguageString].toString(), gQTMediaLanguagePrefix + "0");
hgs
parents: 35
diff changeset
  1345
    QCOMPARE(map[MetaKeyFormat].toString(), gQTMediaFormatPrefix + "0");
hgs
parents: 35
diff changeset
  1346
    QCOMPARE(map[MetaKeyVideoResolutionString].toString(), hbTrId("txt_videos_list_l1l2").arg(1).arg(2));
hgs
parents: 35
diff changeset
  1347
    QCOMPARE(map[MetaKeyBitRate].toString(), hbTrId("txt_videos_list_l1_kbps", 800));
30
hgs
parents:
diff changeset
  1348
    
36
hgs
parents: 35
diff changeset
  1349
    // Mbps case
hgs
parents: 35
diff changeset
  1350
    media = mMediaFactory->mediaArray()->operator [](1);
hgs
parents: 35
diff changeset
  1351
    emit signalVideoDetailsCompleted(media);
hgs
parents: 35
diff changeset
  1352
    QCOMPARE(spysignal.count, 2);
hgs
parents: 35
diff changeset
  1353
    map = spysignal.arg.toMap();    
hgs
parents: 35
diff changeset
  1354
    QVERIFY(map.contains(MetaKeyBitRate));
hgs
parents: 35
diff changeset
  1355
    QCOMPARE(map[MetaKeyBitRate].toString(), hbTrId("txt_videos_list_l1_mbps", 2));
hgs
parents: 35
diff changeset
  1356
    
hgs
parents: 35
diff changeset
  1357
    // empty media case
30
hgs
parents:
diff changeset
  1358
    spysignal.clear();
36
hgs
parents: 35
diff changeset
  1359
    mMediaFactory->removeArray();
hgs
parents: 35
diff changeset
  1360
    mMediaFactory->createMediaItems(1, MediaDataId);
hgs
parents: 35
diff changeset
  1361
    CMPXMedia* emptyMedia = mMediaFactory->mediaArray()->operator [](0);
hgs
parents: 35
diff changeset
  1362
    
hgs
parents: 35
diff changeset
  1363
    emit signalVideoDetailsCompleted(emptyMedia);
hgs
parents: 35
diff changeset
  1364
    QCOMPARE(spysignal.count, 1);
hgs
parents: 35
diff changeset
  1365
    map = spysignal.arg.toMap();
hgs
parents: 35
diff changeset
  1366
    QCOMPARE(map.count(), 2);
hgs
parents: 35
diff changeset
  1367
    QVERIFY(map.contains(MetaKeyDurationString));
hgs
parents: 35
diff changeset
  1368
    QVERIFY(map.contains(MetaKeySizeString));
30
hgs
parents:
diff changeset
  1369
    
hgs
parents:
diff changeset
  1370
    disconnect(this, SIGNAL(signalNewVideoList(CMPXMediaArray*)), mTestObject, SLOT(newVideoListSlot(CMPXMediaArray*)));  
hgs
parents:
diff changeset
  1371
    disconnect(this, SIGNAL(signalVideoDetailsCompleted(TMPXItemId)), mTestObject, SLOT(videoDetailsCompletedSlot(TMPXItemId)));
hgs
parents:
diff changeset
  1372
}
hgs
parents:
diff changeset
  1373
hgs
parents:
diff changeset
  1374
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
  1375
// testCollectionItemCount
hgs
parents:
diff changeset
  1376
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
  1377
//
hgs
parents:
diff changeset
  1378
void TestVideoModel_p::testCollectionItemCount()
hgs
parents:
diff changeset
  1379
{    
hgs
parents:
diff changeset
  1380
    QVERIFY(mTestObject->getVideoCount() == 0);
hgs
parents:
diff changeset
  1381
    
hgs
parents:
diff changeset
  1382
    QVERIFY(connect(this, SIGNAL(signalNewVideoList(CMPXMediaArray*)), mTestObject, SLOT(newVideoListSlot(CMPXMediaArray*))));    
hgs
parents:
diff changeset
  1383
    
hgs
parents:
diff changeset
  1384
    mMediaFactory->removeArray();
hgs
parents:
diff changeset
  1385
    mMediaFactory->createCollectionItems();
hgs
parents:
diff changeset
  1386
    emit signalNewVideoList(mMediaFactory->copyOfMediaArray());
34
hgs
parents: 30
diff changeset
  1387
    int count = mTestObject->getVideoCount();
30
hgs
parents:
diff changeset
  1388
    QVERIFY( mTestObject->getVideoCount() == 2);
hgs
parents:
diff changeset
  1389
hgs
parents:
diff changeset
  1390
    disconnect(this, SIGNAL(signalNewVideoList(CMPXMediaArray*)), mTestObject, SLOT(newVideoListSlot(CMPXMediaArray*)));
hgs
parents:
diff changeset
  1391
}
hgs
parents:
diff changeset
  1392
hgs
parents:
diff changeset
  1393
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
  1394
// testGetCollectionIdFromIndex
hgs
parents:
diff changeset
  1395
// -----------------------------------------------------------------------------
hgs
parents:
diff changeset
  1396
//
hgs
parents:
diff changeset
  1397
void TestVideoModel_p::testGetCollectionIdFromIndex()
hgs
parents:
diff changeset
  1398
{
hgs
parents:
diff changeset
  1399
    QVERIFY(mTestObject->getMediaIdFromIndex(0) == -1);
hgs
parents:
diff changeset
  1400
    QVERIFY(mTestObject->getMediaIdFromIndex(-1) == -1);
hgs
parents:
diff changeset
  1401
    
hgs
parents:
diff changeset
  1402
    mMediaFactory->removeArray();
hgs
parents:
diff changeset
  1403
    QVERIFY(connect(this, SIGNAL(signalNewVideoList(CMPXMediaArray*)), mTestObject, SLOT(newVideoListSlot(CMPXMediaArray*))));          
hgs
parents:
diff changeset
  1404
    mMediaFactory->createCollectionItems();
hgs
parents:
diff changeset
  1405
    emit signalNewVideoList(mMediaFactory->copyOfMediaArray());
34
hgs
parents: 30
diff changeset
  1406
    QVERIFY( mTestObject->getVideoCount() == 2);
30
hgs
parents:
diff changeset
  1407
    QVERIFY(mTestObject->getMediaIdFromIndex(-1) == TMPXItemId::InvalidId());
34
hgs
parents: 30
diff changeset
  1408
    TMPXItemId id = mTestObject->getMediaIdFromIndex(0);
30
hgs
parents:
diff changeset
  1409
    QVERIFY(mTestObject->getMediaIdFromIndex(0) == TMPXItemId(KVcxMvcCategoryIdDownloads, 1));
34
hgs
parents: 30
diff changeset
  1410
    id = mTestObject->getMediaIdFromIndex(1);
30
hgs
parents:
diff changeset
  1411
    QVERIFY(mTestObject->getMediaIdFromIndex(1) == TMPXItemId(KVcxMvcCategoryIdCaptured, 1));
hgs
parents:
diff changeset
  1412
    
hgs
parents:
diff changeset
  1413
    disconnect(this, SIGNAL(signalNewVideoList(CMPXMediaArray*)), mTestObject, SLOT(newVideoListSlot(CMPXMediaArray*)));  
hgs
parents:
diff changeset
  1414
}
hgs
parents:
diff changeset
  1415
hgs
parents:
diff changeset
  1416
// End of file
hgs
parents:
diff changeset
  1417
    
hgs
parents:
diff changeset
  1418
hgs
parents:
diff changeset
  1419