--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/tests/auto/qaudiocapturesource/tst_qaudiocapturesource.cpp Wed Aug 25 15:49:42 2010 +0300
@@ -0,0 +1,358 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the Qt Mobility Components.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <QtTest/QtTest>
+#include <QDebug>
+
+#include <qaudioformat.h>
+
+#include <qaudiocapturesource.h>
+#include <qaudioencodercontrol.h>
+#include <qmediarecordercontrol.h>
+#include <qaudioendpointselector.h>
+
+QT_USE_NAMESPACE
+class MockAudioEncoderControl : public QAudioEncoderControl
+{
+ Q_OBJECT
+public:
+ MockAudioEncoderControl(QObject *parent = 0):
+ QAudioEncoderControl(parent)
+ {
+ m_codecs << "audio/pcm" << "audio/mpeg";
+ m_descriptions << "Pulse Code Modulation" << "mp3 format";
+ m_audioSettings.setCodec("audio/pcm");
+ m_audioSettings.setSampleRate(8000);
+ m_freqs << 8000 << 11025 << 22050 << 44100;
+ }
+
+ ~MockAudioEncoderControl() {}
+
+ QStringList supportedAudioCodecs() const { return m_codecs; }
+ QString codecDescription(const QString &codecName) const { return m_descriptions.at(m_codecs.indexOf(codecName)); }
+
+ QStringList supportedEncodingOptions(const QString &) const { return QStringList() << "bitrate"; }
+ QVariant encodingOption(const QString &, const QString &) const { return m_optionValue; }
+ void setEncodingOption(const QString &, const QString &, const QVariant &value) { m_optionValue = value; }
+
+ QList<int> supportedSampleRates(const QAudioEncoderSettings & = QAudioEncoderSettings(),
+ bool *continuous = 0) const
+ {
+ if (continuous)
+ *continuous = false;
+ return m_freqs;
+ }
+ QList<int> supportedChannelCounts(const QAudioEncoderSettings & = QAudioEncoderSettings()) const { QList<int> list; list << 1 << 2; return list; }
+
+ QAudioEncoderSettings audioSettings() const { return m_audioSettings; }
+ void setAudioSettings(const QAudioEncoderSettings &settings) { m_audioSettings = settings;}
+
+ QStringList m_codecs;
+ QStringList m_descriptions;
+
+ QAudioEncoderSettings m_audioSettings;
+
+ QList<int> m_freqs;
+ QVariant m_optionValue;
+};
+
+class MockMediaRecorderControl : public QMediaRecorderControl
+{
+ Q_OBJECT
+public:
+ MockMediaRecorderControl(QObject *parent = 0):
+ QMediaRecorderControl(parent),
+ m_state(QMediaRecorder::StoppedState),
+ m_position(0),
+ m_muted(false) {}
+
+ ~MockMediaRecorderControl() {}
+
+ QUrl outputLocation() const { return m_sink; }
+ bool setOutputLocation(const QUrl &sink) { m_sink = sink; return true; }
+ QMediaRecorder::State state() const { return m_state; }
+ qint64 duration() const { return m_position; }
+ void applySettings() {}
+ bool isMuted() const { return m_muted; }
+
+public slots:
+ void record()
+ {
+ m_state = QMediaRecorder::RecordingState;
+ m_position=1;
+ emit stateChanged(m_state);
+ emit durationChanged(m_position);
+ }
+ void pause()
+ {
+ m_state = QMediaRecorder::PausedState;
+ emit stateChanged(m_state);
+ }
+
+ void stop()
+ {
+ m_position=0;
+ m_state = QMediaRecorder::StoppedState;
+ emit stateChanged(m_state);
+ }
+
+ void setMuted(bool muted)
+ {
+ if (m_muted != muted)
+ emit mutedChanged(m_muted = muted);
+ }
+
+public:
+ QUrl m_sink;
+ QMediaRecorder::State m_state;
+ qint64 m_position;
+ bool m_muted;
+};
+
+class MockAudioEndpointSelector : public QAudioEndpointSelector
+{
+ Q_OBJECT
+public:
+ MockAudioEndpointSelector(QObject *parent):
+ QAudioEndpointSelector(parent)
+ {
+ m_names << "device1" << "device2" << "device3";
+ m_descriptions << "dev1 comment" << "dev2 comment" << "dev3 comment";
+ m_audioInput = "device1";
+ emit availableEndpointsChanged();
+ }
+ ~MockAudioEndpointSelector() {};
+
+ QList<QString> availableEndpoints() const
+ {
+ return m_names;
+ }
+
+ QString endpointDescription(const QString& name) const
+ {
+ QString desc;
+
+ for(int i = 0; i < m_names.count(); i++) {
+ if (m_names.at(i).compare(name) == 0) {
+ desc = m_descriptions.at(i);
+ break;
+ }
+ }
+ return desc;
+ }
+
+ QString defaultEndpoint() const
+ {
+ return m_names.at(0);
+ }
+
+ QString activeEndpoint() const
+ {
+ return m_audioInput;
+ }
+
+public Q_SLOTS:
+ void setActiveEndpoint(const QString& name)
+ {
+ m_audioInput = name;
+ emit activeEndpointChanged(name);
+ }
+
+private:
+ QString m_audioInput;
+ QList<QString> m_names;
+ QList<QString> m_descriptions;
+};
+
+
+class MockAudioSourceService : public QMediaService
+{
+ Q_OBJECT
+
+public:
+ MockAudioSourceService(): QMediaService(0), hasAudioDeviceControl(true)
+ {
+ mockAudioEncoderControl = new MockAudioEncoderControl(this);
+ mockMediaRecorderControl = new MockMediaRecorderControl(this);
+ mockAudioEndpointSelector = new MockAudioEndpointSelector(this);
+ }
+
+ ~MockAudioSourceService()
+ {
+ delete mockAudioEncoderControl;
+ delete mockMediaRecorderControl;
+ delete mockAudioEndpointSelector;
+ }
+
+ QMediaControl* requestControl(const char *iid)
+ {
+ if (qstrcmp(iid, QAudioEncoderControl_iid) == 0)
+ return mockAudioEncoderControl;
+
+ if (qstrcmp(iid, QMediaRecorderControl_iid) == 0)
+ return mockMediaRecorderControl;
+
+ if (hasAudioDeviceControl && qstrcmp(iid, QAudioEndpointSelector_iid) == 0)
+ return mockAudioEndpointSelector;
+
+ return 0;
+ }
+
+ void releaseControl(QMediaControl*) {}
+
+ MockAudioEncoderControl *mockAudioEncoderControl;
+ MockMediaRecorderControl *mockMediaRecorderControl;
+ MockAudioEndpointSelector *mockAudioEndpointSelector;
+ bool hasAudioDeviceControl;
+};
+
+class MockProvider : public QMediaServiceProvider
+{
+public:
+ MockProvider(MockAudioSourceService *service):mockService(service) {}
+ QMediaService *requestService(const QByteArray&, const QMediaServiceProviderHint &)
+ {
+ return mockService;
+ }
+
+ void releaseService(QMediaService *) {}
+
+ MockAudioSourceService *mockService;
+};
+
+
+class tst_QAudioCaptureSource: public QObject
+{
+ Q_OBJECT
+
+public slots:
+ void initTestCase();
+ void cleanupTestCase();
+
+private slots:
+ //void testNullService();
+ //void testNullControl();
+ void testAudioSource();
+ void testOptions();
+ void testDevices();
+
+private:
+ QAudioCaptureSource *audiosource;
+ MockAudioSourceService *mockAudioSourceService;
+ MockProvider *mockProvider;
+};
+
+void tst_QAudioCaptureSource::initTestCase()
+{
+ mockAudioSourceService = new MockAudioSourceService;
+ mockProvider = new MockProvider(mockAudioSourceService);
+}
+
+void tst_QAudioCaptureSource::cleanupTestCase()
+{
+ delete audiosource;
+ delete mockProvider;
+}
+/*
+void tst_QAudioCaptureSource::testNullService()
+{
+ MockProvider provider(0);
+ QAudioCaptureSource source(0, &provider);
+
+ QCOMPARE(source.audioInputs().size(), 0);
+ QCOMPARE(source.defaultAudioInput(), QString());
+ QCOMPARE(source.activeAudioInput(), QString());
+}
+*/
+/*
+void tst_QAudioCaptureSource::testNullControl()
+{
+ MockAudioSourceService service;
+ service.hasAudioDeviceControl = false;
+ MockProvider provider(&service);
+ QAudioCaptureSource source(0, &provider);
+
+ QCOMPARE(source.audioInputs().size(), 0);
+ QCOMPARE(source.defaultAudioInput(), QString());
+ QCOMPARE(source.activeAudioInput(), QString());
+
+ QCOMPARE(source.audioDescription("blah"), QString());
+
+ QSignalSpy deviceNameSpy(&source, SIGNAL(activeAudioInputChanged(QString)));
+
+ source.setAudioInput("blah");
+ QCOMPARE(deviceNameSpy.count(), 0);
+}
+*/
+void tst_QAudioCaptureSource::testAudioSource()
+{
+ audiosource = new QAudioCaptureSource(0, mockProvider);
+
+ QCOMPARE(audiosource->service(),(QMediaService *) mockAudioSourceService);
+}
+
+void tst_QAudioCaptureSource::testOptions()
+{
+ const QString codec(QLatin1String("mp3"));
+
+ QStringList options = mockAudioSourceService->mockAudioEncoderControl->supportedEncodingOptions(codec);
+ QVERIFY(options.count() == 1);
+ mockAudioSourceService->mockAudioEncoderControl->setEncodingOption(codec, options.first(),8000);
+ QVERIFY(mockAudioSourceService->mockAudioEncoderControl->encodingOption(codec, options.first()).toInt() == 8000);
+}
+
+void tst_QAudioCaptureSource::testDevices()
+{
+ QList<QString> devices = audiosource->audioInputs();
+ QVERIFY(devices.size() > 0);
+ QVERIFY(devices.at(0).compare("device1") == 0);
+ QVERIFY(audiosource->audioDescription("device1").compare("dev1 comment") == 0);
+ QVERIFY(audiosource->defaultAudioInput() == "device1");
+
+ QSignalSpy checkSignal(audiosource, SIGNAL(activeAudioInputChanged(QString)));
+ audiosource->setAudioInput("device2");
+ QVERIFY(audiosource->activeAudioInput().compare("device2") == 0);
+ QVERIFY(checkSignal.count() == 1);
+}
+
+QTEST_MAIN(tst_QAudioCaptureSource)
+
+#include "tst_qaudiocapturesource.moc"