← Back to branch summary

~phablet-team/+junk/qtmultimedia

« back to all changes in this revision

Viewing changes to tests/auto/unit/qmediaobject/tst_qmediaobject.cpp

  • Committer: Jim Hodapp
  • Date: 2015-05-15 19:17:49 UTC
  • Revision ID: jim.hodapp@canonical.com-20150515191749-r4xausjaaphme9ok
Initial import.

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/auto/unit/qmediaobject/tst_qmediaobject.cpp
 
1
/****************************************************************************
 
2
**
 
3
** Copyright (C) 2014 Digia Plc and/or its subsidiary(-ies).
 
4
** Contact: http://www.qt-project.org/legal
 
5
**
 
6
** This file is part of the test suite of the Qt Toolkit.
 
7
**
 
8
** $QT_BEGIN_LICENSE:LGPL21$
 
9
** Commercial License Usage
 
10
** Licensees holding valid commercial Qt licenses may use this file in
 
11
** accordance with the commercial license agreement provided with the
 
12
** Software or, alternatively, in accordance with the terms contained in
 
13
** a written agreement between you and Digia. For licensing terms and
 
14
** conditions see http://qt.digia.com/licensing. For further information
 
15
** use the contact form at http://qt.digia.com/contact-us.
 
16
**
 
17
** GNU Lesser General Public License Usage
 
18
** Alternatively, this file may be used under the terms of the GNU Lesser
 
19
** General Public License version 2.1 or version 3 as published by the Free
 
20
** Software Foundation and appearing in the file LICENSE.LGPLv21 and
 
21
** LICENSE.LGPLv3 included in the packaging of this file. Please review the
 
22
** following information to ensure the GNU Lesser General Public License
 
23
** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
 
24
** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 
25
**
 
26
** In addition, as a special exception, Digia gives you certain additional
 
27
** rights. These rights are described in the Digia Qt LGPL Exception
 
28
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 
29
**
 
30
** $QT_END_LICENSE$
 
31
**
 
32
****************************************************************************/
 
33
 
 
34
//TESTED_COMPONENT=src/multimedia
 
35
 
 
36
#include <QtTest/QtTest>
 
37
 
 
38
#include <QtCore/qtimer.h>
 
39
 
 
40
#include <QtMultimedia/qmediametadata.h>
 
41
#include <qmediaobject.h>
 
42
#include <qmediaservice.h>
 
43
#include <qmetadatareadercontrol.h>
 
44
#include <qaudioinputselectorcontrol.h>
 
45
 
 
46
#include "mockmediarecorderservice.h"
 
47
#include "mockmediaserviceprovider.h"
 
48
#include "mockmetadatareadercontrol.h"
 
49
#include "mockavailabilitycontrol.h"
 
50
 
 
51
class QtTestMediaObjectService : public QMediaService
 
52
{
 
53
    Q_OBJECT
 
54
public:
 
55
    QtTestMediaObjectService(QObject *parent = 0, MockAvailabilityControl *availability = 0)
 
56
        : QMediaService(parent)
 
57
        , availabilityControl(availability)
 
58
        , metaDataRef(0)
 
59
        , hasMetaData(true)
 
60
    {
 
61
    }
 
62
 
 
63
    QMediaControl *requestControl(const char *iid)
 
64
    {
 
65
        if (hasMetaData && qstrcmp(iid, QMetaDataReaderControl_iid) == 0)
 
66
            return &metaData;
 
67
        else if (qstrcmp(iid, QMediaAvailabilityControl_iid) == 0)
 
68
            return availabilityControl;
 
69
        else
 
70
            return 0;
 
71
    }
 
72
 
 
73
    void releaseControl(QMediaControl *)
 
74
    {
 
75
    }
 
76
 
 
77
    MockMetaDataReaderControl metaData;
 
78
    MockAvailabilityControl *availabilityControl;
 
79
    int metaDataRef;
 
80
    bool hasMetaData;
 
81
};
 
82
 
 
83
QT_USE_NAMESPACE
 
84
 
 
85
class tst_QMediaObject : public QObject
 
86
{
 
87
    Q_OBJECT
 
88
 
 
89
private slots:
 
90
    void propertyWatch();
 
91
    void notifySignals_data();
 
92
    void notifySignals();
 
93
    void notifyInterval_data();
 
94
    void notifyInterval();
 
95
 
 
96
    void nullMetaDataControl();
 
97
    void isMetaDataAvailable();
 
98
    void metaDataChanged();
 
99
    void metaData_data();
 
100
    void metaData();
 
101
    void availability();
 
102
 
 
103
    void service();
 
104
 
 
105
private:
 
106
    void setupNotifyTests();
 
107
};
 
108
 
 
109
class QtTestMediaObject : public QMediaObject
 
110
{
 
111
    Q_OBJECT
 
112
    Q_PROPERTY(int a READ a WRITE setA NOTIFY aChanged)
 
113
    Q_PROPERTY(int b READ b WRITE setB NOTIFY bChanged)
 
114
    Q_PROPERTY(int c READ c WRITE setC NOTIFY cChanged)
 
115
    Q_PROPERTY(int d READ d WRITE setD)
 
116
public:
 
117
    QtTestMediaObject(QMediaService *service = 0): QMediaObject(0, service), m_a(0), m_b(0), m_c(0), m_d(0) {}
 
118
 
 
119
    using QMediaObject::addPropertyWatch;
 
120
    using QMediaObject::removePropertyWatch;
 
121
 
 
122
    int a() const { return m_a; }
 
123
    void setA(int a) { m_a = a; }
 
124
 
 
125
    int b() const { return m_b; }
 
126
    void setB(int b) { m_b = b; }
 
127
 
 
128
    int c() const { return m_c; }
 
129
    void setC(int c) { m_c = c; }
 
130
 
 
131
    int d() const { return m_d; }
 
132
    void setD(int d) { m_d = d; }
 
133
 
 
134
Q_SIGNALS:
 
135
    void aChanged(int a);
 
136
    void bChanged(int b);
 
137
    void cChanged(int c);
 
138
 
 
139
private:
 
140
    int m_a;
 
141
    int m_b;
 
142
    int m_c;
 
143
    int m_d;
 
144
};
 
145
 
 
146
void tst_QMediaObject::propertyWatch()
 
147
{
 
148
    QtTestMediaObject object;
 
149
    object.setNotifyInterval(0);
 
150
 
 
151
    QEventLoop loop;
 
152
    connect(&object, SIGNAL(aChanged(int)), &QTestEventLoop::instance(), SLOT(exitLoop()));
 
153
    connect(&object, SIGNAL(bChanged(int)), &QTestEventLoop::instance(), SLOT(exitLoop()));
 
154
    connect(&object, SIGNAL(cChanged(int)), &QTestEventLoop::instance(), SLOT(exitLoop()));
 
155
 
 
156
    QSignalSpy aSpy(&object, SIGNAL(aChanged(int)));
 
157
    QSignalSpy bSpy(&object, SIGNAL(bChanged(int)));
 
158
    QSignalSpy cSpy(&object, SIGNAL(cChanged(int)));
 
159
 
 
160
    QTestEventLoop::instance().enterLoop(1);
 
161
 
 
162
    QCOMPARE(aSpy.count(), 0);
 
163
    QCOMPARE(bSpy.count(), 0);
 
164
    QCOMPARE(cSpy.count(), 0);
 
165
 
 
166
    int aCount = 0;
 
167
    int bCount = 0;
 
168
    int cCount = 0;
 
169
 
 
170
    object.addPropertyWatch("a");
 
171
 
 
172
    QTestEventLoop::instance().enterLoop(1);
 
173
 
 
174
    QVERIFY(aSpy.count() > aCount);
 
175
    QCOMPARE(bSpy.count(), 0);
 
176
    QCOMPARE(cSpy.count(), 0);
 
177
    QCOMPARE(aSpy.last().value(0).toInt(), 0);
 
178
 
 
179
    aCount = aSpy.count();
 
180
 
 
181
    object.setA(54);
 
182
    object.setB(342);
 
183
    object.setC(233);
 
184
 
 
185
    QTestEventLoop::instance().enterLoop(1);
 
186
 
 
187
    QVERIFY(aSpy.count() > aCount);
 
188
    QCOMPARE(bSpy.count(), 0);
 
189
    QCOMPARE(cSpy.count(), 0);
 
190
    QCOMPARE(aSpy.last().value(0).toInt(), 54);
 
191
 
 
192
    aCount = aSpy.count();
 
193
 
 
194
    object.addPropertyWatch("b");
 
195
    object.addPropertyWatch("d");
 
196
    object.removePropertyWatch("e");
 
197
    object.setA(43);
 
198
    object.setB(235);
 
199
    object.setC(90);
 
200
 
 
201
    QTestEventLoop::instance().enterLoop(1);
 
202
 
 
203
    QVERIFY(aSpy.count() > aCount);
 
204
    QVERIFY(bSpy.count() > bCount);
 
205
    QCOMPARE(cSpy.count(), 0);
 
206
    QCOMPARE(aSpy.last().value(0).toInt(), 43);
 
207
    QCOMPARE(bSpy.last().value(0).toInt(), 235);
 
208
 
 
209
    aCount = aSpy.count();
 
210
    bCount = bSpy.count();
 
211
 
 
212
    object.removePropertyWatch("a");
 
213
    object.addPropertyWatch("c");
 
214
    object.addPropertyWatch("e");
 
215
 
 
216
    QTestEventLoop::instance().enterLoop(1);
 
217
 
 
218
    QCOMPARE(aSpy.count(), aCount);
 
219
    QVERIFY(bSpy.count() > bCount);
 
220
    QVERIFY(cSpy.count() > cCount);
 
221
    QCOMPARE(bSpy.last().value(0).toInt(), 235);
 
222
    QCOMPARE(cSpy.last().value(0).toInt(), 90);
 
223
 
 
224
    bCount = bSpy.count();
 
225
    cCount = cSpy.count();
 
226
 
 
227
    object.setA(435);
 
228
    object.setC(9845);
 
229
 
 
230
    QTestEventLoop::instance().enterLoop(1);
 
231
 
 
232
    QCOMPARE(aSpy.count(), aCount);
 
233
    QVERIFY(bSpy.count() > bCount);
 
234
    QVERIFY(cSpy.count() > cCount);
 
235
    QCOMPARE(bSpy.last().value(0).toInt(), 235);
 
236
    QCOMPARE(cSpy.last().value(0).toInt(), 9845);
 
237
 
 
238
    bCount = bSpy.count();
 
239
    cCount = cSpy.count();
 
240
 
 
241
    object.setA(8432);
 
242
    object.setB(324);
 
243
    object.setC(443);
 
244
    object.removePropertyWatch("c");
 
245
    object.removePropertyWatch("d");
 
246
 
 
247
    QTestEventLoop::instance().enterLoop(1);
 
248
 
 
249
    QCOMPARE(aSpy.count(), aCount);
 
250
    QVERIFY(bSpy.count() > bCount);
 
251
    QCOMPARE(cSpy.count(), cCount);
 
252
    QCOMPARE(bSpy.last().value(0).toInt(), 324);
 
253
    QCOMPARE(cSpy.last().value(0).toInt(), 9845);
 
254
 
 
255
    bCount = bSpy.count();
 
256
 
 
257
    object.removePropertyWatch("b");
 
258
 
 
259
    QTestEventLoop::instance().enterLoop(1);
 
260
 
 
261
    QCOMPARE(aSpy.count(), aCount);
 
262
    QCOMPARE(bSpy.count(), bCount);
 
263
    QCOMPARE(cSpy.count(), cCount);
 
264
}
 
265
 
 
266
void tst_QMediaObject::setupNotifyTests()
 
267
{
 
268
    QTest::addColumn<int>("interval");
 
269
    QTest::addColumn<int>("count");
 
270
 
 
271
    QTest::newRow("single 750ms")
 
272
            << 750
 
273
            << 1;
 
274
    QTest::newRow("single 600ms")
 
275
            << 600
 
276
            << 1;
 
277
    QTest::newRow("x3 300ms")
 
278
            << 300
 
279
            << 3;
 
280
    QTest::newRow("x5 180ms")
 
281
            << 180
 
282
            << 5;
 
283
}
 
284
 
 
285
void tst_QMediaObject::notifySignals_data()
 
286
{
 
287
    setupNotifyTests();
 
288
}
 
289
 
 
290
void tst_QMediaObject::notifySignals()
 
291
{
 
292
    QFETCH(int, interval);
 
293
    QFETCH(int, count);
 
294
 
 
295
    QtTestMediaObject object;
 
296
    object.setNotifyInterval(interval);
 
297
    object.addPropertyWatch("a");
 
298
 
 
299
    QSignalSpy spy(&object, SIGNAL(aChanged(int)));
 
300
 
 
301
    QTestEventLoop::instance().enterLoop(1);
 
302
 
 
303
    QCOMPARE(spy.count(), count);
 
304
}
 
305
 
 
306
void tst_QMediaObject::notifyInterval_data()
 
307
{
 
308
    setupNotifyTests();
 
309
}
 
310
 
 
311
void tst_QMediaObject::notifyInterval()
 
312
{
 
313
    QFETCH(int, interval);
 
314
 
 
315
    QtTestMediaObject object;
 
316
    QSignalSpy spy(&object, SIGNAL(notifyIntervalChanged(int)));
 
317
 
 
318
    object.setNotifyInterval(interval);
 
319
    QCOMPARE(object.notifyInterval(), interval);
 
320
    QCOMPARE(spy.count(), 1);
 
321
    QCOMPARE(spy.last().value(0).toInt(), interval);
 
322
 
 
323
    object.setNotifyInterval(interval);
 
324
    QCOMPARE(object.notifyInterval(), interval);
 
325
    QCOMPARE(spy.count(), 1);
 
326
}
 
327
 
 
328
void tst_QMediaObject::nullMetaDataControl()
 
329
{
 
330
    const QString titleKey(QLatin1String("Title"));
 
331
    const QString title(QLatin1String("Host of Seraphim"));
 
332
 
 
333
    QtTestMediaObjectService service;
 
334
    service.hasMetaData = false;
 
335
 
 
336
    QtTestMediaObject object(&service);
 
337
 
 
338
    QSignalSpy spy(&object, SIGNAL(metaDataChanged()));
 
339
 
 
340
    QCOMPARE(object.isMetaDataAvailable(), false);
 
341
 
 
342
    QCOMPARE(object.metaData(QMediaMetaData::Title).toString(), QString());
 
343
    QCOMPARE(object.availableMetaData(), QStringList());
 
344
    QCOMPARE(spy.count(), 0);
 
345
}
 
346
 
 
347
void tst_QMediaObject::isMetaDataAvailable()
 
348
{
 
349
    QtTestMediaObjectService service;
 
350
    service.metaData.setMetaDataAvailable(false);
 
351
 
 
352
    QtTestMediaObject object(&service);
 
353
    QCOMPARE(object.isMetaDataAvailable(), false);
 
354
 
 
355
    QSignalSpy spy(&object, SIGNAL(metaDataAvailableChanged(bool)));
 
356
    service.metaData.setMetaDataAvailable(true);
 
357
 
 
358
    QCOMPARE(object.isMetaDataAvailable(), true);
 
359
    QCOMPARE(spy.count(), 1);
 
360
    QCOMPARE(spy.at(0).at(0).toBool(), true);
 
361
 
 
362
    service.metaData.setMetaDataAvailable(false);
 
363
 
 
364
    QCOMPARE(object.isMetaDataAvailable(), false);
 
365
    QCOMPARE(spy.count(), 2);
 
366
    QCOMPARE(spy.at(1).at(0).toBool(), false);
 
367
}
 
368
 
 
369
void tst_QMediaObject::metaDataChanged()
 
370
{
 
371
    QtTestMediaObjectService service;
 
372
    QtTestMediaObject object(&service);
 
373
 
 
374
    QSignalSpy changedSpy(&object, SIGNAL(metaDataChanged()));
 
375
    QSignalSpy changedWithValueSpy(&object, SIGNAL(metaDataChanged(QString,QVariant)));
 
376
 
 
377
    service.metaData.setMetaData("key", "Value");
 
378
    QCOMPARE(changedSpy.count(), 1);
 
379
    QCOMPARE(changedWithValueSpy.count(), 1);
 
380
    QCOMPARE(changedWithValueSpy.last()[0], QVariant("key"));
 
381
    QCOMPARE(changedWithValueSpy.last()[1].value<QVariant>(), QVariant("Value"));
 
382
 
 
383
    service.metaData.setMetaData("key", "Value");
 
384
    QCOMPARE(changedSpy.count(), 1);
 
385
    QCOMPARE(changedWithValueSpy.count(), 1);
 
386
 
 
387
    service.metaData.setMetaData("key2", "Value");
 
388
    QCOMPARE(changedSpy.count(), 2);
 
389
    QCOMPARE(changedWithValueSpy.count(), 2);
 
390
    QCOMPARE(changedWithValueSpy.last()[0], QVariant("key2"));
 
391
    QCOMPARE(changedWithValueSpy.last()[1].value<QVariant>(), QVariant("Value"));
 
392
}
 
393
 
 
394
void tst_QMediaObject::metaData_data()
 
395
{
 
396
    QTest::addColumn<QString>("artist");
 
397
    QTest::addColumn<QString>("title");
 
398
    QTest::addColumn<QString>("genre");
 
399
 
 
400
    QTest::newRow("")
 
401
            << QString::fromLatin1("Dead Can Dance")
 
402
            << QString::fromLatin1("Host of Seraphim")
 
403
            << QString::fromLatin1("Awesome");
 
404
}
 
405
 
 
406
void tst_QMediaObject::metaData()
 
407
{
 
408
    QFETCH(QString, artist);
 
409
    QFETCH(QString, title);
 
410
    QFETCH(QString, genre);
 
411
 
 
412
    QtTestMediaObjectService service;
 
413
    service.metaData.populateMetaData();
 
414
 
 
415
    QtTestMediaObject object(&service);
 
416
    QVERIFY(object.availableMetaData().isEmpty());
 
417
 
 
418
    service.metaData.m_data.insert(QMediaMetaData::AlbumArtist, artist);
 
419
    service.metaData.m_data.insert(QMediaMetaData::Title, title);
 
420
    service.metaData.m_data.insert(QMediaMetaData::Genre, genre);
 
421
 
 
422
    QCOMPARE(object.metaData(QMediaMetaData::AlbumArtist).toString(), artist);
 
423
    QCOMPARE(object.metaData(QMediaMetaData::Title).toString(), title);
 
424
 
 
425
    QStringList metaDataKeys = object.availableMetaData();
 
426
    QCOMPARE(metaDataKeys.size(), 3);
 
427
    QVERIFY(metaDataKeys.contains(QMediaMetaData::AlbumArtist));
 
428
    QVERIFY(metaDataKeys.contains(QMediaMetaData::Title));
 
429
    QVERIFY(metaDataKeys.contains(QMediaMetaData::Genre));
 
430
}
 
431
 
 
432
void tst_QMediaObject::availability()
 
433
{
 
434
    {
 
435
        QtTestMediaObject nullObject(0);
 
436
        QCOMPARE(nullObject.isAvailable(), false);
 
437
        QCOMPARE(nullObject.availability(), QMultimedia::ServiceMissing);
 
438
    }
 
439
 
 
440
    {
 
441
        QtTestMediaObjectService service;
 
442
        QtTestMediaObject object(&service);
 
443
        QCOMPARE(object.isAvailable(), true);
 
444
        QCOMPARE(object.availability(), QMultimedia::Available);
 
445
    }
 
446
 
 
447
    {
 
448
        MockAvailabilityControl available(QMultimedia::Available);
 
449
        QtTestMediaObjectService service(0, &available);
 
450
        QtTestMediaObject object(&service);
 
451
        QSignalSpy availabilitySpy(&object, SIGNAL(availabilityChanged(bool)));
 
452
        QSignalSpy availabilityStatusSpy(&object, SIGNAL(availabilityChanged(QMultimedia::AvailabilityStatus)));
 
453
 
 
454
        QCOMPARE(object.isAvailable(), true);
 
455
        QCOMPARE(object.availability(), QMultimedia::Available);
 
456
 
 
457
        available.setAvailability(QMultimedia::Busy);
 
458
        QCOMPARE(object.isAvailable(), false);
 
459
        QCOMPARE(object.availability(), QMultimedia::Busy);
 
460
        QCOMPARE(availabilitySpy.count(), 1);
 
461
        QCOMPARE(availabilityStatusSpy.count(), 1);
 
462
 
 
463
        available.setAvailability(QMultimedia::Available);
 
464
        QCOMPARE(object.isAvailable(), true);
 
465
        QCOMPARE(object.availability(), QMultimedia::Available);
 
466
        QCOMPARE(availabilitySpy.count(), 2);
 
467
        QCOMPARE(availabilityStatusSpy.count(), 2);
 
468
    }
 
469
 
 
470
    {
 
471
        MockAvailabilityControl available(QMultimedia::Busy);
 
472
        QtTestMediaObjectService service(0, &available);
 
473
        QtTestMediaObject object(&service);
 
474
        QSignalSpy availabilitySpy(&object, SIGNAL(availabilityChanged(bool)));
 
475
        QSignalSpy availabilityStatusSpy(&object, SIGNAL(availabilityChanged(QMultimedia::AvailabilityStatus)));
 
476
 
 
477
        QCOMPARE(object.isAvailable(), false);
 
478
        QCOMPARE(object.availability(), QMultimedia::Busy);
 
479
 
 
480
        available.setAvailability(QMultimedia::Available);
 
481
        QCOMPARE(object.isAvailable(), true);
 
482
        QCOMPARE(object.availability(), QMultimedia::Available);
 
483
        QCOMPARE(availabilitySpy.count(), 1);
 
484
        QCOMPARE(availabilityStatusSpy.count(), 1);
 
485
    }
 
486
}
 
487
 
 
488
 void tst_QMediaObject::service()
 
489
 {
 
490
     // Create the mediaobject with service.
 
491
     QtTestMediaObjectService service;
 
492
     QtTestMediaObject mediaObject1(&service);
 
493
 
 
494
     // Get service and Compare if it equal to the service passed as an argument in mediaObject1.
 
495
     QMediaService *service1 = mediaObject1.service();
 
496
     QVERIFY(service1 != NULL);
 
497
     QCOMPARE(service1,&service);
 
498
 
 
499
     // Create the mediaobject with empty service and verify that service() returns NULL.
 
500
     QtTestMediaObject mediaObject2;
 
501
     QMediaService *service2 = mediaObject2.service();
 
502
     QVERIFY(service2 == NULL);
 
503
}
 
504
 
 
505
QTEST_GUILESS_MAIN(tst_QMediaObject)
 
506
#include "tst_qmediaobject.moc"