X-Git-Url: http://vcs.maemo.org/git/?a=blobdiff_plain;f=qmafw-gst-subtitles-renderer%2Funittests%2Fut_MafwGstRenderer%2FUt_MafwGstRenderer.cpp;fp=qmafw-gst-subtitles-renderer%2Funittests%2Fut_MafwGstRenderer%2FUt_MafwGstRenderer.cpp;h=dbbded06a16ade88349cae0d03ec9c6175d4e4d2;hb=226d35244df85a27c332d3a3ded1b25b3c7f4951;hp=0000000000000000000000000000000000000000;hpb=57ba96e291a055f69dbfd4ae9f1ae2390e36986e;p=mafwsubrenderer diff --git a/qmafw-gst-subtitles-renderer/unittests/ut_MafwGstRenderer/Ut_MafwGstRenderer.cpp b/qmafw-gst-subtitles-renderer/unittests/ut_MafwGstRenderer/Ut_MafwGstRenderer.cpp new file mode 100644 index 0000000..dbbded0 --- /dev/null +++ b/qmafw-gst-subtitles-renderer/unittests/ut_MafwGstRenderer/Ut_MafwGstRenderer.cpp @@ -0,0 +1,1662 @@ +/* + * This file is part of QMAFW + * + * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). All rights + * reserved. + * + * Contact: Visa Smolander + * + * This software, including documentation, is protected by copyright controlled + * by Nokia Corporation. All rights are reserved. Copying, including + * reproducing, storing, adapting or translating, any or all of this material + * requires the prior written consent of Nokia Corporation. This material also + * contains confidential information which may not be disclosed to others + * without the prior written consent of Nokia. + * + */ + +#include "Ut_MafwGstRenderer.h" + +#include +#include +#include +#include +#include +#include "MafwGstRendererVolume.h" +#include "MafwMetadata.h" +#include "MafwGstRendererPlaylistFileUtility.h" +#include "MafwStubHelper.h" +#include "MafwRendererPolicyStub.h" +#include "mafw-gst-renderer-worker.h" +#include "MafwMediaInfo.h" + +#include "QNetworkStubs.h" +#include + +#define private public // access private members from unit tests +#include "MafwGstRenderer.h" +#include "MafwMmcMonitor.h" + +extern void setStubHelper(MafwStubHelper* stubHlp); +extern void setMafwRendererPolicy(MafwRendererPolicy *policy ); + +extern GError* global_error; +extern gint global_position; +extern int global_qmsystemstub_setBlankingPauseCalled; +extern ContextProperty *global_video_route_property; +extern ContextProperty *global_audio_route_property; +extern QString global_audio_route; +extern QString global_video_route; +extern gboolean global_worker_playing; +extern const gchar* global_worker_uri; +extern int global_worker_stop_called; +extern int global_worker_seek_request; +extern guint global_ready_timeout; +extern GSList *global_worker_destinations; +extern NetworkStubHelper networkStub; +extern configuration *current_worker_conf; +extern QMap globalSettingsMap; + +extern bool stubMmcMounted; +extern MafwMmcMonitor* stubMmcMonitor; +extern QStringList stubPlaylistFileUtilityUris; + +void Ut_MafwGstRenderer::initTestCase() +{ + qRegisterMetaType(); + qRegisterMetaType(); + qRegisterMetaType(); + g_type_init(); + + m_stubHelper = new MafwStubHelper; + setStubHelper(m_stubHelper); + m_rendererPolicy = new MafwRendererPolicyStub(); + setMafwRendererPolicy(m_rendererPolicy); + + m_metadataCount = 0; + + /* Section to test initialization */ + MafwGstRenderer *renderer = new MafwGstRenderer("renderer_uuid", "renderer-plugin", "rendere_name"); + //Basic renderer initialize fails + m_stubHelper->expect("initialize", false); + QVERIFY(renderer->initialize(0) == false); + // Let setDefaultRendererPolicy fail now to get more complete unittesting. + // Failure in loading policy is not considered fatal at this point. + m_stubHelper->expect("initialize", true); + m_stubHelper->expect("setDefaultRendererPolicy", false); + QVERIFY(renderer->initialize(0) == true); + delete renderer; + /* Section End */ + + m_renderer = new MafwGstRenderer("renderer_uuid", "renderer-plugin", "rendere_name"); + + m_stubHelper->expect("initialize", true); + m_stubHelper->expect("setDefaultRendererPolicy", true); + QVERIFY(m_renderer->initialize(0) == true); + QVERIFY(m_renderer->m_worker); + + //redundant initialize call + QVERIFY(m_renderer->initialize(0) == true); + + global_qmsystemstub_setBlankingPauseCalled = 0; +} + +void Ut_MafwGstRenderer::testPlayURI() +{ + //rendererPlaying signal not emitted there + MafwMediaInfo content(""); + QMap > map; + map[MAFW_METADATA_KEY_URI] = QList() << "http://test.play.uri"; + content.setMetaData(map); + + m_renderer->doPlay(content); +} + +/** + * PlaylistFileUtilityStub gives always two uris to play + */ +void Ut_MafwGstRenderer::testPlayPlaylistFile() +{ + QSignalSpy playSpy(m_renderer, SIGNAL(rendererPlaying(int))); + + MafwMediaInfo mediaInfo; + QMap testUri; + QMap testMimeType; + testUri.insert(MAFW_METADATA_KEY_URI, "file:///var/tmp/tunein-station.pls"); + testMimeType.insert(MAFW_METADATA_KEY_MIME, "audio/x-scpls"); + + mediaInfo.setMetaData(testUri); + mediaInfo.setMetaData(testMimeType); + + m_renderer->doPlay(mediaInfo); + QTest::qWait(10); + QCOMPARE(playSpy.count(), 1); + QList arguments = playSpy.takeFirst(); + QCOMPARE(arguments.count(), 1); + QCOMPARE(arguments.at(0).toInt(), 1); //MafwRendererPlayingUri::CurrentUri + +//Test that next uri is started to play if playing first stops because of an error + GError* error = g_error_new_literal(1, 2, "Playlist uri playback error"); + m_renderer->m_worker->notify_error_handler(m_renderer->m_worker, m_renderer, error); + QTest::qWait(10); + QCOMPARE(playSpy.count(), 0); + QVERIFY(global_worker_playing); + QCOMPARE(QString(global_worker_uri), QString("testUri2")); + +//Test that renderer does not go playing state anymore when all uris is used + m_renderer->m_worker->notify_error_handler(m_renderer->m_worker, m_renderer, error); + QTest::qWait(10); + QCOMPARE(playSpy.count(), 0); + + g_error_free(error); +} + +void Ut_MafwGstRenderer::testStop() +{ + //@TODO doStop needs to be tested for all the states the renderer can be in. + QSignalSpy spy(m_renderer, SIGNAL(rendererStopped())); + m_renderer->doStop(); + QCOMPARE(spy.count(), 1); + //Not clear that should signal be emitted when calling doStop at stopped state + m_renderer->doStop(); + m_renderer->doStop(); +} + +void Ut_MafwGstRenderer::testPause() +{ + m_renderer->doPause(); +} + +void Ut_MafwGstRenderer::testResume() +{ + m_renderer->doResume(); +} + +void Ut_MafwGstRenderer::testSeek() +{ + QSignalSpy errorSpy(m_renderer, SIGNAL(rendererError(MafwError))); + global_error = g_error_new_literal(1, 2, "The seek error"); + m_renderer->doSeek(1, MafwRenderer::SeekAbsolute); + QCOMPARE(errorSpy.count(), 1); + + global_error = 0; + m_renderer->doSeek(100, MafwRenderer::SeekRelative); +} + +void Ut_MafwGstRenderer::testDefaultConfiguration() +{ + QVERIFY2(sizeof(configuration) == 64, "You've (or somebody else) most likely changed the configuration struct! Update the unittests also!"); + + MafwGstRenderer *rnd = new MafwGstRenderer("tesssssst", "conf-test-plug", "conf-test-rnd"); + QSettings settings("test-set", QSettings::NativeFormat); + + m_stubHelper->expect("initialize", true); + + rnd->initialize(&settings); + + QCOMPARE(current_worker_conf->asink, "pulsesink"); + QCOMPARE(current_worker_conf->vsink, "omapxvsink"); + QCOMPARE(current_worker_conf->buffer_time, 300000LL); + QCOMPARE(current_worker_conf->latency_time, 100000LL); + QCOMPARE(current_worker_conf->flags, 67); + + QCOMPARE(current_worker_conf->mobile_surround_music.state, 0U); + QCOMPARE(current_worker_conf->mobile_surround_music.color, 2); + QCOMPARE(current_worker_conf->mobile_surround_music.room, 2); + QCOMPARE(current_worker_conf->mobile_surround_video.state, 0U); + QCOMPARE(current_worker_conf->mobile_surround_video.color, 2); + QCOMPARE(current_worker_conf->mobile_surround_video.room, 2); + + QCOMPARE(current_worker_conf->milliseconds_to_pause_frame, 1000U); + QCOMPARE(current_worker_conf->seconds_to_pause_to_ready, 3U); + QCOMPARE(current_worker_conf->use_dhmmixer, 1); + + delete rnd; + +} + +void Ut_MafwGstRenderer::testConfiguration() +{ + globalSettingsMap.clear(); + globalSettingsMap.insert("audio-sink", "no-audio"); + globalSettingsMap.insert("video-sink", "no-video"); + globalSettingsMap.insert("flags", 67); + globalSettingsMap.insert("use_dhmmixer", false); + globalSettingsMap.insert("buffer-time", 313); + globalSettingsMap.insert("latency-time", 007); + + globalSettingsMap.insert("pause-frame", 13000); + globalSettingsMap.insert("pause-to-ready", 7); + + globalSettingsMap.insert("dhm-music-surround", 6); + globalSettingsMap.insert("dhm-music-color", 5); + globalSettingsMap.insert("dhm-music-room-size", 4); + globalSettingsMap.insert("dhm-video-surround", 3); + globalSettingsMap.insert("dhm-video-color", 12); + globalSettingsMap.insert("dhm-video-room-size", 1); + + MafwGstRenderer *rnd = new MafwGstRenderer("tesst", "conf-test-plug", "conf-test-rnd"); + QSettings settings("test-set", QSettings::NativeFormat); + m_stubHelper->expect("initialize", true); + rnd->initialize(&settings); + + QCOMPARE(current_worker_conf->asink, "no-audio"); + QCOMPARE(current_worker_conf->vsink, "no-video"); + QCOMPARE(current_worker_conf->buffer_time, 313LL); + QCOMPARE(current_worker_conf->latency_time, 007LL); + QCOMPARE(current_worker_conf->flags, 67); + + QCOMPARE(current_worker_conf->mobile_surround_music.state, 6U); + QCOMPARE(current_worker_conf->mobile_surround_music.color, 5); + QCOMPARE(current_worker_conf->mobile_surround_music.room, 4); + + // for some reason video values are overwritten via gconf in unittests + QCOMPARE(current_worker_conf->mobile_surround_video.state, 3U); + QCOMPARE(current_worker_conf->mobile_surround_video.color, 12); + QCOMPARE(current_worker_conf->mobile_surround_video.room, 1); + + QCOMPARE(current_worker_conf->milliseconds_to_pause_frame, 13000U); + QCOMPARE(current_worker_conf->seconds_to_pause_to_ready, 7U); + QCOMPARE(current_worker_conf->use_dhmmixer, 0); + + globalSettingsMap.clear(); + + delete rnd; +} + +void Ut_MafwGstRenderer::testNextHint() +{ + MafwMediaInfo content(""); + QMap >map; + map[MAFW_METADATA_KEY_URI] = QList() << "http://test.play.next_uri"; + content.setMetaData(map); + + m_renderer->doNextHint(content); +} + +void Ut_MafwGstRenderer::testPosition() +{ + QVERIFY(connect(m_renderer, SIGNAL(rendererError(MafwError)), this, SLOT(positionError(MafwError)))); + //set renderer to playing state first + MafwMediaInfo content(""); + QMap >map; + map[MAFW_METADATA_KEY_URI] = QList() << "http://test.play.uri"; + content.setMetaData(map); + + m_renderer->doPlay(content); + + // Normal case + m_position = 0; + global_position = 157; + m_renderer->getPosition(this, SLOT(positionChanged(uint))); + QTest::qWait(10); + QVERIFY2(m_position == 157, "Wrong position"); + + //repeated call with same value + m_position = 0; + m_renderer->getPosition(this, SLOT(positionChanged(uint))); + QTest::qWait(10); + QVERIFY2(m_position == 157, "Wrong position"); + + // Normal case, maxint position + m_position = 0; + int maxint = 2147483647; + global_position = maxint; + m_renderer->getPosition(this, SLOT(positionChanged(uint))); + QTest::qWait(10); + QVERIFY2(m_position == (uint)maxint, "Wrong position"); + + // Normal case, position to 0 + global_position = 0; + m_renderer->getPosition(this, SLOT(positionChanged(uint))); + QTest::qWait(10); + QVERIFY2(m_position == 0, "Wrong position"); + + // Errorenuous position case + m_position = 0; + global_position = -1; + m_renderer->getPosition(this, SLOT(positionChanged(uint))); + QTest::qWait(10); + QVERIFY2(m_position == 0, "Wrong position"); + QVERIFY2(m_error.code() == MafwError::RendererError_CannotGetPosition, "Wrong error code"); + + //Errorenuous position case, -maxint + m_position = 0; + global_position = -maxint; + m_renderer->getPosition(this, SLOT(positionChanged(uint))); + QTest::qWait(10); + QVERIFY2(m_position == 0, "Wrong position"); + + //NULL result slot + global_position = 1; + m_renderer->getPosition(0, SLOT(positionChanged(uint))); + QTest::qWait(10); + + //Not existing error slot + global_position = -1; + m_renderer->getPosition(this, SLOT(positionChanged(uint))); + QTest::qWait(10); + + // Stopped case when 0 should be returned + m_renderer->doStop(); + m_position = 0; + global_position = -1; + m_renderer->getPosition(this, SLOT(positionChanged(uint))); + QTest::qWait(10); + QVERIFY2(m_position == 0, "Wrong position"); +} + +void Ut_MafwGstRenderer::testProperty() +{ + QFETCH(QString, name); + QFETCH(QVariant, value); + bool success = m_renderer->setMafwProperty(name, value); + QVERIFY2(success, "Unable to set property"); + + m_renderer->mafwProperty(name, this, SLOT(propertyChanged(const QString&, const QVariant&))); + QTest::qWait(10); + + //@TODO getter for current-frame-on-pause needs to be implemented + if (name == "colorkey") + { + QCOMPARE(m_value, QVariant(1)); //value comes from worker stub + + //Test unexisting slot case + m_renderer->mafwProperty(name, this, SLOT(propertyChanged2(const QString&, const QVariant&))); + QTest::qWait(10); + } + else if (name != "unknown" + && name!= "current-frame-on-pause" + && name != MafwRenderer::MAFW_RENDERER_PROPERTY_POLICY_OVERRIDE ) + { + QCOMPARE(m_name, name); + QCOMPARE(m_value, value); + } +} + +void Ut_MafwGstRenderer::testProperty_data() +{ + QTest::addColumn("name"); + QTest::addColumn("value"); + + QTest::newRow("volume") << "volume" << QVariant(1); + QTest::newRow("force-aspect-ratio") << "force-aspect-ratio" << QVariant(false); + QTest::newRow("autopaint") << "autopaint" << QVariant(true); + QTest::newRow("xid") << "xid" << QVariant(12345); + QTest::newRow("current-frame-on-pause") << "current-frame-on-pause" << QVariant(true); + QTest::newRow("colorkey") << "colorkey" << QVariant(23456); + QTest::newRow("render-rectangle") << "render-rectangle" << QVariant(QString("%1,%2,%3,%4").arg(1).arg(2).arg(3).arg(4)); + QTest::newRow("unknown property") << "unknown" << QVariant(true); +} + +void Ut_MafwGstRenderer::testPlaybackSpeedProperty() +{ + QString propertyName = "playback-speed"; + + QSignalSpy propertyChangedSpy(m_renderer, SIGNAL(mafwPropertyChanged(const QString&, const QVariant&))); + + // + //Stopped - won't accept the property + // + m_renderer->setMafwProperty(propertyName, 0); + m_renderer->setMafwProperty(propertyName, 1); + m_renderer->setMafwProperty(propertyName, -1); + QCOMPARE(propertyChangedSpy.size(), 0); + + // + //Playing + // + //then test in playing state + MafwMediaInfo content(""); + QMap >map; + map[MAFW_METADATA_KEY_URI] = QList() << "http://test.play.uri"; + content.setMetaData(map); + + m_renderer->doPlay(content); + + //no change in playback, just expect the signal + m_renderer->setMafwProperty(propertyName, 1); + QTest::qWait(20); + QCOMPARE(propertyChangedSpy.size(), 1); + QList arguments = propertyChangedSpy.takeFirst(); + QCOMPARE(arguments.count(), 2); + QCOMPARE(arguments.at(0).toString(), propertyName); + //There is a QVariant inside QVariant + QCOMPARE(arguments.at(1).value().toFloat(), float(1)); + + m_renderer->setMafwProperty(propertyName, 2); + QTest::qWait(20); + QCOMPARE(propertyChangedSpy.size(), 1); + arguments = propertyChangedSpy.takeFirst(); + QCOMPARE(arguments.count(), 2); + QCOMPARE(arguments.at(0).toString(), propertyName); + //There is a QVariant inside QVariant + QCOMPARE(arguments.at(1).value().toFloat(), float(2)); + + m_renderer->setMafwProperty(propertyName, 2); + QTest::qWait(20); + QCOMPARE(propertyChangedSpy.size(), 1); + arguments = propertyChangedSpy.takeFirst(); + QCOMPARE(arguments.count(), 2); + QCOMPARE(arguments.at(0).toString(), propertyName); + //There is a QVariant inside QVariant + QCOMPARE(arguments.at(1).value().toFloat(), float(2)); + + m_renderer->setMafwProperty(propertyName, -1); + QTest::qWait(20); + QCOMPARE(propertyChangedSpy.size(), 1); + arguments = propertyChangedSpy.takeFirst(); + QCOMPARE(arguments.count(), 2); + QCOMPARE(arguments.at(0).toString(), propertyName); + //There is a QVariant inside QVariant + QCOMPARE(arguments.at(1).value().toFloat(), float(-1)); + + m_renderer->setMafwProperty(propertyName, 0.3); + QTest::qWait(20); + QCOMPARE(propertyChangedSpy.size(), 1); + arguments = propertyChangedSpy.takeFirst(); + QCOMPARE(arguments.count(), 2); + QCOMPARE(arguments.at(0).toString(), propertyName); + //There is a QVariant inside QVariant + QCOMPARE(arguments.at(1).value().toFloat(), float(0.3)); + + m_renderer->setMafwProperty(propertyName, 1.3); + QTest::qWait(20); + QCOMPARE(propertyChangedSpy.size(), 1); + arguments = propertyChangedSpy.takeFirst(); + QCOMPARE(arguments.count(), 2); + QCOMPARE(arguments.at(0).toString(), propertyName); + //There is a QVariant inside QVariant + QCOMPARE(arguments.at(1).value().toFloat(), float(1.3)); + + m_renderer->setMafwProperty(propertyName, -0.3); + QTest::qWait(20); + QCOMPARE(propertyChangedSpy.size(), 1); + arguments = propertyChangedSpy.takeFirst(); + QCOMPARE(arguments.count(), 2); + QCOMPARE(arguments.at(0).toString(), propertyName); + //There is a QVariant inside QVariant + QCOMPARE(arguments.at(1).value().toFloat(), float(-0.3)); + + m_renderer->setMafwProperty(propertyName, -1.3); + QTest::qWait(20); + QCOMPARE(propertyChangedSpy.size(), 1); + arguments = propertyChangedSpy.takeFirst(); + QCOMPARE(arguments.count(), 2); + QCOMPARE(arguments.at(0).toString(), propertyName); + //There is a QVariant inside QVariant + QCOMPARE(arguments.at(1).value().toFloat(), float(-1.3)); + //check that mafwProperty() returns the correct value + m_value = QVariant(0); + QVERIFY(m_renderer->mafwProperty(propertyName, this, SLOT(propertyChanged(const QString&, const QVariant&)))); + QTest::qWait(20); + QCOMPARE(m_value.toFloat(), float(-1.3)); + + //TODO what does 0 mean? + m_renderer->setMafwProperty(propertyName, 0); + QCOMPARE(propertyChangedSpy.size(), 1); + arguments = propertyChangedSpy.takeFirst(); + QCOMPARE(arguments.count(), 2); + QCOMPARE(arguments.at(0).toString(), propertyName); + //There is a QVariant inside QVariant + QCOMPARE(arguments.at(1).value().toFloat(), float(0)); + + // + //Paused - won't accept the property + // + m_renderer->doPause(); + m_renderer->setMafwProperty(propertyName, 3); + //check that mafwProperty() returns the correct value + m_value = QVariant(-1); //not same as the last value set in playing state + QVERIFY(m_renderer->mafwProperty(propertyName, this, SLOT(propertyChanged(const QString&, const QVariant&)))); + QTest::qWait(20); + QCOMPARE(m_value, QVariant(0)); //the value that was last set in playing state + + //TODO test property value after resume + + // + //Stopped - won't accept the property + // + m_renderer->doStop(); + + m_renderer->setMafwProperty(propertyName, 3); + //check that mafwProperty() returns the correct value + m_value = QVariant(-1); //not same as the last value set in playing state + QVERIFY(m_renderer->mafwProperty(propertyName, this, SLOT(propertyChanged(const QString&, const QVariant&)))); + QTest::qWait(20); + QCOMPARE(m_value, QVariant(0)); //the value that was last set in playing state + +} + +void Ut_MafwGstRenderer::cleanupTestCase() +{ + delete m_renderer; + g_slist_free(global_worker_destinations); + + QCoreApplication::sendPostedEvents(0, QEvent::DeferredDelete); + while(QCoreApplication::hasPendingEvents()) + { + QCoreApplication::sendPostedEvents(); + QCoreApplication::sendPostedEvents(0, QEvent::DeferredDelete); + QCoreApplication::processEvents(); + } +} + +/** + * Pointers to callback functions after are set to renderer worker at + * MafwGstRenderer::initialize + */ +void Ut_MafwGstRenderer::testCallbacks() +{ + GValue intValue; + GValue uintValue; + GValue boolValue; + GValue stringValue; + GValue uninitValue; + GValue objectValue; + GValue doubleValue; + GValue int64Value; + + memset(&intValue, 0, sizeof(GValue)); + memset(&uintValue, 0, sizeof(GValue)); + memset(&boolValue, 0, sizeof(GValue)); + memset(&stringValue, 0, sizeof(GValue)); + memset(&uninitValue, 0, sizeof(GValue)); + memset(&objectValue, 0, sizeof(GValue)); + memset(&doubleValue, 0, sizeof(GValue)); + memset(&int64Value, 0, sizeof(GValue)); + + g_value_init(&intValue, G_TYPE_INT); + g_value_init(&uintValue, G_TYPE_UINT); + g_value_init(&boolValue, G_TYPE_BOOLEAN); + g_value_init(&stringValue, G_TYPE_STRING); + g_value_init(&objectValue, G_TYPE_OBJECT); + g_value_init(&doubleValue, G_TYPE_DOUBLE); + g_value_init(&int64Value, G_TYPE_INT64); + + g_value_set_int(&intValue, -123); + g_value_set_uint(&uintValue, (uint)-1); + g_value_set_boolean(&boolValue, TRUE); + g_value_set_string(&stringValue, "The test property"); + g_value_set_double(&doubleValue, 1.01); + g_value_set_int64(&int64Value, 1234567890); + +//playCallback + QSignalSpy playSpy(m_renderer, SIGNAL(rendererPlaying(int))); + m_renderer->m_worker->notify_play_handler(m_renderer->m_worker, m_renderer); + QCOMPARE(playSpy.count(), 1); + +//pauseCallback + QSignalSpy pauseSpy(m_renderer, SIGNAL(rendererPaused())); + m_renderer->m_worker->notify_pause_handler(m_renderer->m_worker, m_renderer); + QCOMPARE(pauseSpy.count(), 1); + +//errorCallback + QSignalSpy errorSpy(m_renderer, SIGNAL(rendererError(MafwError))); + GError* error = g_error_new_literal(1, 2, "The unit test error"); + GError* error2 = g_error_new_literal(1, -1, "Another unit test error"); + m_renderer->m_worker->notify_error_handler(m_renderer->m_worker, m_renderer, error); + m_renderer->m_worker->notify_error_handler(m_renderer->m_worker, m_renderer, error2); + QCOMPARE(errorSpy.count(), 2); + g_error_free(error); + g_error_free(error2); + +//eosCallback + QSignalSpy eosSpy(m_renderer, SIGNAL(rendererEos())); + m_renderer->m_worker->notify_eos_handler(m_renderer->m_worker, m_renderer); + QTest::qWait(10); //renderer paused will be emitted asynchronously + QCOMPARE(eosSpy.count(), 1); + +//metadataCallback + QSignalSpy metadataSpy(m_renderer, SIGNAL(metadataChanged(const QString&, const QList&))); + GValueArray *array = g_value_array_new(0); + g_value_array_append(array, &stringValue); + g_value_array_append(array, &doubleValue); + g_value_array_append(array, &int64Value); + + //unknown metadata key + m_renderer->m_worker->notify_metadata_handler(m_renderer->m_worker, m_renderer, -1, G_TYPE_VALUE_ARRAY, array); + //invalid type + m_renderer->m_worker->notify_metadata_handler(m_renderer->m_worker, m_renderer, 1, G_TYPE_VALUE, &stringValue); + //valid case + m_renderer->m_worker->notify_metadata_handler(m_renderer->m_worker, m_renderer, 1, G_TYPE_VALUE_ARRAY, array); + + QCOMPARE(metadataSpy.count(), 1); + g_value_array_free(array); + +//propertyCallback + int count = 0; + QSignalSpy propertySpy(m_renderer, SIGNAL(mafwPropertyChanged(const QString&, const QVariant&))); + + //auto paint + m_renderer->m_worker->notify_property_handler(m_renderer->m_worker, m_renderer, WORKER_PROPERTY_AUTOPAINT, &boolValue); + QCOMPARE(propertySpy.count(), ++count); + + //color key + m_renderer->m_worker->notify_property_handler(m_renderer->m_worker, m_renderer, WORKER_PROPERTY_COLORKEY, &intValue); + QCOMPARE(propertySpy.count(), ++count); + + //xid + m_renderer->m_worker->notify_property_handler(m_renderer->m_worker, m_renderer, WORKER_PROPERTY_XID, &uintValue); + QCOMPARE(propertySpy.count(), ++count); + + //pause frame + m_renderer->m_worker->notify_property_handler(m_renderer->m_worker, m_renderer, WORKER_PROPERTY_CURRENT_FRAME_ON_PAUSE, &boolValue); + QCOMPARE(propertySpy.count(), ++count); + + //force aspect ratio + m_renderer->m_worker->notify_property_handler(m_renderer->m_worker, m_renderer, WORKER_PROPERTY_FORCE_ASPECT_RATIO, &boolValue); + QCOMPARE(propertySpy.count(), ++count); + + //playback speed + m_renderer->m_worker->notify_property_handler(m_renderer->m_worker, m_renderer, WORKER_PROPERTY_PLAYBACK_SPEED, &doubleValue); + QCOMPARE(propertySpy.count(), ++count); + + //unknown property id + m_renderer->m_worker->notify_property_handler(m_renderer->m_worker, m_renderer, 6, &uintValue); + QCOMPARE(propertySpy.count(), ++count); + + //!G_IS_VALUE + m_renderer->m_worker->notify_property_handler(m_renderer->m_worker, m_renderer, WORKER_PROPERTY_CURRENT_FRAME_ON_PAUSE, &uninitValue); + QCOMPARE(propertySpy.count(), count); + + //unsupported value g_type + m_renderer->m_worker->notify_property_handler(m_renderer->m_worker, m_renderer, WORKER_PROPERTY_MUTE, &objectValue); + QCOMPARE(propertySpy.count(), count); + + //boolean property with string value, currently there is no check -> emits mafwPropertyChanged( "mute", "The test property" ) + m_renderer->m_worker->notify_property_handler(m_renderer->m_worker, m_renderer, WORKER_PROPERTY_MUTE, &intValue); + + +//bufferStatusCallback + QSignalSpy bufferSpy(m_renderer, SIGNAL(bufferingInfo(float))); + m_renderer->m_worker->notify_buffer_status_handler(m_renderer->m_worker, m_renderer, (gdouble)1.001); + m_renderer->m_worker->notify_buffer_status_handler(m_renderer->m_worker, m_renderer, (gdouble)-1.001); + m_renderer->m_worker->notify_buffer_status_handler(m_renderer->m_worker, m_renderer, (gdouble)1001); + QCOMPARE(bufferSpy.count(), 3); + + g_value_unset(&intValue); + g_value_unset(&uintValue); + g_value_unset(&boolValue); + g_value_unset(&stringValue); + g_value_unset(&int64Value); + g_value_unset(&doubleValue); +} + +void Ut_MafwGstRenderer::testGetCurrentMediaInfo() +{ + QFETCH(QString, name); + QFETCH(QList, values); + + qDebug() << "values.size():" << values.size(); + + MafwMediaInfo content(""); + MafwMediaInfo mediaInfo; + QMap > map; + QMap >old_map; + + bool success = false; + m_name = name; + + GValueArray *array = g_value_array_new(0); + + if(name == "all") + { + QList valueList; + valueList.append("http://test.play.uri"); + map[MAFW_METADATA_KEY_URI] = valueList; + old_map[MAFW_METADATA_KEY_URI] = valueList; + mediaInfo.setMetaData(map); + content.setMetaData(old_map); + + GValue geevalue; + memset(&geevalue, 0, sizeof(GValue)); + g_value_init(&geevalue, G_TYPE_STRING); + g_value_set_string(&geevalue, "http://test.play.uri"); + g_value_array_append(array, &geevalue); + g_value_unset(&geevalue); + + m_renderer->doPlay(content); + m_renderer->m_worker->notify_metadata_handler(m_renderer->m_worker, m_renderer, 18, G_TYPE_VALUE_ARRAY, array); + success = m_renderer->getCurrentMediaInfo(this, SLOT(media_info_result(const MafwMediaInfo& ))); + QTest::qWait(10); + + if(success) + { + QCOMPARE(m_media_values.at(0), mediaInfo.firstMetaData(MAFW_METADATA_KEY_URI)); + } + else if(!success) + { + QVERIFY(success); + } + } + else + { + //URI must be set + QMap onlyURI; + onlyURI[MAFW_METADATA_KEY_URI] = "http://2222.222.22"; + content.setMetaData(onlyURI); + m_renderer->doPlay(content); + + map[name] = values; + old_map[name] = values; + mediaInfo.setMetaData(map); + content.setMetaData(old_map); + m_metadataCount++; + + Q_FOREACH(QVariant value, values) + { + GValue geevalue; + memset(&geevalue, 0, sizeof(GValue)); + QString type = value.typeName(); + + if(type == "QString") + { + g_value_init(&geevalue, G_TYPE_STRING); + g_value_set_string(&geevalue, value.toByteArray()); + } + else if(type == "int") + { + g_value_init(&geevalue, G_TYPE_INT); + g_value_set_int(&geevalue, value.toInt()); + } + else if(type == "float") + { + g_value_init(&geevalue, G_TYPE_DOUBLE); + g_value_set_double(&geevalue, value.toDouble()); + } + else if(type == "bool") + { + g_value_init(&geevalue, G_TYPE_BOOLEAN); + g_value_set_boolean(&geevalue, value.toBool()); + } + + g_value_array_append(array, &geevalue); + g_value_unset(&geevalue); + } + qDebug() << "array.size:" << array->n_values; + m_renderer->m_worker->notify_metadata_handler(m_renderer->m_worker, m_renderer, m_metadataCount, G_TYPE_VALUE_ARRAY, array); + + success = m_renderer->getCurrentMediaInfo(this, SLOT(media_info_result(const MafwMediaInfo& )), name); + QTest::qWait(10); + + if(success) + { + //TODO rethink this and do the test properly if more metadata start to have related info attached + //Related metadata is returned with paused-thumbnail-uri. + if(name == "paused-thumbnail-uri") + { + values.append(QVariant(QString("http://2222.222.22"))); + values.append(QVariant(0)); + } + qDebug() << m_media_values; + qDebug() << values; + QCOMPARE(m_media_values, values); + } + else if(!success) + { + QVERIFY(success); + } + } + + g_value_array_free(array); +} + +void Ut_MafwGstRenderer::testGetCurrentMediaInfo_data() +{ + QTest::addColumn("name"); + QTest::addColumn >("values"); + + QTest::newRow("all") << "all" << QList(); + QTest::newRow("title") << MAFW_METADATA_KEY_TITLE << ( QList() << QVariant("test-title") ); + QTest::newRow("artist") << MAFW_METADATA_KEY_ARTIST << ( QList() << QVariant("test-artist") << QVariant("test-artist 2") ); + QTest::newRow("audio-codec") << MAFW_METADATA_KEY_AUDIO_CODEC << ( QList() << QVariant("test-audio-codec") ); + QTest::newRow("video-codec") << MAFW_METADATA_KEY_VIDEO_CODEC << ( QList() << QVariant("test-video-codec") ); + QTest::newRow("bitrate") << MAFW_METADATA_KEY_BITRATE << ( QList() << QVariant(256) ); + QTest::newRow("encoding") << MAFW_METADATA_KEY_ENCODING << ( QList() << QVariant("test-encoding") ); + QTest::newRow("album") << MAFW_METADATA_KEY_ALBUM << ( QList() << QVariant("test-album") ); + QTest::newRow("genre") << MAFW_METADATA_KEY_GENRE << ( QList() << QVariant("test-genre") ); + QTest::newRow("track") << MAFW_METADATA_KEY_TRACK << ( QList() << QVariant(1) ); + QTest::newRow("organization") << MAFW_METADATA_KEY_ORGANIZATION << ( QList() << QVariant("test-organization") ); + QTest::newRow("renderer-art-uri") << MAFW_METADATA_KEY_RENDERER_ART_URI << ( QList() << QVariant("http://test.renderer.art.uri") ); + QTest::newRow("res-x") << MAFW_METADATA_KEY_RES_X << ( QList() << QVariant(480) ); + QTest::newRow("res-y") << MAFW_METADATA_KEY_RES_Y << ( QList() << QVariant(640) ); + QTest::newRow("video-framerate") << MAFW_METADATA_KEY_VIDEO_FRAMERATE << ( QList() << QVariant(float(30/1)) ); + QTest::newRow("duration") << MAFW_METADATA_KEY_DURATION << ( QList() << QVariant(5) ); + QTest::newRow("is-seekable") << MAFW_METADATA_KEY_IS_SEEKABLE << ( QList() << QVariant(true) ); + QTest::newRow("paused-thumbnail-uri") << MAFW_METADATA_KEY_PAUSED_THUMBNAIL_URI << ( QList() << QVariant("file:///test.thumbnail.paused.uri") );// << QVariant("http://test.play.uri") << QVariant(666) ); + QTest::newRow("uri") << MAFW_METADATA_KEY_URI << ( QList() << QVariant("http://test.play.uri") ); +} + +void Ut_MafwGstRenderer::testErrorCodeScenarios() +{ + m_renderer->m_playingPlaylistFile = false; + + QFETCH(QString, uri); + QFETCH(int, workerError); + QFETCH(MafwError::Code, emittedError); + + global_worker_uri = g_strdup(uri.toAscii().constData()); + + QSignalSpy errorSpy(m_renderer, SIGNAL(rendererError(MafwError))); + + GError* gerror = g_error_new_literal(1, workerError, "Media not found"); + m_renderer->m_worker->notify_error_handler(m_renderer->m_worker, m_renderer, gerror); + + QCOMPARE(errorSpy.size(), 1); + + QVariantList params = errorSpy.takeFirst(); + MafwError mafwError = params.at(0).value(); + + QCOMPARE(mafwError.code(), MafwError::Code(emittedError)); + + g_error_free(gerror); +} + +void Ut_MafwGstRenderer::testErrorCodeScenarios_data() +{ + QTest::addColumn("uri"); + QTest::addColumn("workerError"); + QTest::addColumn("emittedError"); + + QTest::newRow("Local file not found") << "file:///donotexits.mp3" << int(WORKER_ERROR_MEDIA_NOT_FOUND) << MafwError::RendererError_MediaNotFound; + QTest::newRow("Stream could not be connected") << "mms:///donotexits.mp3" << int(WORKER_ERROR_MEDIA_NOT_FOUND) << MafwError::RendererError_URINotAvailable; +} + +void Ut_MafwGstRenderer::testBlankingPreventer() +{ + m_renderer->m_worker->blanking__control_handler(m_renderer->m_worker, m_renderer, TRUE ); + QCOMPARE( global_qmsystemstub_setBlankingPauseCalled, 1 ); + QTest::qWait( 50*1000 ); // >45 secs + QCOMPARE( global_qmsystemstub_setBlankingPauseCalled, 2 ); + global_qmsystemstub_setBlankingPauseCalled = 0; + + m_renderer->m_worker->blanking__control_handler(m_renderer->m_worker, m_renderer, FALSE ); + QTest::qWait( 50*1000 ); // >45 secs + // no more calls arrived + QCOMPARE( global_qmsystemstub_setBlankingPauseCalled, 0 ); +} + +void Ut_MafwGstRenderer::testPolicyPropertyHandler() +{ + m_renderer->setMafwProperty(MafwRenderer::MAFW_RENDERER_PROPERTY_POLICY_OVERRIDE, true); + QVERIFY(global_ready_timeout == 0); + + m_renderer->setMafwProperty(MafwRenderer::MAFW_RENDERER_PROPERTY_POLICY_OVERRIDE, false); + QCOMPARE(global_ready_timeout, (guint)MAFW_GST_RENDERER_WORKER_READY_TIMEOUT); + + m_renderer->setMafwProperty(MafwRenderer::MAFW_RENDERER_PROPERTY_POLICY_OVERRIDE, true); + QVERIFY(global_ready_timeout == 0); + + m_renderer->setMafwProperty(MafwRenderer::MAFW_RENDERER_PROPERTY_POLICY_OVERRIDE, false); + QCOMPARE(global_ready_timeout, (guint)MAFW_GST_RENDERER_WORKER_READY_TIMEOUT); + +} + +void Ut_MafwGstRenderer::testMediaRouting() +{ + + QVERIFY(global_audio_route_property); + QVERIFY(global_video_route_property); + + global_audio_route = "tvout"; + global_video_route = "builtinandtvout"; + m_renderer->m_audioRoute->ignoreCommander(); + m_renderer->m_videoRoute->ignoreCommander(); + QVERIFY(global_worker_destinations); + QVERIFY(g_slist_length(global_worker_destinations) == 3); + QVERIFY(g_slist_find(global_worker_destinations, GINT_TO_POINTER(WORKER_OUTPUT_HEADPHONE_JACK))); + QVERIFY(g_slist_find(global_worker_destinations, GINT_TO_POINTER(WORKER_OUTPUT_BUILTIN_DISPLAY))); + QVERIFY(g_slist_find(global_worker_destinations, GINT_TO_POINTER(WORKER_OUTPUT_TVOUT))); + + global_audio_route = "tvout"; + global_video_route = "tvout"; + m_renderer->m_audioRoute->ignoreCommander(); + m_renderer->m_videoRoute->ignoreCommander(); + QVERIFY(global_worker_destinations); + QVERIFY(g_slist_length(global_worker_destinations) == 2); + QVERIFY(g_slist_find(global_worker_destinations, GINT_TO_POINTER(WORKER_OUTPUT_HEADPHONE_JACK))); + QVERIFY(g_slist_find(global_worker_destinations, GINT_TO_POINTER(WORKER_OUTPUT_TVOUT))); + + global_audio_route = "null"; + global_video_route = "builtin"; + m_renderer->m_audioRoute->ignoreCommander(); + m_renderer->m_videoRoute->ignoreCommander(); + QVERIFY(global_worker_destinations); + QVERIFY(g_slist_length(global_worker_destinations) == 2); + QVERIFY(g_slist_find(global_worker_destinations, GINT_TO_POINTER(WORKER_OUTPUT_NULL))); + QVERIFY(g_slist_find(global_worker_destinations, GINT_TO_POINTER(WORKER_OUTPUT_BUILTIN_DISPLAY))); + + global_audio_route = "headset"; + global_video_route = "kjkjkjfg"; + m_renderer->m_audioRoute->ignoreCommander(); + m_renderer->m_videoRoute->ignoreCommander(); + QVERIFY(global_worker_destinations); + QVERIFY(g_slist_length(global_worker_destinations) == 2); + QVERIFY(g_slist_find(global_worker_destinations, GINT_TO_POINTER(WORKER_OUTPUT_HEADPHONE_JACK))); + QVERIFY(g_slist_find(global_worker_destinations, GINT_TO_POINTER(WORKER_OUTPUT_NULL))); + + MafwMediaInfo content("test_uuid"); + QMap > map; + map[MAFW_METADATA_KEY_URI] = QList() << "http://test.play.uri"; + content.setMetaData(map); + m_renderer->doPlay(content); + QVERIFY(global_worker_playing == TRUE); //should be playing now + global_audio_route = "ihf"; + global_video_route = "builtin"; + m_renderer->m_audioRoute->ignoreCommander(); + QVERIFY(global_worker_destinations); + QVERIFY(g_slist_find(global_worker_destinations, GINT_TO_POINTER(WORKER_OUTPUT_BUILTIN_SPEAKERS))); + m_renderer->m_videoRoute->ignoreCommander(); + QVERIFY(g_slist_find(global_worker_destinations, GINT_TO_POINTER(WORKER_OUTPUT_BUILTIN_DISPLAY))); + QVERIFY(g_slist_length(global_worker_destinations) == 2); + + global_audio_route = "earpiece"; + global_video_route = "builtinandtvout"; + m_renderer->m_audioRoute->ignoreCommander(); + m_renderer->m_videoRoute->ignoreCommander(); + QVERIFY(global_worker_destinations); + QVERIFY(g_slist_length(global_worker_destinations) == 3); + QVERIFY(g_slist_find(global_worker_destinations, GINT_TO_POINTER(WORKER_OUTPUT_BUILTIN_SPEAKERS))); + QVERIFY(g_slist_find(global_worker_destinations, GINT_TO_POINTER(WORKER_OUTPUT_BUILTIN_DISPLAY))); + QVERIFY(g_slist_find(global_worker_destinations, GINT_TO_POINTER(WORKER_OUTPUT_TVOUT))); + + global_audio_route = "bthsp"; + global_video_route = "kjkjkjfg"; + m_renderer->m_audioRoute->ignoreCommander(); + m_renderer->m_videoRoute->ignoreCommander(); + QVERIFY(global_worker_destinations); + QVERIFY(g_slist_length(global_worker_destinations) == 2); + QVERIFY(g_slist_find(global_worker_destinations, GINT_TO_POINTER(WORKER_OUTPUT_BLUETOOTH_AUDIO))); + QVERIFY(g_slist_find(global_worker_destinations, GINT_TO_POINTER(WORKER_OUTPUT_NULL))); + + global_audio_route = "bta2dp"; + global_video_route = "builtin"; + m_renderer->m_audioRoute->ignoreCommander(); + m_renderer->m_videoRoute->ignoreCommander(); + QVERIFY(global_worker_destinations); + QVERIFY(g_slist_length(global_worker_destinations) == 2); + QVERIFY(g_slist_find(global_worker_destinations, GINT_TO_POINTER(WORKER_OUTPUT_BLUETOOTH_AUDIO))); + QVERIFY(g_slist_find(global_worker_destinations, GINT_TO_POINTER(WORKER_OUTPUT_BUILTIN_DISPLAY))); + + global_audio_route = "lkglklkgh"; + global_video_route = "bugvfdd"; + m_renderer->m_audioRoute->ignoreCommander(); + m_renderer->m_videoRoute->ignoreCommander(); + QVERIFY(global_worker_destinations); + QVERIFY(g_slist_length(global_worker_destinations) == 1); + QVERIFY(g_slist_find(global_worker_destinations, GINT_TO_POINTER(WORKER_OUTPUT_NULL))); + + global_audio_route = "fmtx"; + global_video_route = "builtinandtvout"; + m_renderer->m_audioRoute->ignoreCommander(); + m_renderer->m_videoRoute->ignoreCommander(); + QVERIFY(global_worker_destinations); + QVERIFY(g_slist_length(global_worker_destinations) == 3); + QVERIFY(g_slist_find(global_worker_destinations, GINT_TO_POINTER(WORKER_OUTPUT_FM_RADIO))); + QVERIFY(g_slist_find(global_worker_destinations, GINT_TO_POINTER(WORKER_OUTPUT_BUILTIN_DISPLAY))); + QVERIFY(g_slist_find(global_worker_destinations, GINT_TO_POINTER(WORKER_OUTPUT_TVOUT))); + + global_audio_route = "ihfandfmtx"; + global_video_route = "builtinandtvout"; + m_renderer->m_audioRoute->ignoreCommander(); + m_renderer->m_videoRoute->ignoreCommander(); + QVERIFY(global_worker_destinations); + QVERIFY(g_slist_length(global_worker_destinations) == 4); + QVERIFY(g_slist_find(global_worker_destinations, GINT_TO_POINTER(WORKER_OUTPUT_BUILTIN_SPEAKERS))); + QVERIFY(g_slist_find(global_worker_destinations, GINT_TO_POINTER(WORKER_OUTPUT_FM_RADIO))); + QVERIFY(g_slist_find(global_worker_destinations, GINT_TO_POINTER(WORKER_OUTPUT_BUILTIN_DISPLAY))); + QVERIFY(g_slist_find(global_worker_destinations, GINT_TO_POINTER(WORKER_OUTPUT_TVOUT))); + + global_audio_route = "earpieceandtvout"; + global_video_route = "builtinandtvout"; + m_renderer->m_audioRoute->ignoreCommander(); + m_renderer->m_videoRoute->ignoreCommander(); + QVERIFY(global_worker_destinations); + QVERIFY(g_slist_length(global_worker_destinations) == 3); + QVERIFY(g_slist_find(global_worker_destinations, GINT_TO_POINTER(WORKER_OUTPUT_BUILTIN_SPEAKERS))); + QVERIFY(g_slist_find(global_worker_destinations, GINT_TO_POINTER(WORKER_OUTPUT_BUILTIN_DISPLAY))); + QVERIFY(g_slist_find(global_worker_destinations, GINT_TO_POINTER(WORKER_OUTPUT_TVOUT))); + + global_audio_route = "headphone"; + global_video_route = "builtinandtvout"; + m_renderer->m_audioRoute->ignoreCommander(); + m_renderer->m_videoRoute->ignoreCommander(); + QVERIFY(global_worker_destinations); + QVERIFY(g_slist_length(global_worker_destinations) == 3); + QVERIFY(g_slist_find(global_worker_destinations, GINT_TO_POINTER(WORKER_OUTPUT_HEADPHONE_JACK))); + QVERIFY(g_slist_find(global_worker_destinations, GINT_TO_POINTER(WORKER_OUTPUT_BUILTIN_DISPLAY))); + QVERIFY(g_slist_find(global_worker_destinations, GINT_TO_POINTER(WORKER_OUTPUT_TVOUT))); + + global_audio_route = "ihfandheadset"; + global_video_route = "builtinandtvout"; + m_renderer->m_audioRoute->ignoreCommander(); + m_renderer->m_videoRoute->ignoreCommander(); + QVERIFY(global_worker_destinations); + QVERIFY(g_slist_length(global_worker_destinations) == 4); + QVERIFY(g_slist_find(global_worker_destinations, GINT_TO_POINTER(WORKER_OUTPUT_BUILTIN_SPEAKERS))); + QVERIFY(g_slist_find(global_worker_destinations, GINT_TO_POINTER(WORKER_OUTPUT_HEADPHONE_JACK))); + QVERIFY(g_slist_find(global_worker_destinations, GINT_TO_POINTER(WORKER_OUTPUT_BUILTIN_DISPLAY))); + QVERIFY(g_slist_find(global_worker_destinations, GINT_TO_POINTER(WORKER_OUTPUT_TVOUT))); + + global_audio_route = "ihfandheadphone"; + global_video_route = "builtinandtvout"; + m_renderer->m_audioRoute->ignoreCommander(); + m_renderer->m_videoRoute->ignoreCommander(); + QVERIFY(global_worker_destinations); + QVERIFY(g_slist_length(global_worker_destinations) == 4); + QVERIFY(g_slist_find(global_worker_destinations, GINT_TO_POINTER(WORKER_OUTPUT_BUILTIN_SPEAKERS))); + QVERIFY(g_slist_find(global_worker_destinations, GINT_TO_POINTER(WORKER_OUTPUT_HEADPHONE_JACK))); + QVERIFY(g_slist_find(global_worker_destinations, GINT_TO_POINTER(WORKER_OUTPUT_BUILTIN_DISPLAY))); + QVERIFY(g_slist_find(global_worker_destinations, GINT_TO_POINTER(WORKER_OUTPUT_TVOUT))); + + global_audio_route = "ihfandbthsp"; + global_video_route = "builtinandtvout"; + m_renderer->m_audioRoute->ignoreCommander(); + m_renderer->m_videoRoute->ignoreCommander(); + QVERIFY(global_worker_destinations); + QVERIFY(g_slist_length(global_worker_destinations) == 4); + QVERIFY(g_slist_find(global_worker_destinations, GINT_TO_POINTER(WORKER_OUTPUT_BUILTIN_SPEAKERS))); + QVERIFY(g_slist_find(global_worker_destinations, GINT_TO_POINTER(WORKER_OUTPUT_BLUETOOTH_AUDIO))); + QVERIFY(g_slist_find(global_worker_destinations, GINT_TO_POINTER(WORKER_OUTPUT_BUILTIN_DISPLAY))); + QVERIFY(g_slist_find(global_worker_destinations, GINT_TO_POINTER(WORKER_OUTPUT_TVOUT))); + + global_audio_route = "tvoutandbthsp"; + global_video_route = "builtinandtvout"; + m_renderer->m_audioRoute->ignoreCommander(); + m_renderer->m_videoRoute->ignoreCommander(); + QVERIFY(global_worker_destinations); + QVERIFY(g_slist_length(global_worker_destinations) == 4); + QVERIFY(g_slist_find(global_worker_destinations, GINT_TO_POINTER(WORKER_OUTPUT_HEADPHONE_JACK))); + QVERIFY(g_slist_find(global_worker_destinations, GINT_TO_POINTER(WORKER_OUTPUT_BLUETOOTH_AUDIO))); + QVERIFY(g_slist_find(global_worker_destinations, GINT_TO_POINTER(WORKER_OUTPUT_BUILTIN_DISPLAY))); + QVERIFY(g_slist_find(global_worker_destinations, GINT_TO_POINTER(WORKER_OUTPUT_TVOUT))); + + global_audio_route = "tvoutandbta2dp"; + global_video_route = "builtinandtvout"; + m_renderer->m_audioRoute->ignoreCommander(); + m_renderer->m_videoRoute->ignoreCommander(); + QVERIFY(global_worker_destinations); + QVERIFY(g_slist_length(global_worker_destinations) == 4); + QVERIFY(g_slist_find(global_worker_destinations, GINT_TO_POINTER(WORKER_OUTPUT_HEADPHONE_JACK))); + QVERIFY(g_slist_find(global_worker_destinations, GINT_TO_POINTER(WORKER_OUTPUT_BLUETOOTH_AUDIO))); + QVERIFY(g_slist_find(global_worker_destinations, GINT_TO_POINTER(WORKER_OUTPUT_BUILTIN_DISPLAY))); + QVERIFY(g_slist_find(global_worker_destinations, GINT_TO_POINTER(WORKER_OUTPUT_TVOUT))); + + // provider dies + global_audio_route = "earpiece"; + global_video_route = "builtin"; + m_renderer->m_audioRoute->ignoreCommander(); + m_renderer->m_videoRoute->ignoreCommander(); + QVERIFY(g_slist_find(global_worker_destinations, GINT_TO_POINTER(WORKER_OUTPUT_BUILTIN_SPEAKERS))); + QVERIFY(g_slist_find(global_worker_destinations, GINT_TO_POINTER(WORKER_OUTPUT_BUILTIN_DISPLAY))); + QList args; + args << "name" << "old" << ""; + QDBusMessage dbusMsg; + dbusMsg.setArguments(args); + m_renderer->handleContextProviderRemoval( dbusMsg ); + QVERIFY(g_slist_find(global_worker_destinations, GINT_TO_POINTER(WORKER_OUTPUT_NULL))); +} + +void Ut_MafwGstRenderer::testStamping() +{ + // start playing + MafwMediaInfo content("MafwTrackerSource::test_uuid"); + QMap > map; + map[MAFW_METADATA_KEY_URI] = QList() << "file:///home/user/MyDocs/test.play.uri"; + content.setMetaData(map); + + m_renderer->doPlay(content); + + QVERIFY( m_renderer->m_playedStamped==false ); + QTest::qWait(5200); + QVERIFY( m_renderer->m_playedStamped==true ); + m_renderer->doStop(); + + //http uri + MafwMediaInfo content2("MafwTrackerSource::test_uuid2"); + QMap > map2; + map2[MAFW_METADATA_KEY_URI] = QList() << "http://test.play.uri"; + content2.setMetaData(map2); + + m_renderer->doPlay(content2); + + QVERIFY( m_renderer->m_playedStamped==false ); + QTest::qWait(5200); + QVERIFY( m_renderer->m_playedStamped==false ); + m_renderer->doStop(); + + // play uri case (no uuid) + MafwMediaInfo content3; + QMap > map3; + map3[MAFW_METADATA_KEY_URI] = QList() << "file://test.play.uri"; + content3.setMetaData(map3); + + m_renderer->doPlay(content3); + + QVERIFY( m_renderer->m_playedStamped==false ); + QTest::qWait(5200); + QVERIFY( m_renderer->m_playedStamped==true ); + m_renderer->doStop(); +} + +void Ut_MafwGstRenderer::testNetworkChangesWhenPlaying() +{ + MafwMediaInfo content("test_uuid"); + QMap > map; + map[MAFW_METADATA_KEY_URI] = QList() << "http://test.play.uri"; + content.setMetaData(map); + + m_renderer->doPlay(content); + QVERIFY(global_worker_playing); //should be playing now + + NetworkStubHelper::currentCreatedConfigIsValid = true; + QNetworkConfiguration config; + + global_worker_stop_called = 0; + networkStub.emitConfigurationChange(config, + QNetworkConfiguration::Active); + QVERIFY(global_worker_playing); + QCOMPARE(global_worker_uri, "http://test.play.uri"); + QCOMPARE(global_worker_stop_called, 1); + + map[MAFW_METADATA_KEY_URI] = QList() << "file://test.play.uri"; + content.setMetaData(map); + + m_renderer->doPlay(content); + QVERIFY(global_worker_playing); //should be playing now + + //another network config is activated + QNetworkConfiguration config2; + networkStub.emitConfigurationChange(config2, + QNetworkConfiguration::Active); + + QVERIFY(global_worker_playing); //should keep playing as URI is file:// + + m_renderer->doStop(); + QVERIFY(!global_worker_playing); + + //checks that activating new network config stops play when streaming + map[MAFW_METADATA_KEY_URI] = QList() << "http://test.play.uri"; + content.setMetaData(map); + + m_renderer->doPlay(content); + QVERIFY(global_worker_playing); + + QNetworkConfiguration config3; + global_worker_stop_called = 0; + networkStub.emitConfigurationChange(config3, QNetworkConfiguration::Active); + QCOMPARE(global_worker_uri, "http://test.play.uri"); + QCOMPARE(global_worker_stop_called, 1); + QVERIFY(global_worker_playing); + + //checks that deactivating the current configuration stops playback + m_renderer->doPlay(content); + QVERIFY(global_worker_playing); + networkStub.emitConfigurationChange(config3, QNetworkConfiguration::Discovered); + QVERIFY(!global_worker_playing); +} + +void Ut_MafwGstRenderer::testNetworkChangesWithNoPlaylistFileUtil() +{ + delete m_renderer->m_playlistFileUtil; + m_renderer->m_playlistFileUtil = 0; + testNetworkChangesWhenPlaying(); +} + +void Ut_MafwGstRenderer::testNetworkChangesWhenPaused() +{ + MafwMediaInfo content("test_uuid"); + QMap > map; + map[MAFW_METADATA_KEY_URI] = QList() << "http://test.play.uri"; + content.setMetaData(map); + + QSignalSpy pauseSpy(m_renderer, SIGNAL(rendererPaused())); + QSignalSpy stopSpy(m_renderer, SIGNAL(rendererStopped())); + QSignalSpy playSpy(m_renderer, SIGNAL(rendererPlaying(int))); + QSignalSpy resumeSpy(m_renderer, SIGNAL(rendererResumed())); + + m_renderer->doPlay(content); + QVERIFY(global_worker_playing); //should be playing now + + m_renderer->doPause(); + + QCOMPARE(playSpy.size(), 1); + playSpy.clear(); + QCOMPARE(pauseSpy.size(), 1); + pauseSpy.clear(); + QVERIFY(!global_worker_playing); //should be playing now + + global_position = 313; + QNetworkConfiguration config; + networkStub.emitConfigurationChange(config, QNetworkConfiguration::Active); + + QVERIFY(!global_worker_playing); + QCOMPARE(m_renderer->m_playingItem, MafwBasicRenderer::CurrentUri); + + QCOMPARE(m_renderer->m_haltState.m_state, MafwRenderer::Paused); + QCOMPARE(m_renderer->m_haltState.m_position, 313); + QCOMPARE(m_renderer->m_haltState.m_uri, QString("http://test.play.uri")); + + QCOMPARE(stopSpy.size(), 0); + QCOMPARE(pauseSpy.size(), 0); + QCOMPARE(playSpy.size(), 0); + QCOMPARE(resumeSpy.size(), 0); + + global_worker_seek_request = 0; + + m_renderer->doResume(); + + QCOMPARE(stopSpy.size(), 0); + QCOMPARE(pauseSpy.size(), 0); + QCOMPARE(playSpy.size(), 0); + QCOMPARE(resumeSpy.size(), 1); + + QVERIFY(global_worker_playing); + + QCOMPARE(QString(global_worker_uri), QString("http://test.play.uri")); + QCOMPARE(m_renderer->m_playingItem, MafwBasicRenderer::CurrentUri); + QVERIFY(!m_renderer->m_haltState.isSet()); + + QCOMPARE(global_worker_seek_request, 313); +} + +void Ut_MafwGstRenderer::testNetworkChangesWhenPausedAndRendererStopped() +{ + MafwMediaInfo content("test_uuid"); + QMap > map; + map[MAFW_METADATA_KEY_URI] = QList() << "http://test.play.uri"; + content.setMetaData(map); + + QSignalSpy pauseSpy(m_renderer, SIGNAL(rendererPaused())); + QSignalSpy stopSpy(m_renderer, SIGNAL(rendererStopped())); + QSignalSpy playSpy(m_renderer, SIGNAL(rendererPlaying(int))); + + m_renderer->doPlay(content); + QVERIFY(global_worker_playing); //should be playing now + + m_renderer->doPause(); + + QCOMPARE(playSpy.size(), 1); + playSpy.clear(); + QCOMPARE(pauseSpy.size(), 1); + pauseSpy.clear(); + QVERIFY(!global_worker_playing); //should be playing now + + global_position = 313; + QNetworkConfiguration config; + networkStub.emitConfigurationChange(config, QNetworkConfiguration::Active); + + m_renderer->doStop(); + QCOMPARE(stopSpy.size(), 1); + QVERIFY(!m_renderer->m_haltState.isSet()); +} + +void Ut_MafwGstRenderer::testNetworkChangesToInactiveAndPauseResumeRequested() +{ + QFETCH(int, resumeDelay); + MafwGstRendererHaltState::DECAY_TIME = 3; + + MafwMediaInfo content("test_uuid"); + QMap > map; + map[MAFW_METADATA_KEY_URI] = QList() << "http://test.resume-pause.uri"; + content.setMetaData(map); + + QSignalSpy pauseSpy(m_renderer, SIGNAL(rendererPaused())); + QSignalSpy stopSpy(m_renderer, SIGNAL(rendererStopped())); + QSignalSpy playSpy(m_renderer, SIGNAL(rendererPlaying(int))); + + m_renderer->doPlay(content); + QVERIFY(global_worker_playing); //should be playing now + + QCOMPARE(playSpy.size(), 1); + playSpy.clear(); + + global_position = 999; + QNetworkConfiguration config; + networkStub.emitConfigurationChange(config, QNetworkConfiguration::Discovered); + + m_renderer->doPause(); + QCOMPARE(pauseSpy.size(), 1); + pauseSpy.clear(); + + QVERIFY(m_renderer->m_haltState.isSet()); + QCOMPARE(m_renderer->m_haltState.m_state, MafwRenderer::Paused); + QCOMPARE(m_renderer->m_haltState.m_position, 999); + QCOMPARE(m_renderer->m_haltState.m_uri, QString("http://test.resume-pause.uri")); + + global_worker_seek_request = 0; + + QTest::qWait(resumeDelay); + + m_renderer->doResume(); + QCOMPARE(global_worker_seek_request, 999); + QVERIFY(global_worker_playing); //should be playing yeah there's no network but it will try + QVERIFY(!m_renderer->m_haltState.isSet()); +} + +void Ut_MafwGstRenderer::testNetworkChangesToInactiveAndPauseResumeRequested_data() +{ + QTest::addColumn("resumeDelay"); + QTest::newRow("short delay") << 1000; + QTest::newRow("same as decay") << 3000; + QTest::newRow("longer than decay") << 5000; +} + +void Ut_MafwGstRenderer::testNetworkChangesWithPlaylistURI() +{ + QStringList playlistUris = QStringList() << "http://test.uriplaylist.item/1" << "http://test.uriplaylist.item/2"; + stubPlaylistFileUtilityUris.clear(); + stubPlaylistFileUtilityUris = playlistUris; + + MafwMediaInfo content("test_uuid"); + QMap > map; + map[MAFW_METADATA_KEY_URI] = QList() << "http://test.playlist.m3u"; //does not matter + map[MAFW_METADATA_KEY_MIME] = QList() << "audio/x-scpls"; + content.setMetaData(map); + + QSignalSpy pauseSpy(m_renderer, SIGNAL(rendererPaused())); + QSignalSpy stopSpy(m_renderer, SIGNAL(rendererStopped())); + QSignalSpy playSpy(m_renderer, SIGNAL(rendererPlaying(int))); + QSignalSpy resumeSpy(m_renderer, SIGNAL(rendererResumed())); + + m_renderer->doPlay(content); + + //time to parse the playlist + QTest::qWait(75); + + QVERIFY(global_worker_playing); //should be playing now + + QCOMPARE(playSpy.size(), 1); + playSpy.clear(); + + global_position = 007; + global_worker_stop_called = 0; + + NetworkStubHelper::currentCreatedConfigIsValid = false; + QNetworkConfiguration config; + networkStub.emitConfigurationChange(config, QNetworkConfiguration::Discovered); + + QVERIFY(!global_worker_playing); + QCOMPARE(global_worker_stop_called, 1); + QCOMPARE(m_renderer->m_playingItem, MafwBasicRenderer::CurrentUri); + + QCOMPARE(m_renderer->m_haltState.m_state, MafwRenderer::Playing); + QCOMPARE(m_renderer->m_haltState.m_position, 007); + QCOMPARE(m_renderer->m_haltState.m_uri, playlistUris.at(0)); + + QCOMPARE(pauseSpy.size(), 0); + QCOMPARE(stopSpy.size(), 0); + QCOMPARE(playSpy.size(), 0); + QCOMPARE(resumeSpy.size(), 0); + + global_worker_seek_request = 0; + + NetworkStubHelper::currentCreatedConfigIsValid = true; + QNetworkConfiguration configActive; + networkStub.emitConfigurationChange(configActive, QNetworkConfiguration::Active); + + QVERIFY(global_worker_playing); + QCOMPARE(global_worker_seek_request, 007); + + QCOMPARE(stopSpy.size(), 0); + QCOMPARE(pauseSpy.size(), 0); + QCOMPARE(playSpy.size(), 0); + QCOMPARE(resumeSpy.size(), 0); + + QCOMPARE(QString(global_worker_uri), playlistUris.at(0)); + QCOMPARE(m_renderer->m_playingItem, MafwBasicRenderer::CurrentUri); + QVERIFY(!m_renderer->m_haltState.isSet()); + + //Test that next uri is started to play if playing first stops because of an error + GError* error = g_error_new_literal(1, 2, "Playlist uri playback error"); + m_renderer->m_worker->notify_error_handler(m_renderer->m_worker, m_renderer, error); + QTest::qWait(10); + + QVERIFY(global_worker_playing); + QCOMPARE(stopSpy.size(), 0); + QCOMPARE(pauseSpy.size(), 0); + QCOMPARE(playSpy.size(), 0); + QCOMPARE(resumeSpy.size(), 0); + + QCOMPARE(QString(global_worker_uri), playlistUris.at(1)); + + m_renderer->doStop(); + QVERIFY(!global_worker_playing); + QCOMPARE(stopSpy.size(), 1); + + g_error_free(error); +} + +void Ut_MafwGstRenderer::testNetworkChangesHaltStateDecay() +{ + MafwGstRendererHaltState::DECAY_TIME = 4; + + MafwMediaInfo content("test_uuid"); + QMap > map; + map[MAFW_METADATA_KEY_URI] = QList() << "http://test.decay.uri"; + content.setMetaData(map); + + QSignalSpy pauseSpy(m_renderer, SIGNAL(rendererPaused())); + QSignalSpy stopSpy(m_renderer, SIGNAL(rendererStopped())); + QSignalSpy playSpy(m_renderer, SIGNAL(rendererPlaying(int))); + QSignalSpy resumeSpy(m_renderer, SIGNAL(rendererResumed())); + + m_renderer->doPlay(content); + QVERIFY(global_worker_playing); //should be playing now + + QCOMPARE(playSpy.size(), 1); + playSpy.clear(); + + global_position = 313; + NetworkStubHelper::currentCreatedConfigIsValid = false; + QNetworkConfiguration config; + networkStub.emitConfigurationChange(config, QNetworkConfiguration::Discovered); + + QVERIFY(!global_worker_playing); + QCOMPARE(m_renderer->m_playingItem, MafwBasicRenderer::CurrentUri); + + QCOMPARE(m_renderer->m_haltState.m_state, MafwRenderer::Playing); + QCOMPARE(m_renderer->m_haltState.m_position, 313); + QCOMPARE(m_renderer->m_haltState.m_uri, QString("http://test.decay.uri")); + + QCOMPARE(stopSpy.size(), 0); + QCOMPARE(pauseSpy.size(), 0); + QCOMPARE(playSpy.size(), 0); + QCOMPARE(resumeSpy.size(), 0); + + global_worker_stop_called = 0; + QTest::qWait(MafwGstRendererHaltState::DECAY_TIME * 1000 + 1000); + + global_worker_stop_called = 1; + QCOMPARE(stopSpy.size(), 1); + stopSpy.clear(); + QCOMPARE(pauseSpy.size(), 0); + QCOMPARE(playSpy.size(), 0); + QCOMPARE(resumeSpy.size(), 0); + + QVERIFY(!m_renderer->m_haltState.isSet()); + + global_worker_seek_request = 0; + global_worker_stop_called = 0; + NetworkStubHelper::currentCreatedConfigIsValid = true; + QNetworkConfiguration config2; + networkStub.emitConfigurationChange(config2, QNetworkConfiguration::Active); + + QCOMPARE(stopSpy.size(), 0); + QCOMPARE(pauseSpy.size(), 0); + QCOMPARE(playSpy.size(), 0); + QCOMPARE(resumeSpy.size(), 0); + + QVERIFY(!global_worker_playing); + + global_worker_stop_called = 0; + QCOMPARE(m_renderer->m_playingItem, MafwBasicRenderer::UnknownUri); + QVERIFY(!m_renderer->m_haltState.isSet()); + + QCOMPARE(global_worker_seek_request, 0); +} + +void Ut_MafwGstRenderer::testMmc() +{ + QVERIFY(!global_worker_playing); + + MafwGstRenderer *rnd = new MafwGstRenderer("renderer_uuid", "renderer-plugin", "rendere_name"); + m_stubHelper->expect("initialize", true); + QVERIFY(rnd->initialize(0) == true); + + // MMC not mounted at first case + + QSignalSpy errorSpy( rnd, SIGNAL( rendererError(const MafwError&) ) ); + stubMmcMounted = false; + MafwMediaInfo content("test_uuid_xyz"); + QMap > map; + map[MAFW_METADATA_KEY_URI] = QList() << "file:///home/user/MyDocs/rock.mp3"; + content.setMetaData(map); + + rnd->doPlay(content); + QVERIFY(!global_worker_playing); + QCOMPARE( errorSpy.size(), 1 ); + MafwError err=errorSpy[0][0].value(); + QVERIFY( err.code()==MafwError::RendererError_MmcNotAvailable ); + + // MMC unmounted during play + + stubMmcMounted = true; + errorSpy.clear(); + + rnd->doPlay(content); + QVERIFY(global_worker_playing); + + Q_EMIT stubMmcMonitor->preUnmountEvent("pre-unmount"); + QTest::qWait(100); + QVERIFY(!global_worker_playing); + QVERIFY( errorSpy.size()==1 ); + + // Playlist first not available + + stubPlaylistFileUtilityUris.clear(); + stubPlaylistFileUtilityUris << "file:///home/user/MyDocs/rock.mp3"; + stubPlaylistFileUtilityUris << "file:///home/user/MyDocs/rock2.mp3"; + errorSpy.clear(); + stubMmcMounted = false; + + MafwMediaInfo mediaInfo; + QMap testUri; + QMap testMimeType; + testUri.insert(MAFW_METADATA_KEY_URI, "file:///var/tmp/tunein-station.pls"); + testMimeType.insert(MAFW_METADATA_KEY_MIME, "audio/x-scpls"); + mediaInfo.setMetaData(testUri); + mediaInfo.setMetaData(testMimeType); + + rnd->doPlay(mediaInfo); + QTest::qWait(10); + QVERIFY(!global_worker_playing); + QCOMPARE( errorSpy.size(), 1 ); + err=errorSpy[0][0].value(); + QVERIFY( err.code()==MafwError::RendererError_MmcNotAvailable ); + + // Playlist play first, second not available + + errorSpy.clear(); + stubMmcMounted = true; + + rnd->doPlay(mediaInfo); + QTest::qWait(10); + QVERIFY(global_worker_playing); + + stubMmcMounted = false; + // cause next + GError* error = g_error_new_literal(1, 2, "Playlist uri playback error"); + m_renderer->m_worker->notify_error_handler(m_renderer->m_worker, rnd, error); + errorSpy.clear(); + + QTest::qWait(10); + QCOMPARE( errorSpy.size(), 1 ); + err=errorSpy[0][0].value(); + QVERIFY( err.code()==MafwError::RendererError_MmcNotAvailable ); + QVERIFY(!global_worker_playing); + + g_error_free(error); + + delete rnd; +} + +void Ut_MafwGstRenderer::play_result(const MafwError& /*error*/, MafwRenderer& /*rndr*/) +{ + qDebug() << "Ut_MafwGstRenderer::play_result"; + +} + +void Ut_MafwGstRenderer::positionChanged(uint position) +{ + m_position = position; +} + +void Ut_MafwGstRenderer::positionError(const MafwError& error) +{ + m_error = error; +} + +void Ut_MafwGstRenderer::propertyChanged(const QString& name, const QVariant& value) +{ + m_name = name; + m_value = value; +} + +void Ut_MafwGstRenderer::media_info_result(const MafwMediaInfo& mediaInfo) +{ + qDebug() << __PRETTY_FUNCTION__; + qDebug() << "m_name:" << m_name; + + m_media_values.clear(); + + if(m_name == "all") + { + m_media_values = mediaInfo.metaData(MAFW_METADATA_KEY_URI); + } + else + { + m_media_values = mediaInfo.metaData(m_name); + } + + qDebug() << "m_media_values.size():" << m_media_values.size(); + Q_FOREACH(QVariant v, m_media_values) + { + qDebug() << "value:" << v; + } +} + +void gst_init(int *argc, char **argv[]) +{ + Q_UNUSED(argc); + Q_UNUSED(argv); +} + +QTEST_MAIN(Ut_MafwGstRenderer) + +//Volume stub +MafwGstRendererVolume::MafwGstRendererVolume() +{ + qDebug() << "Volume stub ctor"; +} + +void MafwGstRendererVolume::connectToPulseAudio() +{ +} + +MafwGstRendererVolume::~MafwGstRendererVolume() +{ +} + +uint MafwGstRendererVolume::getVolume() +{ + qDebug(__PRETTY_FUNCTION__); + return (uint)1; +} + +bool MafwGstRendererVolume::setVolume (uint value) +{ + Q_UNUSED(value); + return true; +}