--- /dev/null
+/*
+ * This file is part of QMAFW
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). All rights
+ * reserved.
+ *
+ * Contact: Visa Smolander <visa.smolander@nokia.com>
+ *
+ * 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 <QDebug>
+#include <QVariant>
+#include <QDBusMessage>
+#include <MafwContent.h>
+#include <MafwMediaInfo.h>
+#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 <QtNetwork/QNetworkConfiguration>
+
+#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<QString, QVariant> globalSettingsMap;
+
+extern bool stubMmcMounted;
+extern MafwMmcMonitor* stubMmcMonitor;
+extern QStringList stubPlaylistFileUtilityUris;
+
+void Ut_MafwGstRenderer::initTestCase()
+{
+ qRegisterMetaType<MafwError>();
+ qRegisterMetaType<MafwError::Code>();
+ qRegisterMetaType<QVariant>();
+ 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<QString,QList<QVariant> > map;
+ map[MAFW_METADATA_KEY_URI] = QList<QVariant>() << "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<QString, QVariant> testUri;
+ QMap<QString, QVariant> 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<QVariant> 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<QString,QList<QVariant> >map;
+ map[MAFW_METADATA_KEY_URI] = QList<QVariant>() << "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<QString,QList<QVariant> >map;
+ map[MAFW_METADATA_KEY_URI] = QList<QVariant>() << "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<QString>("name");
+ QTest::addColumn<QVariant>("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<QString,QList<QVariant> >map;
+ map[MAFW_METADATA_KEY_URI] = QList<QVariant>() << "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<QVariant> arguments = propertyChangedSpy.takeFirst();
+ QCOMPARE(arguments.count(), 2);
+ QCOMPARE(arguments.at(0).toString(), propertyName);
+ //There is a QVariant inside QVariant
+ QCOMPARE(arguments.at(1).value<QVariant>().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<QVariant>().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<QVariant>().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<QVariant>().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<QVariant>().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<QVariant>().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<QVariant>().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<QVariant>().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<QVariant>().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<QVariant>&)));
+ 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<QVariant>, values);
+
+ qDebug() << "values.size():" << values.size();
+
+ MafwMediaInfo content("");
+ MafwMediaInfo mediaInfo;
+ QMap<QString,QList<QVariant> > map;
+ QMap<QString,QList<QVariant> >old_map;
+
+ bool success = false;
+ m_name = name;
+
+ GValueArray *array = g_value_array_new(0);
+
+ if(name == "all")
+ {
+ QList<QVariant> 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<QString, QVariant> 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<QString>("name");
+ QTest::addColumn<QList<QVariant> >("values");
+
+ QTest::newRow("all") << "all" << QList<QVariant>();
+ QTest::newRow("title") << MAFW_METADATA_KEY_TITLE << ( QList<QVariant>() << QVariant("test-title") );
+ QTest::newRow("artist") << MAFW_METADATA_KEY_ARTIST << ( QList<QVariant>() << QVariant("test-artist") << QVariant("test-artist 2") );
+ QTest::newRow("audio-codec") << MAFW_METADATA_KEY_AUDIO_CODEC << ( QList<QVariant>() << QVariant("test-audio-codec") );
+ QTest::newRow("video-codec") << MAFW_METADATA_KEY_VIDEO_CODEC << ( QList<QVariant>() << QVariant("test-video-codec") );
+ QTest::newRow("bitrate") << MAFW_METADATA_KEY_BITRATE << ( QList<QVariant>() << QVariant(256) );
+ QTest::newRow("encoding") << MAFW_METADATA_KEY_ENCODING << ( QList<QVariant>() << QVariant("test-encoding") );
+ QTest::newRow("album") << MAFW_METADATA_KEY_ALBUM << ( QList<QVariant>() << QVariant("test-album") );
+ QTest::newRow("genre") << MAFW_METADATA_KEY_GENRE << ( QList<QVariant>() << QVariant("test-genre") );
+ QTest::newRow("track") << MAFW_METADATA_KEY_TRACK << ( QList<QVariant>() << QVariant(1) );
+ QTest::newRow("organization") << MAFW_METADATA_KEY_ORGANIZATION << ( QList<QVariant>() << QVariant("test-organization") );
+ QTest::newRow("renderer-art-uri") << MAFW_METADATA_KEY_RENDERER_ART_URI << ( QList<QVariant>() << QVariant("http://test.renderer.art.uri") );
+ QTest::newRow("res-x") << MAFW_METADATA_KEY_RES_X << ( QList<QVariant>() << QVariant(480) );
+ QTest::newRow("res-y") << MAFW_METADATA_KEY_RES_Y << ( QList<QVariant>() << QVariant(640) );
+ QTest::newRow("video-framerate") << MAFW_METADATA_KEY_VIDEO_FRAMERATE << ( QList<QVariant>() << QVariant(float(30/1)) );
+ QTest::newRow("duration") << MAFW_METADATA_KEY_DURATION << ( QList<QVariant>() << QVariant(5) );
+ QTest::newRow("is-seekable") << MAFW_METADATA_KEY_IS_SEEKABLE << ( QList<QVariant>() << QVariant(true) );
+ QTest::newRow("paused-thumbnail-uri") << MAFW_METADATA_KEY_PAUSED_THUMBNAIL_URI << ( QList<QVariant>() << QVariant("file:///test.thumbnail.paused.uri") );// << QVariant("http://test.play.uri") << QVariant(666) );
+ QTest::newRow("uri") << MAFW_METADATA_KEY_URI << ( QList<QVariant>() << 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<MafwError>();
+
+ QCOMPARE(mafwError.code(), MafwError::Code(emittedError));
+
+ g_error_free(gerror);
+}
+
+void Ut_MafwGstRenderer::testErrorCodeScenarios_data()
+{
+ QTest::addColumn<QString>("uri");
+ QTest::addColumn<int>("workerError");
+ QTest::addColumn<MafwError::Code>("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<QString,QList<QVariant> > map;
+ map[MAFW_METADATA_KEY_URI] = QList<QVariant>() << "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<QVariant> 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<QString,QList<QVariant> > map;
+ map[MAFW_METADATA_KEY_URI] = QList<QVariant>() << "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<QString,QList<QVariant> > map2;
+ map2[MAFW_METADATA_KEY_URI] = QList<QVariant>() << "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<QString,QList<QVariant> > map3;
+ map3[MAFW_METADATA_KEY_URI] = QList<QVariant>() << "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<QString,QList<QVariant> > map;
+ map[MAFW_METADATA_KEY_URI] = QList<QVariant>() << "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<QVariant>() << "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<QVariant>() << "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<QString,QList<QVariant> > map;
+ map[MAFW_METADATA_KEY_URI] = QList<QVariant>() << "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<QString,QList<QVariant> > map;
+ map[MAFW_METADATA_KEY_URI] = QList<QVariant>() << "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<QString,QList<QVariant> > map;
+ map[MAFW_METADATA_KEY_URI] = QList<QVariant>() << "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<int>("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<QString,QList<QVariant> > map;
+ map[MAFW_METADATA_KEY_URI] = QList<QVariant>() << "http://test.playlist.m3u"; //does not matter
+ map[MAFW_METADATA_KEY_MIME] = QList<QVariant>() << "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<QString,QList<QVariant> > map;
+ map[MAFW_METADATA_KEY_URI] = QList<QVariant>() << "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<QString,QList<QVariant> > map;
+ map[MAFW_METADATA_KEY_URI] = QList<QVariant>() << "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<MafwError>();
+ 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<QString, QVariant> testUri;
+ QMap<QString, QVariant> 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<MafwError>();
+ 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<MafwError>();
+ 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;
+}
projects / mafwsubrenderer / blobdiff