diff options
Diffstat (limited to 'tests/auto/unit/multimediawidgets')
10 files changed, 982 insertions, 0 deletions
diff --git a/tests/auto/unit/multimediawidgets/CMakeLists.txt b/tests/auto/unit/multimediawidgets/CMakeLists.txt new file mode 100644 index 000000000..87adc0190 --- /dev/null +++ b/tests/auto/unit/multimediawidgets/CMakeLists.txt @@ -0,0 +1,13 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Generated from multimediawidgets.pro. + +add_subdirectory(qcamerawidgets) +add_subdirectory(qgraphicsvideoitem) +add_subdirectory(qmediaplayerwidgets) +add_subdirectory(qvideowidget) +if(QT_FEATURE_private_tests) +# add_subdirectory(qgraphicsvideoitem) +# add_subdirectory(qvideowidget) +endif() diff --git a/tests/auto/unit/multimediawidgets/qcamerawidgets/CMakeLists.txt b/tests/auto/unit/multimediawidgets/qcamerawidgets/CMakeLists.txt new file mode 100644 index 000000000..486f34690 --- /dev/null +++ b/tests/auto/unit/multimediawidgets/qcamerawidgets/CMakeLists.txt @@ -0,0 +1,22 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Generated from qcamerawidgets.pro. + +##################################################################### +## tst_qcamerawidgets Test: +##################################################################### + +qt_internal_add_test(tst_qcamerawidgets + SOURCES + tst_qcamerawidgets.cpp + INCLUDE_DIRECTORIES + ../../mockbackend + LIBRARIES + # Remove: L${CMAKE_CURRENT_SOURCE_DIR} + Qt::Gui + Qt::MultimediaPrivate + Qt::MultimediaWidgetsPrivate + Qt::Widgets + MockMultimediaPlugin +) diff --git a/tests/auto/unit/multimediawidgets/qcamerawidgets/tst_qcamerawidgets.cpp b/tests/auto/unit/multimediawidgets/qcamerawidgets/tst_qcamerawidgets.cpp new file mode 100644 index 000000000..6c31a4b66 --- /dev/null +++ b/tests/auto/unit/multimediawidgets/qcamerawidgets/tst_qcamerawidgets.cpp @@ -0,0 +1,114 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only + +#include <QtTest/QtTest> +#include <QDebug> + +#include <private/qplatformcamera_p.h> +#include <private/qplatformimagecapture_p.h> +#include <qmediacapturesession.h> +#include <qcamera.h> +#include <qimagecapture.h> +#include <qgraphicsvideoitem.h> +#include <qobject.h> +#include <qvideowidget.h> +#include <qvideosink.h> + +#include "qmockmediacapturesession.h" +#include "qmockintegration.h" + +QT_USE_NAMESPACE + +Q_ENABLE_MOCK_MULTIMEDIA_PLUGIN + +class tst_QCameraWidgets: public QObject +{ + Q_OBJECT + +public slots: + void initTestCase(); + void cleanupTestCase(); + +private slots: + void testCameraEncodingProperyChange(); + void testSetVideoOutput(); +}; + +void tst_QCameraWidgets::initTestCase() +{ +} + + +void tst_QCameraWidgets::cleanupTestCase() +{ +} + +void tst_QCameraWidgets::testCameraEncodingProperyChange() +{ + QMediaCaptureSession session; + QCamera camera; + QImageCapture imageCapture; + session.setCamera(&camera); + session.setImageCapture(&imageCapture); + + QSignalSpy activeChangedSignal(&camera, &QCamera::activeChanged); + + camera.start(); + QCOMPARE(camera.isActive(), true); + + QCOMPARE(activeChangedSignal.size(), 1); +} + +void tst_QCameraWidgets::testSetVideoOutput() +{ + QVideoWidget widget; + QGraphicsVideoItem item; + QVideoSink surface; + QMediaCaptureSession session; + + session.setVideoOutput(&widget); + QVERIFY(session.videoSink() == widget.videoSink()); + QVERIFY(session.videoOutput() == &widget); + + session.setVideoOutput(&item); + QVERIFY(session.videoSink() == item.videoSink()); + QVERIFY(session.videoOutput() == &item); + + session.setVideoOutput(nullptr); + QVERIFY(session.videoSink() == nullptr); + QVERIFY(session.videoOutput() == nullptr); + + session.setVideoOutput(&widget); + QVERIFY(session.videoSink() == widget.videoSink()); + QVERIFY(session.videoOutput() == &widget); + + session.setVideoOutput(nullptr); + QVERIFY(session.videoOutput() == nullptr); + + session.setVideoOutput(&surface); + QVERIFY(session.videoSink() == &surface); + QVERIFY(session.videoOutput() == &surface); + + session.setVideoSink(nullptr); + QVERIFY(session.videoSink() == nullptr); + QVERIFY(session.videoOutput() == nullptr); + + session.setVideoOutput(&surface); + QVERIFY(session.videoSink() == &surface); + QVERIFY(session.videoOutput() == &surface); + + session.setVideoSink(&surface); + QVERIFY(session.videoSink() == &surface); + QVERIFY(session.videoOutput() == nullptr); + + session.setVideoOutput(&widget); + QVERIFY(session.videoSink() == widget.videoSink()); + QVERIFY(session.videoOutput() == &widget); + + session.setVideoOutput(&surface); + QVERIFY(session.videoOutput() == &surface); +} + +QTEST_MAIN(tst_QCameraWidgets) + +#include "tst_qcamerawidgets.moc" diff --git a/tests/auto/unit/multimediawidgets/qgraphicsvideoitem/CMakeLists.txt b/tests/auto/unit/multimediawidgets/qgraphicsvideoitem/CMakeLists.txt new file mode 100644 index 000000000..599042725 --- /dev/null +++ b/tests/auto/unit/multimediawidgets/qgraphicsvideoitem/CMakeLists.txt @@ -0,0 +1,21 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Generated from qgraphicsvideoitem.pro. + +##################################################################### +## tst_qgraphicsvideoitem Test: +##################################################################### + +qt_internal_add_test(tst_qgraphicsvideoitem + SOURCES + tst_qgraphicsvideoitem.cpp + INCLUDE_DIRECTORIES + ../../mockbackend + LIBRARIES + Qt::Gui + Qt::MultimediaPrivate + Qt::MultimediaWidgetsPrivate + Qt::Widgets + MockMultimediaPlugin +) diff --git a/tests/auto/unit/multimediawidgets/qgraphicsvideoitem/tst_qgraphicsvideoitem.cpp b/tests/auto/unit/multimediawidgets/qgraphicsvideoitem/tst_qgraphicsvideoitem.cpp new file mode 100644 index 000000000..0cda11de1 --- /dev/null +++ b/tests/auto/unit/multimediawidgets/qgraphicsvideoitem/tst_qgraphicsvideoitem.cpp @@ -0,0 +1,389 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only + +#include <qtmultimediaglobal.h> +#include "qgraphicsvideoitem.h" +#include <QtTest/QtTest> + +#include <qvideosink.h> +#include <qvideoframeformat.h> +#include <qvideoframe.h> +#include <qmediaplayer.h> + +#include <QtWidgets/qapplication.h> +#include <QtWidgets/qgraphicsscene.h> +#include <QtWidgets/qgraphicsview.h> + +#include <qmockintegration.h> + +QT_USE_NAMESPACE + +Q_ENABLE_MOCK_MULTIMEDIA_PLUGIN + +class tst_QGraphicsVideoItem : public QObject +{ + Q_OBJECT +public slots: + void initTestCase(); + +private slots: + void nullObject(); + void playerDestroyed(); + + void show(); + + void aspectRatioMode(); + void offset(); + void size(); + void nativeSize_data(); + void nativeSize(); + + void boundingRect_data(); + void boundingRect(); + + void paint(); +}; + +class QtTestGraphicsVideoItem : public QGraphicsVideoItem +{ +public: + QtTestGraphicsVideoItem(QGraphicsItem *parent = nullptr) + : QGraphicsVideoItem(parent) + { + } + + void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = nullptr) override + { + ++m_paintCount; + + QTestEventLoop::instance().exitLoop(); + + QGraphicsVideoItem::paint(painter, option, widget); + } + + bool waitForPaint(int secs) + { + const int paintCount = m_paintCount; + + QTestEventLoop::instance().enterLoop(secs); + + return m_paintCount != paintCount; + } + + [[nodiscard]] int paintCount() const + { + return m_paintCount; + } + +private: + int m_paintCount = 0; +}; + +void tst_QGraphicsVideoItem::initTestCase() +{ +} + +void tst_QGraphicsVideoItem::nullObject() +{ + QGraphicsVideoItem item(nullptr); + + QVERIFY(item.boundingRect().isEmpty()); +} + +void tst_QGraphicsVideoItem::playerDestroyed() +{ + QGraphicsVideoItem item; + { + QMediaPlayer player; + player.setVideoOutput(&item); + } + + QVERIFY(item.boundingRect().isEmpty()); +} + +void tst_QGraphicsVideoItem::show() +{ + auto *item = new QtTestGraphicsVideoItem; + QMediaPlayer player; + player.setVideoOutput(item); + + // Graphics items are visible by default + item->hide(); + item->show(); + + QGraphicsScene graphicsScene; + graphicsScene.addItem(item); + QGraphicsView graphicsView(&graphicsScene); + graphicsView.show(); + + QVERIFY(item->paintCount() || item->waitForPaint(1)); + + QVERIFY(item->boundingRect().isEmpty()); + + // ### Ensure we get a correct bounding rect +// QVideoFrameFormat format(QSize(320,240),QVideoFrameFormat::Format_RGB32); +// QVERIFY(object.testService->rendererControl->surface()->start(format)); + +// QCoreApplication::processEvents(); +// QVERIFY(!item->boundingRect().isEmpty()); +} + +void tst_QGraphicsVideoItem::aspectRatioMode() +{ + QGraphicsVideoItem item; + + QCOMPARE(item.aspectRatioMode(), Qt::KeepAspectRatio); + + item.setAspectRatioMode(Qt::IgnoreAspectRatio); + QCOMPARE(item.aspectRatioMode(), Qt::IgnoreAspectRatio); + + item.setAspectRatioMode(Qt::KeepAspectRatioByExpanding); + QCOMPARE(item.aspectRatioMode(), Qt::KeepAspectRatioByExpanding); + + item.setAspectRatioMode(Qt::KeepAspectRatio); + QCOMPARE(item.aspectRatioMode(), Qt::KeepAspectRatio); +} + +void tst_QGraphicsVideoItem::offset() +{ + QGraphicsVideoItem item; + + QCOMPARE(item.offset(), QPointF(0, 0)); + + item.setOffset(QPointF(-32.4, 43.0)); + QCOMPARE(item.offset(), QPointF(-32.4, 43.0)); + + item.setOffset(QPointF(1, 1)); + QCOMPARE(item.offset(), QPointF(1, 1)); + + item.setOffset(QPointF(12, -30.4)); + QCOMPARE(item.offset(), QPointF(12, -30.4)); + + item.setOffset(QPointF(-90.4, -75)); + QCOMPARE(item.offset(), QPointF(-90.4, -75)); +} + +void tst_QGraphicsVideoItem::size() +{ + QGraphicsVideoItem item; + + QCOMPARE(item.size(), QSizeF(320, 240)); + + item.setSize(QSizeF(542.5, 436.3)); + QCOMPARE(item.size(), QSizeF(542.5, 436.3)); + + item.setSize(QSizeF(-43, 12)); + QCOMPARE(item.size(), QSizeF(0, 0)); + + item.setSize(QSizeF(54, -9)); + QCOMPARE(item.size(), QSizeF(0, 0)); + + item.setSize(QSizeF(-90, -65)); + QCOMPARE(item.size(), QSizeF(0, 0)); + + item.setSize(QSizeF(1000, 1000)); + QCOMPARE(item.size(), QSizeF(1000, 1000)); +} + +void tst_QGraphicsVideoItem::nativeSize_data() +{ + QTest::addColumn<QSize>("frameSize"); + QTest::addColumn<QRect>("viewport"); + QTest::addColumn<QSizeF>("nativeSize"); + + QTest::newRow("640x480") + << QSize(640, 480) + << QRect(0, 0, 640, 480) + << QSizeF(640, 480); + + QTest::newRow("800x600, (80,60, 640x480) viewport") + << QSize(800, 600) + << QRect(80, 60, 640, 480) + << QSizeF(640, 480); +} + +void tst_QGraphicsVideoItem::nativeSize() +{ + QFETCH(QSize, frameSize); + QFETCH(QRect, viewport); + QFETCH(QSizeF, nativeSize); + + QtTestGraphicsVideoItem item; + QMediaPlayer player; + player.setVideoOutput(&item); + + QCOMPARE(item.nativeSize(), QSizeF()); + + QSignalSpy spy(&item, &QGraphicsVideoItem::nativeSizeChanged); + + QVideoFrameFormat format(frameSize, QVideoFrameFormat::Format_ARGB8888); + format.setViewport(viewport); + QVideoFrame frame(format); + item.videoSink()->setVideoFrame(frame); + + QCoreApplication::processEvents(); + QCOMPARE(item.nativeSize(), nativeSize); + QCOMPARE(spy.size(), 1); + QCOMPARE(spy.last().first().toSizeF(), nativeSize); +} + +void tst_QGraphicsVideoItem::boundingRect_data() +{ + QTest::addColumn<QSize>("frameSize"); + QTest::addColumn<QPointF>("offset"); + QTest::addColumn<QSizeF>("size"); + QTest::addColumn<Qt::AspectRatioMode>("aspectRatioMode"); + QTest::addColumn<QRectF>("expectedRect"); + + + QTest::newRow("640x480: (0,0 640x480), Keep") + << QSize(640, 480) + << QPointF(0, 0) + << QSizeF(640, 480) + << Qt::KeepAspectRatio + << QRectF(0, 0, 640, 480); + + QTest::newRow("800x600, (0,0, 640x480), Keep") + << QSize(800, 600) + << QPointF(0, 0) + << QSizeF(640, 480) + << Qt::KeepAspectRatio + << QRectF(0, 0, 640, 480); + + QTest::newRow("800x600, (0,0, 640x480), KeepByExpanding") + << QSize(800, 600) + << QPointF(0, 0) + << QSizeF(640, 480) + << Qt::KeepAspectRatioByExpanding + << QRectF(0, 0, 640, 480); + + QTest::newRow("800x600, (0,0, 640x480), Ignore") + << QSize(800, 600) + << QPointF(0, 0) + << QSizeF(640, 480) + << Qt::IgnoreAspectRatio + << QRectF(0, 0, 640, 480); + + QTest::newRow("800x600, (100,100, 640x480), Keep") + << QSize(800, 600) + << QPointF(100, 100) + << QSizeF(640, 480) + << Qt::KeepAspectRatio + << QRectF(100, 100, 640, 480); + + QTest::newRow("800x600, (100,-100, 640x480), KeepByExpanding") + << QSize(800, 600) + << QPointF(100, -100) + << QSizeF(640, 480) + << Qt::KeepAspectRatioByExpanding + << QRectF(100, -100, 640, 480); + + QTest::newRow("800x600, (-100,-100, 640x480), Ignore") + << QSize(800, 600) + << QPointF(-100, -100) + << QSizeF(640, 480) + << Qt::IgnoreAspectRatio + << QRectF(-100, -100, 640, 480); + + QTest::newRow("800x600, (0,0, 1920x1024), Keep") + << QSize(800, 600) + << QPointF(0, 0) + << QSizeF(1920, 1024) + << Qt::KeepAspectRatio + << QRectF(832.0 / 3, 0, 4096.0 / 3, 1024); + + QTest::newRow("800x600, (0,0, 1920x1024), KeepByExpanding") + << QSize(800, 600) + << QPointF(0, 0) + << QSizeF(1920, 1024) + << Qt::KeepAspectRatioByExpanding + << QRectF(0, 0, 1920, 1024); + + QTest::newRow("800x600, (0,0, 1920x1024), Ignore") + << QSize(800, 600) + << QPointF(0, 0) + << QSizeF(1920, 1024) + << Qt::IgnoreAspectRatio + << QRectF(0, 0, 1920, 1024); + + QTest::newRow("800x600, (100,100, 1920x1024), Keep") + << QSize(800, 600) + << QPointF(100, 100) + << QSizeF(1920, 1024) + << Qt::KeepAspectRatio + << QRectF(100 + 832.0 / 3, 100, 4096.0 / 3, 1024); + + QTest::newRow("800x600, (100,-100, 1920x1024), KeepByExpanding") + << QSize(800, 600) + << QPointF(100, -100) + << QSizeF(1920, 1024) + << Qt::KeepAspectRatioByExpanding + << QRectF(100, -100, 1920, 1024); + + QTest::newRow("800x600, (-100,-100, 1920x1024), Ignore") + << QSize(800, 600) + << QPointF(-100, -100) + << QSizeF(1920, 1024) + << Qt::IgnoreAspectRatio + << QRectF(-100, -100, 1920, 1024); +} + +void tst_QGraphicsVideoItem::boundingRect() +{ + QFETCH(QSize, frameSize); + QFETCH(QPointF, offset); + QFETCH(QSizeF, size); + QFETCH(Qt::AspectRatioMode, aspectRatioMode); + QFETCH(QRectF, expectedRect); + + QtTestGraphicsVideoItem item; + QMediaPlayer player; + player.setVideoOutput(&item); + + item.setOffset(offset); + item.setSize(size); + item.setAspectRatioMode(aspectRatioMode); + + QVideoFrameFormat format(frameSize, QVideoFrameFormat::Format_ARGB8888); + QVideoFrame frame(format); + item.videoSink()->setVideoFrame(frame); + + QCoreApplication::processEvents(); + QCOMPARE(item.boundingRect(), expectedRect); +} + +static const uchar rgb32ImageData[] = +{ + 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, + 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00 +}; + +void tst_QGraphicsVideoItem::paint() +{ + auto *item = new QtTestGraphicsVideoItem; + QMediaPlayer player; + player.setVideoOutput(item); + + QGraphicsScene graphicsScene; + graphicsScene.addItem(item); + QGraphicsView graphicsView(&graphicsScene); + graphicsView.show(); + QVERIFY(item->paintCount() || item->waitForPaint(1)); + + auto *sink = item->videoSink(); + Q_ASSERT(sink); + + QVideoFrameFormat format(QSize(2, 2), QVideoFrameFormat::Format_XRGB8888); + QVideoFrame frame(format); + frame.map(QtVideo::MapMode::WriteOnly); + memcpy(frame.bits(0), rgb32ImageData, frame.mappedBytes(0)); + frame.unmap(); + + sink->setVideoFrame(frame); + + QVERIFY(item->waitForPaint(1)); +} + +QTEST_MAIN(tst_QGraphicsVideoItem) + +#include "tst_qgraphicsvideoitem.moc" diff --git a/tests/auto/unit/multimediawidgets/qmediaplayerwidgets/CMakeLists.txt b/tests/auto/unit/multimediawidgets/qmediaplayerwidgets/CMakeLists.txt new file mode 100644 index 000000000..7c54e67b9 --- /dev/null +++ b/tests/auto/unit/multimediawidgets/qmediaplayerwidgets/CMakeLists.txt @@ -0,0 +1,23 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Generated from qmediaplayerwidgets.pro. + +##################################################################### +## tst_qmediaplayerwidgets Test: +##################################################################### + +qt_internal_add_test(tst_qmediaplayerwidgets + SOURCES + tst_qmediaplayerwidgets.cpp + INCLUDE_DIRECTORIES + ../../mockbackend + LIBRARIES + # Remove: L${CMAKE_CURRENT_SOURCE_DIR} + Qt::Gui + Qt::MultimediaPrivate + Qt::MultimediaWidgetsPrivate + Qt::Network + Qt::Widgets + MockMultimediaPlugin +) diff --git a/tests/auto/unit/multimediawidgets/qmediaplayerwidgets/tst_qmediaplayerwidgets.cpp b/tests/auto/unit/multimediawidgets/qmediaplayerwidgets/tst_qmediaplayerwidgets.cpp new file mode 100644 index 000000000..e0f23d477 --- /dev/null +++ b/tests/auto/unit/multimediawidgets/qmediaplayerwidgets/tst_qmediaplayerwidgets.cpp @@ -0,0 +1,107 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only + +#include <QtTest/QtTest> +#include <QtCore/qdebug.h> +#include <QtCore/qbuffer.h> + +#include <qgraphicsvideoitem.h> +#include <qvideosink.h> +#include <qmediaplayer.h> +#include <private/qplatformmediaplayer_p.h> + +#include "qvideosink.h" +#include "qmockintegration.h" + +QT_USE_NAMESPACE + +Q_ENABLE_MOCK_MULTIMEDIA_PLUGIN + +class tst_QMediaPlayerWidgets: public QObject +{ + Q_OBJECT + +private slots: + void testSetVideoOutput(); + void testSetVideoOutputNoService(); + void testSetVideoOutputNoControl(); +}; + +void tst_QMediaPlayerWidgets::testSetVideoOutput() +{ + QVideoWidget widget; + QGraphicsVideoItem item; + QVideoSink surface; + + QMediaPlayer player; + + player.setVideoOutput(&widget); +// QVERIFY(widget.mediaSource() == &player); + + player.setVideoOutput(&item); +// QVERIFY(widget.mediaSource() == nullptr); +// QVERIFY(item.mediaSource() == &player); + + player.setVideoOutput(reinterpret_cast<QVideoWidget *>(0)); +// QVERIFY(item.mediaSource() == nullptr); + + player.setVideoOutput(&widget); +// QVERIFY(widget.mediaSource() == &player); + + player.setVideoOutput(reinterpret_cast<QGraphicsVideoItem *>(0)); +// QVERIFY(widget.mediaSource() == nullptr); + + player.setVideoOutput(&surface); +// QVERIFY(mockService->rendererControl->surface() == &surface); + + player.setVideoOutput(reinterpret_cast<QVideoSink *>(0)); +// QVERIFY(mockService->rendererControl->surface() == nullptr); + + player.setVideoOutput(&surface); +// QVERIFY(mockService->rendererControl->surface() == &surface); + + player.setVideoOutput(&widget); +// QVERIFY(mockService->rendererControl->surface() == nullptr); +// QVERIFY(widget.mediaSource() == &player); + + player.setVideoOutput(&surface); +// QVERIFY(mockService->rendererControl->surface() == &surface); +// QVERIFY(widget.mediaSource() == nullptr); +} + + +void tst_QMediaPlayerWidgets::testSetVideoOutputNoService() +{ + QVideoWidget widget; + QGraphicsVideoItem item; + QVideoSink surface; + + QMockIntegration::instance()->setFlags(QMockIntegration::NoPlayerInterface); + QMediaPlayer player; + QMockIntegration::instance()->setFlags({}); + + player.setVideoOutput(&widget); + + player.setVideoOutput(&item); + + player.setVideoOutput(&surface); + // Nothing we can verify here other than it doesn't assert. +} + +void tst_QMediaPlayerWidgets::testSetVideoOutputNoControl() +{ + QVideoWidget widget; + QGraphicsVideoItem item; + QVideoSink surface; + + QMediaPlayer player; + + player.setVideoOutput(&widget); + + player.setVideoOutput(&item); + + player.setVideoOutput(&surface); +} + +QTEST_MAIN(tst_QMediaPlayerWidgets) +#include "tst_qmediaplayerwidgets.moc" diff --git a/tests/auto/unit/multimediawidgets/qvideowidget/BLACKLIST b/tests/auto/unit/multimediawidgets/qvideowidget/BLACKLIST new file mode 100644 index 000000000..2ce9e48fa --- /dev/null +++ b/tests/auto/unit/multimediawidgets/qvideowidget/BLACKLIST @@ -0,0 +1,3 @@ +# QTBUG-110453 +[fullScreen] +android diff --git a/tests/auto/unit/multimediawidgets/qvideowidget/CMakeLists.txt b/tests/auto/unit/multimediawidgets/qvideowidget/CMakeLists.txt new file mode 100644 index 000000000..b179b0b3b --- /dev/null +++ b/tests/auto/unit/multimediawidgets/qvideowidget/CMakeLists.txt @@ -0,0 +1,21 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Generated from qvideowidget.pro. + +##################################################################### +## tst_qvideowidget Test: +##################################################################### + +qt_internal_add_test(tst_qvideowidget + SOURCES + tst_qvideowidget.cpp + INCLUDE_DIRECTORIES + ../../mockbackend + LIBRARIES + Qt::Gui + Qt::MultimediaPrivate + Qt::MultimediaWidgetsPrivate + Qt::Widgets + MockMultimediaPlugin +) diff --git a/tests/auto/unit/multimediawidgets/qvideowidget/tst_qvideowidget.cpp b/tests/auto/unit/multimediawidgets/qvideowidget/tst_qvideowidget.cpp new file mode 100644 index 000000000..b999020a4 --- /dev/null +++ b/tests/auto/unit/multimediawidgets/qvideowidget/tst_qvideowidget.cpp @@ -0,0 +1,269 @@ +// Copyright (C) 2021 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only + +#include <qtmultimediaglobal.h> +#include <QtTest/QtTest> + +#include "qvideowidget.h" +#include "qvideosink.h" +#include "qmediaplayer.h" + +#include <qvideoframeformat.h> +#include <qvideoframe.h> + +#include <QtWidgets/qapplication.h> + +#include <qmockintegration.h> +#include <qmockvideosink.h> + +QT_USE_NAMESPACE + +Q_ENABLE_MOCK_MULTIMEDIA_PLUGIN + +class tst_QVideoWidget : public QObject +{ + Q_OBJECT +public slots: + void initTestCase(); + +private slots: + void nullObject(); + + void show(); + void fullScreen(); + void aspectRatio(); + void sizeHint_data(); + void sizeHint(); +#if 0 + void brightness_data() { color_data(); } + void brightness(); + void contrast_data() { color_data(); } + void contrast(); + void hue_data() { color_data(); } + void hue(); + void saturation_data() { color_data(); } + void saturation(); +#endif + + void paint(); + +private: +// void color_data(); +}; + +class QtTestVideoWidget : public QVideoWidget +{ +public: + QtTestVideoWidget(QWidget *parent = nullptr) + : QVideoWidget(parent) + { + resize(320, 240); + } +}; + +void tst_QVideoWidget::initTestCase() +{ +#ifdef Q_OS_MACOS + if (qEnvironmentVariable("QTEST_ENVIRONMENT").toLower() == "ci") + QSKIP("SKIP on macOS CI since metal is not supported, otherwise it often crashes. To be " + "fixed."); +#endif +} + +void tst_QVideoWidget::nullObject() +{ + QtTestVideoWidget widget; + + widget.show(); + QVERIFY(QTest::qWaitForWindowExposed(&widget)); + + widget.setFullScreen(true); + QVERIFY(QTest::qWaitForWindowExposed(&widget)); + QCOMPARE(widget.isFullScreen(), true); + + widget.setAspectRatioMode(Qt::IgnoreAspectRatio); + QCOMPARE(widget.aspectRatioMode(), Qt::IgnoreAspectRatio); +} + + + +void tst_QVideoWidget::show() +{ + QtTestVideoWidget widget; + + widget.show(); + QVERIFY(QTest::qWaitForWindowExposed(&widget)); + + widget.resize(640, 480); + QCOMPARE(widget.size(), QSize(640, 480)); + + widget.move(10, 10); + QCOMPARE(widget.size(), QSize(640, 480)); + + widget.hide(); +} + +void tst_QVideoWidget::aspectRatio() +{ + QtTestVideoWidget widget; + QMediaPlayer player; + player.setVideoOutput(&widget); + + // Test the aspect ratio defaults to keeping the aspect ratio. + QCOMPARE(widget.aspectRatioMode(), Qt::KeepAspectRatio); + + // Test the control has been informed of the aspect ratio change, post show. + widget.show(); + QVERIFY(QTest::qWaitForWindowExposed(&widget)); + QCOMPARE(widget.aspectRatioMode(), Qt::KeepAspectRatio); + + // Test an aspect ratio change is enforced immediately while visible. + widget.setAspectRatioMode(Qt::IgnoreAspectRatio); + QCOMPARE(widget.aspectRatioMode(), Qt::IgnoreAspectRatio); + + // Test an aspect ratio set while not visible is respected. + widget.hide(); + widget.setAspectRatioMode(Qt::KeepAspectRatio); + QCOMPARE(widget.aspectRatioMode(), Qt::KeepAspectRatio); + widget.show(); + QCOMPARE(widget.aspectRatioMode(), Qt::KeepAspectRatio); +} + +void tst_QVideoWidget::sizeHint_data() +{ +#ifdef Q_OS_MAC + QSKIP("QTBUG-26481 - Crashes on Mac"); +#endif + + QTest::addColumn<QSize>("frameSize"); + QTest::addColumn<QRect>("viewport"); + QTest::addColumn<QSize>("expectedSize"); + + QTest::newRow("640x480") + << QSize(640, 480) + << QRect(0, 0, 640, 480) + << QSize(640, 480); + +// QTest::newRow("800x600, (80,60, 640x480) viewport") +// << QSize(800, 600) +// << QRect(80, 60, 640, 480) +// << QSize(640, 480); +} + +void tst_QVideoWidget::sizeHint() +{ +#ifdef Q_OS_MAC + QSKIP("QTBUG-26481 - Crashes on Mac"); +#endif + + QFETCH(QSize, frameSize); +// QFETCH(QRect, viewport); + QFETCH(QSize, expectedSize); + + QtTestVideoWidget widget; + QMediaPlayer player; + + player.setVideoOutput(&widget); + auto mockSink = QMockIntegration::instance()->lastVideoSink(); + + widget.show(); + QVERIFY(QTest::qWaitForWindowExposed(&widget)); + mockSink->setNativeSize(frameSize); + + QCOMPARE(widget.sizeHint(), expectedSize); +} + + +void tst_QVideoWidget::fullScreen() +{ + QtTestVideoWidget widget; + QMediaPlayer player; + player.setVideoOutput(&widget); + widget.showNormal(); + QVERIFY(QTest::qWaitForWindowExposed(&widget)); + + Qt::WindowFlags windowFlags = widget.windowFlags(); + + QSignalSpy spy(&widget, &QVideoWidget::fullScreenChanged); + + // Test showing full screen with setFullScreen(true). + widget.setFullScreen(true); + QVERIFY(QTest::qWaitForWindowExposed(&widget)); + QCOMPARE(widget.isFullScreen(), true); + QCOMPARE(spy.size(), 1); + QCOMPARE(spy.value(0).value(0).toBool(), true); + + // Test returning to normal with setFullScreen(false). + widget.setFullScreen(false); + QVERIFY(QTest::qWaitForWindowExposed(&widget)); + QCOMPARE(widget.isFullScreen(), false); + QCOMPARE(spy.size(), 2); + QCOMPARE(spy.value(1).value(0).toBool(), false); + QCOMPARE(widget.windowFlags(), windowFlags); + + // Test showing full screen with showFullScreen(). + widget.showFullScreen(); + QVERIFY(QTest::qWaitForWindowExposed(&widget)); + QCOMPARE(widget.isFullScreen(), true); + QCOMPARE(spy.size(), 3); + QCOMPARE(spy.value(2).value(0).toBool(), true); + + // Test returning to normal with showNormal(). + widget.showNormal(); + QVERIFY(QTest::qWaitForWindowExposed(&widget)); + QCOMPARE(widget.isFullScreen(), false); + QCOMPARE(spy.size(), 4); + QCOMPARE(spy.value(3).value(0).toBool(), false); + QCOMPARE(widget.windowFlags(), windowFlags); + + // Test setFullScreen(false) and showNormal() do nothing when isFullScreen() == false. + widget.setFullScreen(false); + QCOMPARE(widget.isFullScreen(), false); + QCOMPARE(spy.size(), 4); + widget.showNormal(); + QVERIFY(QTest::qWaitForWindowExposed(&widget)); + QCOMPARE(widget.isFullScreen(), false); + QCOMPARE(spy.size(), 4); + + // Test setFullScreen(true) and showFullScreen() do nothing when isFullScreen() == true. + widget.showFullScreen(); + QVERIFY(QTest::qWaitForWindowExposed(&widget)); + widget.setFullScreen(true); + QCOMPARE(widget.isFullScreen(), true); + QCOMPARE(spy.size(), 5); + widget.showFullScreen(); + QCOMPARE(widget.isFullScreen(), true); + QCOMPARE(spy.size(), 5); +} + +static const uchar rgb32ImageData[] = +{ + 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, + 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00 +}; + +void tst_QVideoWidget::paint() +{ + QtTestVideoWidget widget; + QMediaPlayer player; + player.setVideoOutput(&widget); + widget.resize(640,480); + widget.show(); + QVERIFY(QTest::qWaitForWindowExposed(&widget)); + + QVideoFrameFormat format(QSize(2, 2), QVideoFrameFormat::Format_XRGB8888); + QVideoFrame frame(format); + QVERIFY(frame.map(QtVideo::MapMode::ReadWrite)); + uchar *data = frame.bits(0); + memcpy(data, rgb32ImageData, sizeof(rgb32ImageData)); + frame.unmap(); + + auto *sink = widget.videoSink(); + emit sink->setVideoFrame(frame); + + QCoreApplication::processEvents(QEventLoop::AllEvents); +} + +QTEST_MAIN(tst_QVideoWidget) + +#include "tst_qvideowidget.moc" |