1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the Qt Mobility Components.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 #include <QtTest/QtTest>

    43 

    44 #include <QtCore/qtimer.h>

    45 

    46 #include <qmediaobject.h>

    47 #include <qmediaservice.h>

    48 #include <qmetadatacontrol.h>

    49 

    50 QTM_USE_NAMESPACE

    51 class tst_QMediaObject : public QObject

    52 {

    53     Q_OBJECT

    54 

    55 private slots:

    56     void propertyWatch();

    57     void notifySignals_data();

    58     void notifySignals();

    59     void notifyInterval_data();

    60     void notifyInterval();

    61 

    62     void nullMetaDataControl();

    63     void isMetaDataAvailable();

    64     void isWritable();

    65     void metaDataChanged();

    66     void metaData_data();

    67     void metaData();

    68     void setMetaData_data();

    69     void setMetaData();

    70     void extendedMetaData_data() { metaData_data(); }

    71     void extendedMetaData();

    72     void setExtendedMetaData_data() { extendedMetaData_data(); }

    73     void setExtendedMetaData();

    74 

    75 

    76 private:

    77     void setupNotifyTests();

    78 };

    79 

    80 class QtTestMetaDataProvider : public QMetaDataControl

    81 {

    82     Q_OBJECT

    83 public:

    84     QtTestMetaDataProvider(QObject *parent = 0)

    85         : QMetaDataControl(parent)

    86         , m_available(false)

    87         , m_writable(false)

    88     {

    89     }

    90 

    91     bool isMetaDataAvailable() const { return m_available; }

    92     void setMetaDataAvailable(bool available) {

    93         if (m_available != available)

    94             emit metaDataAvailableChanged(m_available = available);

    95     }

    96     QList<QtMedia::MetaData> availableMetaData() const { return m_data.keys(); }

    97 

    98     bool isWritable() const { return m_writable; }

    99     void setWritable(bool writable) { emit writableChanged(m_writable = writable); }

   100 

   101     QVariant metaData(QtMedia::MetaData key) const { return m_data.value(key); }

   102     void setMetaData(QtMedia::MetaData key, const QVariant &value) {

   103         m_data.insert(key, value); }

   104 

   105     QVariant extendedMetaData(const QString &key) const { return m_extendedData.value(key); }

   106     void setExtendedMetaData(const QString &key, const QVariant &value) {

   107         m_extendedData.insert(key, value); }

   108 

   109     QStringList availableExtendedMetaData() const { return m_extendedData.keys(); }

   110 

   111     using QMetaDataControl::metaDataChanged;

   112 

   113     void populateMetaData()

   114     {

   115         m_available = true;

   116     }

   117 

   118     bool m_available;

   119     bool m_writable;

   120     QMap<QtMedia::MetaData, QVariant> m_data;

   121     QMap<QString, QVariant> m_extendedData;

   122 };

   123 

   124 class QtTestMetaDataService : public QMediaService

   125 {

   126     Q_OBJECT

   127 public:

   128     QtTestMetaDataService(QObject *parent = 0):QMediaService(parent), hasMetaData(true)

   129     {

   130     }

   131 

   132     QMediaControl *control(const char *iid) const

   133     {

   134         if (hasMetaData && qstrcmp(iid, QMetaDataControl_iid) == 0)

   135             return const_cast<QtTestMetaDataProvider *>(&metaData);

   136         else

   137             return 0;

   138     }

   139 

   140     QtTestMetaDataProvider metaData;

   141     bool hasMetaData;

   142 };

   143 

   144 

   145 class QtTestMediaObject : public QMediaObject

   146 {

   147     Q_OBJECT

   148     Q_PROPERTY(int a READ a WRITE setA NOTIFY aChanged)

   149     Q_PROPERTY(int b READ b WRITE setB NOTIFY bChanged)

   150     Q_PROPERTY(int c READ c WRITE setC NOTIFY cChanged)

   151     Q_PROPERTY(int d READ d WRITE setD)

   152 public:

   153     QtTestMediaObject(QMediaService *service = 0): QMediaObject(0, service), m_a(0), m_b(0), m_c(0), m_d(0) {}

   154 

   155     using QMediaObject::addPropertyWatch;

   156     using QMediaObject::removePropertyWatch;

   157 

   158     int a() const { return m_a; }

   159     void setA(int a) { m_a = a; }

   160 

   161     int b() const { return m_b; }

   162     void setB(int b) { m_b = b; }

   163 

   164     int c() const { return m_c; }

   165     void setC(int c) { m_c = c; }

   166 

   167     int d() const { return m_d; }

   168     void setD(int d) { m_d = d; }

   169 

   170 Q_SIGNALS:

   171     void aChanged(int a);

   172     void bChanged(int b);

   173     void cChanged(int c);

   174 

   175 private:

   176     int m_a;

   177     int m_b;

   178     int m_c;

   179     int m_d;

   180 };

   181 

   182 void tst_QMediaObject::propertyWatch()

   183 {

   184     QtTestMediaObject object;

   185     object.setNotifyInterval(0);

   186 

   187     QEventLoop loop;

   188     connect(&object, SIGNAL(aChanged(int)), &QTestEventLoop::instance(), SLOT(exitLoop()));

   189     connect(&object, SIGNAL(bChanged(int)), &QTestEventLoop::instance(), SLOT(exitLoop()));

   190     connect(&object, SIGNAL(cChanged(int)), &QTestEventLoop::instance(), SLOT(exitLoop()));

   191 

   192     QSignalSpy aSpy(&object, SIGNAL(aChanged(int)));

   193     QSignalSpy bSpy(&object, SIGNAL(bChanged(int)));

   194     QSignalSpy cSpy(&object, SIGNAL(cChanged(int)));

   195 

   196     QTestEventLoop::instance().enterLoop(1);

   197 

   198     QCOMPARE(aSpy.count(), 0);

   199     QCOMPARE(bSpy.count(), 0);

   200     QCOMPARE(cSpy.count(), 0);

   201 

   202     int aCount = 0;

   203     int bCount = 0;

   204     int cCount = 0;

   205 

   206     object.addPropertyWatch("a");

   207 

   208     QTestEventLoop::instance().enterLoop(1);

   209 

   210     QVERIFY(aSpy.count() > aCount);

   211     QCOMPARE(bSpy.count(), 0);

   212     QCOMPARE(cSpy.count(), 0);

   213     QCOMPARE(aSpy.last().value(0).toInt(), 0);

   214 

   215     aCount = aSpy.count();

   216 

   217     object.setA(54);

   218     object.setB(342);

   219     object.setC(233);

   220 

   221     QTestEventLoop::instance().enterLoop(1);

   222 

   223     QVERIFY(aSpy.count() > aCount);

   224     QCOMPARE(bSpy.count(), 0);

   225     QCOMPARE(cSpy.count(), 0);

   226     QCOMPARE(aSpy.last().value(0).toInt(), 54);

   227 

   228     aCount = aSpy.count();

   229 

   230     object.addPropertyWatch("b");

   231     object.addPropertyWatch("d");

   232     object.removePropertyWatch("e");

   233     object.setA(43);

   234     object.setB(235);

   235     object.setC(90);

   236 

   237     QTestEventLoop::instance().enterLoop(1);

   238 

   239     QVERIFY(aSpy.count() > aCount);

   240     QVERIFY(bSpy.count() > bCount);

   241     QCOMPARE(cSpy.count(), 0);

   242     QCOMPARE(aSpy.last().value(0).toInt(), 43);

   243     QCOMPARE(bSpy.last().value(0).toInt(), 235);

   244 

   245     aCount = aSpy.count();

   246     bCount = bSpy.count();

   247 

   248     object.removePropertyWatch("a");

   249     object.addPropertyWatch("c");

   250     object.addPropertyWatch("e");

   251 

   252     QTestEventLoop::instance().enterLoop(1);

   253 

   254     QCOMPARE(aSpy.count(), aCount);

   255     QVERIFY(bSpy.count() > bCount);

   256     QVERIFY(cSpy.count() > cCount);

   257     QCOMPARE(bSpy.last().value(0).toInt(), 235);

   258     QCOMPARE(cSpy.last().value(0).toInt(), 90);

   259 

   260     bCount = bSpy.count();

   261     cCount = cSpy.count();

   262 

   263     object.setA(435);

   264     object.setC(9845);

   265 

   266     QTestEventLoop::instance().enterLoop(1);

   267 

   268     QCOMPARE(aSpy.count(), aCount);

   269     QVERIFY(bSpy.count() > bCount);

   270     QVERIFY(cSpy.count() > cCount);

   271     QCOMPARE(bSpy.last().value(0).toInt(), 235);

   272     QCOMPARE(cSpy.last().value(0).toInt(), 9845);

   273 

   274     bCount = bSpy.count();

   275     cCount = cSpy.count();

   276 

   277     object.setA(8432);

   278     object.setB(324);

   279     object.setC(443);

   280     object.removePropertyWatch("c");

   281     object.removePropertyWatch("d");

   282 

   283     QTestEventLoop::instance().enterLoop(1);

   284 

   285     QCOMPARE(aSpy.count(), aCount);

   286     QVERIFY(bSpy.count() > bCount);

   287     QCOMPARE(cSpy.count(), cCount);

   288     QCOMPARE(bSpy.last().value(0).toInt(), 324);

   289     QCOMPARE(cSpy.last().value(0).toInt(), 9845);

   290 

   291     bCount = bSpy.count();

   292 

   293     object.removePropertyWatch("b");

   294 

   295     QTestEventLoop::instance().enterLoop(1);

   296 

   297     QCOMPARE(aSpy.count(), aCount);

   298     QCOMPARE(bSpy.count(), bCount);

   299     QCOMPARE(cSpy.count(), cCount);

   300 }

   301 

   302 void tst_QMediaObject::setupNotifyTests()

   303 {

   304     QTest::addColumn<int>("interval");

   305     QTest::addColumn<int>("count");

   306 

   307     QTest::newRow("single 750ms")

   308             << 750

   309             << 1;

   310     QTest::newRow("single 600ms")

   311             << 600

   312             << 1;

   313     QTest::newRow("x3 300ms")

   314             << 300

   315             << 3;

   316     QTest::newRow("x5 180ms")

   317             << 180

   318             << 5;

   319 }

   320 

   321 void tst_QMediaObject::notifySignals_data()

   322 {

   323     setupNotifyTests();

   324 }

   325 

   326 void tst_QMediaObject::notifySignals()

   327 {

   328     QFETCH(int, interval);

   329     QFETCH(int, count);

   330 

   331     QtTestMediaObject object;

   332     object.setNotifyInterval(interval);

   333     object.addPropertyWatch("a");

   334 

   335     QSignalSpy spy(&object, SIGNAL(aChanged(int)));

   336 

   337     QTestEventLoop::instance().enterLoop(1);

   338 

   339     QCOMPARE(spy.count(), count);

   340 }

   341 

   342 void tst_QMediaObject::notifyInterval_data()

   343 {

   344     setupNotifyTests();

   345 }

   346 

   347 void tst_QMediaObject::notifyInterval()

   348 {

   349     QFETCH(int, interval);

   350 

   351     QtTestMediaObject object;

   352     QSignalSpy spy(&object, SIGNAL(notifyIntervalChanged(int)));

   353 

   354     object.setNotifyInterval(interval);

   355     QCOMPARE(object.notifyInterval(), interval);

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

   357     QCOMPARE(spy.last().value(0).toInt(), interval);

   358 

   359     object.setNotifyInterval(interval);

   360     QCOMPARE(object.notifyInterval(), interval);

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

   362 }

   363 

   364 void tst_QMediaObject::nullMetaDataControl()

   365 {

   366     const QString titleKey(QLatin1String("Title"));

   367     const QString title(QLatin1String("Host of Seraphim"));

   368 

   369     QtTestMetaDataService service;

   370     service.hasMetaData = false;

   371 

   372     QtTestMediaObject object(&service);

   373 

   374     QSignalSpy spy(&object, SIGNAL(metaDataChanged()));

   375 

   376     QCOMPARE(object.isMetaDataAvailable(), false);

   377     QCOMPARE(object.isMetaDataWritable(), false);

   378 

   379     object.setMetaData(QtMedia::Title, title);

   380     object.setExtendedMetaData(titleKey, title);

   381 

   382     QCOMPARE(object.metaData(QtMedia::Title).toString(), QString());

   383     QCOMPARE(object.extendedMetaData(titleKey).toString(), QString());

   384     QCOMPARE(object.availableMetaData(), QList<QtMedia::MetaData>());

   385     QCOMPARE(object.availableExtendedMetaData(), QStringList());

   386     QCOMPARE(spy.count(), 0);

   387 }

   388 

   389 void tst_QMediaObject::isMetaDataAvailable()

   390 {

   391     QtTestMetaDataService service;

   392     service.metaData.setMetaDataAvailable(false);

   393 

   394     QtTestMediaObject object(&service);

   395     QCOMPARE(object.isMetaDataAvailable(), false);

   396 

   397     QSignalSpy spy(&object, SIGNAL(metaDataAvailableChanged(bool)));

   398     service.metaData.setMetaDataAvailable(true);

   399 

   400     QCOMPARE(object.isMetaDataAvailable(), true);

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

   402     QCOMPARE(spy.at(0).at(0).toBool(), true);

   403 

   404     service.metaData.setMetaDataAvailable(false);

   405 

   406     QCOMPARE(object.isMetaDataAvailable(), false);

   407     QCOMPARE(spy.count(), 2);

   408     QCOMPARE(spy.at(1).at(0).toBool(), false);

   409 }

   410 

   411 void tst_QMediaObject::isWritable()

   412 {

   413     QtTestMetaDataService service;

   414     service.metaData.setWritable(false);

   415 

   416     QtTestMediaObject object(&service);

   417 

   418     QSignalSpy spy(&object, SIGNAL(metaDataWritableChanged(bool)));

   419 

   420     QCOMPARE(object.isMetaDataWritable(), false);

   421 

   422     service.metaData.setWritable(true);

   423 

   424     QCOMPARE(object.isMetaDataWritable(), true);

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

   426     QCOMPARE(spy.at(0).at(0).toBool(), true);

   427 

   428     service.metaData.setWritable(false);

   429 

   430     QCOMPARE(object.isMetaDataWritable(), false);

   431     QCOMPARE(spy.count(), 2);

   432     QCOMPARE(spy.at(1).at(0).toBool(), false);

   433 }

   434 

   435 void tst_QMediaObject::metaDataChanged()

   436 {

   437     QtTestMetaDataService service;

   438     QtTestMediaObject object(&service);

   439 

   440     QSignalSpy spy(&object, SIGNAL(metaDataChanged()));

   441 

   442     service.metaData.metaDataChanged();

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

   444 

   445     service.metaData.metaDataChanged();

   446     QCOMPARE(spy.count(), 2);

   447 }

   448 

   449 void tst_QMediaObject::metaData_data()

   450 {

   451     QTest::addColumn<QString>("artist");

   452     QTest::addColumn<QString>("title");

   453     QTest::addColumn<QString>("genre");

   454 

   455     QTest::newRow("")

   456             << QString::fromLatin1("Dead Can Dance")

   457             << QString::fromLatin1("Host of Seraphim")

   458             << QString::fromLatin1("Awesome");

   459 }

   460 

   461 void tst_QMediaObject::metaData()

   462 {

   463     QFETCH(QString, artist);

   464     QFETCH(QString, title);

   465     QFETCH(QString, genre);

   466 

   467     QtTestMetaDataService service;

   468     service.metaData.populateMetaData();

   469 

   470     QtTestMediaObject object(&service);

   471     QVERIFY(object.availableMetaData().isEmpty());

   472 

   473     service.metaData.m_data.insert(QtMedia::AlbumArtist, artist);

   474     service.metaData.m_data.insert(QtMedia::Title, title);

   475     service.metaData.m_data.insert(QtMedia::Genre, genre);

   476 

   477     QCOMPARE(object.metaData(QtMedia::AlbumArtist).toString(), artist);

   478     QCOMPARE(object.metaData(QtMedia::Title).toString(), title);

   479 

   480     QList<QtMedia::MetaData> metaDataKeys = object.availableMetaData();

   481     QCOMPARE(metaDataKeys.size(), 3);

   482     QVERIFY(metaDataKeys.contains(QtMedia::AlbumArtist));

   483     QVERIFY(metaDataKeys.contains(QtMedia::Title));

   484     QVERIFY(metaDataKeys.contains(QtMedia::Genre));

   485 }

   486 

   487 void tst_QMediaObject::setMetaData_data()

   488 {

   489     QTest::addColumn<QString>("title");

   490 

   491     QTest::newRow("")

   492             << QString::fromLatin1("In the Kingdom of the Blind the One eyed are Kings");

   493 }

   494 

   495 void tst_QMediaObject::setMetaData()

   496 {

   497     QFETCH(QString, title);

   498 

   499     QtTestMetaDataService service;

   500     service.metaData.populateMetaData();

   501 

   502     QtTestMediaObject object(&service);

   503 

   504     object.setMetaData(QtMedia::Title, title);

   505     QCOMPARE(object.metaData(QtMedia::Title).toString(), title);

   506     QCOMPARE(service.metaData.m_data.value(QtMedia::Title).toString(), title);

   507 }

   508 

   509 void tst_QMediaObject::extendedMetaData()

   510 {

   511     QFETCH(QString, artist);

   512     QFETCH(QString, title);

   513     QFETCH(QString, genre);

   514 

   515     QtTestMetaDataService service;

   516     QtTestMediaObject object(&service);

   517     QVERIFY(object.availableExtendedMetaData().isEmpty());

   518 

   519     service.metaData.m_extendedData.insert(QLatin1String("Artist"), artist);

   520     service.metaData.m_extendedData.insert(QLatin1String("Title"), title);

   521     service.metaData.m_extendedData.insert(QLatin1String("Genre"), genre);

   522 

   523     QCOMPARE(object.extendedMetaData(QLatin1String("Artist")).toString(), artist);

   524     QCOMPARE(object.extendedMetaData(QLatin1String("Title")).toString(), title);

   525 

   526     QStringList extendedKeys = object.availableExtendedMetaData();

   527     QCOMPARE(extendedKeys.size(), 3);

   528     QVERIFY(extendedKeys.contains(QLatin1String("Artist")));

   529     QVERIFY(extendedKeys.contains(QLatin1String("Title")));

   530     QVERIFY(extendedKeys.contains(QLatin1String("Genre")));

   531 }

   532 

   533 void tst_QMediaObject::setExtendedMetaData()

   534 {

   535     QtTestMetaDataService service;

   536     service.metaData.populateMetaData();

   537 

   538     QtTestMediaObject object(&service);

   539 

   540     QString title(QLatin1String("In the Kingdom of the Blind the One eyed are Kings"));

   541 

   542     object.setExtendedMetaData(QLatin1String("Title"), title);

   543     QCOMPARE(object.extendedMetaData(QLatin1String("Title")).toString(), title);

   544     QCOMPARE(service.metaData.m_extendedData.value(QLatin1String("Title")).toString(), title);

   545 }

   546 

   547 QTEST_MAIN(tst_QMediaObject)

   548 

   549 #include "tst_qmediaobject.moc"