Declare more metatypes and debug operators.

Nearly all of the multimedia metatypes used in the auto tests are now declared properly, and a large number of the types have debug operators as well. Removed the superfluous decls as well. Change-Id: I42cfe37562db0c71d9811b4577fc326a3326ccc9 Reviewed-by: Jonas Rabbe <jonas.rabbe@nokia.com>
2011-11-01 12:46:48 +10:00
parent 6a3a442ea6
commit 7dfb883df6
30 changed files with 720 additions and 168 deletions
--- a/tests/auto/multimedia.pro
+++ b/tests/auto/multimedia.pro
@@ -7,6 +7,7 @@ SUBDIRS += \
    qaudiodeviceinfo \
    qaudioformat \
    qaudioinput \
+    qaudionamespace \
    qaudiooutput \
    qmediabindableinterface \
    qmediacontainercontrol \
--- a/tests/auto/qabstractvideobuffer/tst_qabstractvideobuffer.cpp
+++ b/tests/auto/qabstractvideobuffer/tst_qabstractvideobuffer.cpp
@@ -45,6 +45,12 @@

 #include <qabstractvideobuffer.h>

+// Adds an enum, and the stringized version
+#define ADD_ENUM_TEST(x) \
+    QTest::newRow(#x) \
+        << QAbstractVideoBuffer::x \
+    << QString(QLatin1String(#x));
+
 class tst_QAbstractVideoBuffer : public QObject
 {
    Q_OBJECT
@@ -63,6 +69,8 @@ private slots:
    void handleType();
    void handle();
    void mapMode();
+    void mapModeDebug_data();
+    void mapModeDebug();
 };

 class QtTestVideoBuffer : public QAbstractVideoBuffer
@@ -100,21 +108,16 @@ void tst_QAbstractVideoBuffer::cleanup()
 {
 }

-#define ADD_HANDLE_TEST(x) \
-    QTest::newRow(#x) \
-        << QAbstractVideoBuffer::x \
-    << QString(QLatin1String(#x));
-
 void tst_QAbstractVideoBuffer::handleType_data()
 {
    QTest::addColumn<QAbstractVideoBuffer::HandleType>("type");
    QTest::addColumn<QString>("stringized");

-    ADD_HANDLE_TEST(NoHandle);
-    ADD_HANDLE_TEST(GLTextureHandle);
-    ADD_HANDLE_TEST(XvShmImageHandle);
-    ADD_HANDLE_TEST(QPixmapHandle);
-    ADD_HANDLE_TEST(CoreImageHandle);
+    ADD_ENUM_TEST(NoHandle);
+    ADD_ENUM_TEST(GLTextureHandle);
+    ADD_ENUM_TEST(XvShmImageHandle);
+    ADD_ENUM_TEST(QPixmapHandle);
+    ADD_ENUM_TEST(CoreImageHandle);

    // User handles are different

@@ -150,6 +153,26 @@ void tst_QAbstractVideoBuffer::mapMode()
    QVERIFY2(maptest.mapMode() == QAbstractVideoBuffer::ReadWrite, "ReadWrite Failed");
 }

+void tst_QAbstractVideoBuffer::mapModeDebug_data()
+{
+    QTest::addColumn<QAbstractVideoBuffer::MapMode>("mapMode");
+    QTest::addColumn<QString>("stringized");
+
+    ADD_ENUM_TEST(NotMapped);
+    ADD_ENUM_TEST(ReadOnly);
+    ADD_ENUM_TEST(WriteOnly);
+    ADD_ENUM_TEST(ReadWrite);
+}
+
+void tst_QAbstractVideoBuffer::mapModeDebug()
+{
+    QFETCH(QAbstractVideoBuffer::MapMode, mapMode);
+    QFETCH(QString, stringized);
+
+    QTest::ignoreMessage(QtDebugMsg, stringized.toLatin1().constData());
+    qDebug() << mapMode;
+}
+
 QTEST_MAIN(tst_QAbstractVideoBuffer)

 #include "tst_qabstractvideobuffer.moc"
--- a/tests/auto/qabstractvideosurface/tst_qabstractvideosurface.cpp
+++ b/tests/auto/qabstractvideosurface/tst_qabstractvideosurface.cpp
@@ -74,8 +74,6 @@ private slots:
 typedef QMap<QAbstractVideoBuffer::HandleType, QVideoFrame::PixelFormat> SupportedFormatMap;

 Q_DECLARE_METATYPE(SupportedFormatMap)
-Q_DECLARE_METATYPE(QVideoSurfaceFormat)
-Q_DECLARE_METATYPE(QAbstractVideoSurface::Error);

 class QtTestVideoSurface : public QAbstractVideoSurface
 {
@@ -144,21 +142,33 @@ void tst_QAbstractVideoSurface::setError()
    QtTestVideoSurface surface;

    QCOMPARE(surface.error(), QAbstractVideoSurface::NoError);
+    QTest::ignoreMessage(QtDebugMsg, "NoError");
+    qDebug() << QAbstractVideoSurface::NoError;

    surface.setError(QAbstractVideoSurface::StoppedError);
    QCOMPARE(surface.error(), QAbstractVideoSurface::StoppedError);
+    QTest::ignoreMessage(QtDebugMsg, "StoppedError");
+    qDebug() << QAbstractVideoSurface::StoppedError;

    surface.setError(QAbstractVideoSurface::ResourceError);
    QCOMPARE(surface.error(), QAbstractVideoSurface::ResourceError);
+    QTest::ignoreMessage(QtDebugMsg, "ResourceError");
+    qDebug() << QAbstractVideoSurface::ResourceError;

    surface.setError(QAbstractVideoSurface::NoError);
    QCOMPARE(surface.error(), QAbstractVideoSurface::NoError);
+    QTest::ignoreMessage(QtDebugMsg, "NoError");
+    qDebug() << QAbstractVideoSurface::NoError;

    surface.setError(QAbstractVideoSurface::UnsupportedFormatError);
    QCOMPARE(surface.error(), QAbstractVideoSurface::UnsupportedFormatError);
+    QTest::ignoreMessage(QtDebugMsg, "UnsupportedFormatError");
+    qDebug() << QAbstractVideoSurface::UnsupportedFormatError;

    surface.setError(QAbstractVideoSurface::IncorrectFormatError);
    QCOMPARE(surface.error(), QAbstractVideoSurface::IncorrectFormatError);
+    QTest::ignoreMessage(QtDebugMsg, "IncorrectFormatError");
+    qDebug() << QAbstractVideoSurface::IncorrectFormatError;
 }

 void tst_QAbstractVideoSurface::isFormatSupported_data()
--- a/tests/auto/qaudioformat/tst_qaudioformat.cpp
+++ b/tests/auto/qaudioformat/tst_qaudioformat.cpp
@@ -67,6 +67,9 @@ private slots:
    void checkAssignment();
    void checkSampleRate();
    void checkChannelCount();
+
+    void debugOperator();
+    void debugOperator_data();
 };

 void tst_QAudioFormat::checkNull()
@@ -114,8 +117,14 @@ void tst_QAudioFormat::checkByteOrder()
    audioFormat.setByteOrder(QAudioFormat::LittleEndian);
    QVERIFY(audioFormat.byteOrder() == QAudioFormat::LittleEndian);

+    QTest::ignoreMessage(QtDebugMsg, "LittleEndian");
+    qDebug() << QAudioFormat::LittleEndian;
+
    audioFormat.setByteOrder(QAudioFormat::BigEndian);
    QVERIFY(audioFormat.byteOrder() == QAudioFormat::BigEndian);
+
+    QTest::ignoreMessage(QtDebugMsg, "BigEndian");
+    qDebug() << QAudioFormat::BigEndian;
 }

 void tst_QAudioFormat::checkSampleType()
@@ -123,12 +132,23 @@ void tst_QAudioFormat::checkSampleType()
    QAudioFormat audioFormat;
    audioFormat.setSampleType(QAudioFormat::SignedInt);
    QVERIFY(audioFormat.sampleType() == QAudioFormat::SignedInt);
+    QTest::ignoreMessage(QtDebugMsg, "SignedInt");
+    qDebug() << QAudioFormat::SignedInt;

    audioFormat.setSampleType(QAudioFormat::Unknown);
    QVERIFY(audioFormat.sampleType() == QAudioFormat::Unknown);
+    QTest::ignoreMessage(QtDebugMsg, "Unknown");
+    qDebug() << QAudioFormat::Unknown;
+
+    audioFormat.setSampleType(QAudioFormat::UnSignedInt);
+    QVERIFY(audioFormat.sampleType() == QAudioFormat::UnSignedInt);
+    QTest::ignoreMessage(QtDebugMsg, "UnSignedInt");
+    qDebug() << QAudioFormat::UnSignedInt;

    audioFormat.setSampleType(QAudioFormat::Float);
    QVERIFY(audioFormat.sampleType() == QAudioFormat::Float);
+    QTest::ignoreMessage(QtDebugMsg, "Float");
+    qDebug() << QAudioFormat::Float;
 }

 void tst_QAudioFormat::checkEquality()
@@ -210,6 +230,42 @@ void tst_QAudioFormat::checkChannelCount()
    QVERIFY(audioFormat.channels() == 5);
 }

+void tst_QAudioFormat::debugOperator_data()
+{
+    QTest::addColumn<QAudioFormat>("format");
+    QTest::addColumn<QString>("stringized");
+
+    // A small sampling
+    QAudioFormat f;
+    QTest::newRow("plain") << f << QString::fromLatin1("QAudioFormat(-1Hz, -1bit, channelCount=-1, sampleType=Unknown, byteOrder=LittleEndian, codec=\"\") ");
+
+    f.setSampleRate(22050);
+    f.setByteOrder(QAudioFormat::LittleEndian);
+    f.setChannelCount(4);
+    f.setCodec("audio/pcm");
+    f.setSampleType(QAudioFormat::Float);
+
+    QTest::newRow("float") << f << QString::fromLatin1("QAudioFormat(22050Hz, -1bit, channelCount=4, sampleType=Float, byteOrder=LittleEndian, codec=\"audio/pcm\") ");
+
+    f.setSampleType(QAudioFormat::UnSignedInt);
+    QTest::newRow("unsigned") << f << QString::fromLatin1("QAudioFormat(22050Hz, -1bit, channelCount=4, sampleType=UnSignedInt, byteOrder=LittleEndian, codec=\"audio/pcm\") ");
+
+    f.setSampleRate(44100);
+    QTest::newRow("44.1 unsigned") << f << QString::fromLatin1("QAudioFormat(44100Hz, -1bit, channelCount=4, sampleType=UnSignedInt, byteOrder=LittleEndian, codec=\"audio/pcm\") ");
+
+    f.setByteOrder(QAudioFormat::BigEndian);
+    QTest::newRow("44.1 big unsigned") << f << QString::fromLatin1("QAudioFormat(44100Hz, -1bit, channelCount=4, sampleType=UnSignedInt, byteOrder=BigEndian, codec=\"audio/pcm\") ");
+}
+
+void tst_QAudioFormat::debugOperator()
+{
+    QFETCH(QAudioFormat, format);
+    QFETCH(QString, stringized);
+
+    QTest::ignoreMessage(QtDebugMsg, stringized.toLatin1().constData());
+    qDebug() << format;
+}
+
 QTEST_MAIN(tst_QAudioFormat)

 #include "tst_qaudioformat.moc"
--- a/tests/auto/qaudioinput/tst_qaudioinput.cpp
+++ b/tests/auto/qaudioinput/tst_qaudioinput.cpp
@@ -68,8 +68,6 @@
    } while(0)
 #endif

-Q_DECLARE_METATYPE(QAudioFormat)
-
 class tst_QAudioInput : public QObject
 {
    Q_OBJECT
--- a/tests/auto/qaudionamespace/qaudionamespace.pro
+++ b/tests/auto/qaudionamespace/qaudionamespace.pro
@@ -0,0 +1,8 @@
+CONFIG += testcase
+TARGET = tst_qaudionamespace
+
+QT += core multimedia-private testlib
+CONFIG += no_private_qt_headers_warning
+
+SOURCES += tst_qaudionamespace.cpp
+
--- a/tests/auto/qaudionamespace/tst_qaudionamespace.cpp
+++ b/tests/auto/qaudionamespace/tst_qaudionamespace.cpp
@@ -0,0 +1,127 @@
+/****************************************************************************
+**
+** 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 test suite of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** GNU Lesser General Public License Usage
+** 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.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU General
+** Public License version 3.0 as published by the Free Software Foundation
+** and appearing in the file LICENSE.GPL included in the packaging of this
+** file. Please review the following information to ensure the GNU General
+** Public License version 3.0 requirements will be met:
+** http://www.gnu.org/copyleft/gpl.html.
+**
+** Other Usage
+** Alternatively, this file may be used in accordance with the terms and
+** conditions contained in a signed written agreement between you and Nokia.
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+//TESTED_COMPONENT=src/multimedia
+
+#include <QtTest/QtTest>
+
+#include "qaudio.h"
+
+// Adds an enum, and the stringized version
+#define ADD_ENUM_TEST(x) \
+    QTest::newRow(#x) \
+        << QAudio::x \
+    << QString(QLatin1String(#x));
+
+class tst_QAudioNamespace : public QObject
+{
+    Q_OBJECT
+
+private slots:
+    void debugError();
+    void debugError_data();
+    void debugState();
+    void debugState_data();
+    void debugMode();
+    void debugMode_data();
+};
+
+void tst_QAudioNamespace::debugError_data()
+{
+    QTest::addColumn<QAudio::Error>("error");
+    QTest::addColumn<QString>("stringized");
+
+    ADD_ENUM_TEST(NoError);
+    ADD_ENUM_TEST(OpenError);
+    ADD_ENUM_TEST(IOError);
+    ADD_ENUM_TEST(UnderrunError);
+    ADD_ENUM_TEST(FatalError);
+}
+
+void tst_QAudioNamespace::debugError()
+{
+    QFETCH(QAudio::Error, error);
+    QFETCH(QString, stringized);
+
+    QTest::ignoreMessage(QtDebugMsg, stringized.toLatin1().constData());
+    qDebug() << error;
+}
+
+void tst_QAudioNamespace::debugState_data()
+{
+    QTest::addColumn<QAudio::State>("state");
+    QTest::addColumn<QString>("stringized");
+
+    ADD_ENUM_TEST(ActiveState);
+    ADD_ENUM_TEST(SuspendedState);
+    ADD_ENUM_TEST(StoppedState);
+    ADD_ENUM_TEST(IdleState);
+}
+
+void tst_QAudioNamespace::debugState()
+{
+    QFETCH(QAudio::State, state);
+    QFETCH(QString, stringized);
+
+    QTest::ignoreMessage(QtDebugMsg, stringized.toLatin1().constData());
+    qDebug() << state;
+}
+
+void tst_QAudioNamespace::debugMode_data()
+{
+    QTest::addColumn<QAudio::Mode>("mode");
+    QTest::addColumn<QString>("stringized");
+
+    ADD_ENUM_TEST(AudioInput);
+    ADD_ENUM_TEST(AudioOutput);
+}
+
+void tst_QAudioNamespace::debugMode()
+{
+    QFETCH(QAudio::Mode, mode);
+    QFETCH(QString, stringized);
+
+    QTest::ignoreMessage(QtDebugMsg, stringized.toLatin1().constData());
+    qDebug() << mode;
+}
+QTEST_MAIN(tst_QAudioNamespace)
+
+#include "tst_qaudionamespace.moc"
--- a/tests/auto/qaudiooutput/tst_qaudiooutput.cpp
+++ b/tests/auto/qaudiooutput/tst_qaudiooutput.cpp
@@ -68,8 +68,6 @@
    } while(0)
 #endif

-Q_DECLARE_METATYPE(QAudioFormat)
-
 class tst_QAudioOutput : public QObject
 {
    Q_OBJECT
--- a/tests/auto/qcamerabackend/tst_qcamerabackend.cpp
+++ b/tests/auto/qcamerabackend/tst_qcamerabackend.cpp
@@ -120,9 +120,6 @@ QT_USE_NAMESPACE
 it may be less stable.
 */

-
-Q_DECLARE_METATYPE(QVideoFrame)
-
 class tst_QCameraBackend: public QObject
 {
    Q_OBJECT
--- a/tests/auto/qvideoframe/tst_qvideoframe.cpp
+++ b/tests/auto/qvideoframe/tst_qvideoframe.cpp
@@ -47,6 +47,13 @@
 #include <QtGui/QImage>
 #include <QtCore/QPointer>

+// Adds an enum, and the stringized version
+#define ADD_ENUM_TEST(x) \
+    QTest::newRow(#x) \
+        << QVideoFrame::x \
+    << QString(QLatin1String(#x));
+
+
 class tst_QVideoFrame : public QObject
 {
    Q_OBJECT
@@ -84,13 +91,21 @@ private slots:
    void formatConversion_data();
    void formatConversion();

+    void debugType_data();
+    void debugType();
+
+    void debug_data();
+    void debug();
+
+    void debugFormat_data();
+    void debugFormat();
+
    void isMapped();
    void isReadable();
    void isWritable();
 };

 Q_DECLARE_METATYPE(QImage::Format)
-Q_DECLARE_METATYPE(QVideoFrame)

 class QtTestVideoBuffer : public QObject, public QAbstractVideoBuffer
 {
@@ -963,6 +978,148 @@ void tst_QVideoFrame::isWritable()
    frame.unmap();
 }

+void tst_QVideoFrame::debugType_data()
+{
+    QTest::addColumn<QVideoFrame::FieldType>("fieldType");
+    QTest::addColumn<QString>("stringized");
+
+    ADD_ENUM_TEST(ProgressiveFrame);
+    ADD_ENUM_TEST(InterlacedFrame);
+    ADD_ENUM_TEST(TopField);
+    ADD_ENUM_TEST(BottomField);
+}
+
+void tst_QVideoFrame::debugType()
+{
+    QFETCH(QVideoFrame::FieldType, fieldType);
+    QFETCH(QString, stringized);
+
+    QTest::ignoreMessage(QtDebugMsg, stringized.toLatin1().constData());
+    qDebug() << fieldType;
+}
+
+void tst_QVideoFrame::debug_data()
+{
+    QTest::addColumn<QVideoFrame>("frame");
+    QTest::addColumn<QString>("stringized");
+
+    QVideoFrame f;
+    QTest::newRow("default") << f << QString::fromLatin1("QVideoFrame( QSize(-1, -1) , Format_Invalid, NoHandle, NotMapped, [no timestamp])");
+
+    QVideoFrame f2;
+    f2.setStartTime(12345);
+    f2.setEndTime(8000000000LL);
+    QTest::newRow("times") << f2 << QString::fromLatin1("QVideoFrame( QSize(-1, -1) , Format_Invalid, NoHandle, NotMapped, 0:00:00.12345 - 2:13:20.00)");
+
+    QVideoFrame f3;
+    f3.setFieldType(QVideoFrame::ProgressiveFrame);
+    QTest::newRow("times prog") << f3 << QString::fromLatin1("QVideoFrame( QSize(-1, -1) , Format_Invalid, NoHandle, NotMapped, [no timestamp])");
+
+    QVideoFrame f4;
+    f4.setFieldType(QVideoFrame::TopField);
+    QTest::newRow("times top") << f4 << QString::fromLatin1("QVideoFrame( QSize(-1, -1) , Format_Invalid, NoHandle, NotMapped, [no timestamp])");
+
+    QVideoFrame f5;
+    f5.setFieldType(QVideoFrame::TopField);
+    f5.setEndTime(90000000000LL);
+    QTest::newRow("end but no start") << f5 << QString::fromLatin1("QVideoFrame( QSize(-1, -1) , Format_Invalid, NoHandle, NotMapped, [no timestamp])");
+
+    QVideoFrame f6;
+    f6.setStartTime(12345000000LL);
+    f6.setEndTime(80000000000LL);
+    QTest::newRow("times big") << f6 << QString::fromLatin1("QVideoFrame( QSize(-1, -1) , Format_Invalid, NoHandle, NotMapped, 3:25:45.00 - 22:13:20.00)");
+
+    QVideoFrame g(0, QSize(320,240), 640, QVideoFrame::Format_ARGB32);
+    QTest::newRow("more valid") << g << QString::fromLatin1("QVideoFrame( QSize(320, 240) , Format_ARGB32, NoHandle, NotMapped, [no timestamp])");
+
+    QVideoFrame g2(0, QSize(320,240), 640, QVideoFrame::Format_ARGB32);
+    g2.setStartTime(9000000000LL);
+    g2.setEndTime(9000000000LL);
+    QTest::newRow("more valid") << g2 << QString::fromLatin1("QVideoFrame( QSize(320, 240) , Format_ARGB32, NoHandle, NotMapped, @2:30:00.00)");
+
+    QVideoFrame g3(0, QSize(320,240), 640, QVideoFrame::Format_ARGB32);
+    g3.setStartTime(900000LL);
+    g3.setEndTime(900000LL);
+    QTest::newRow("more valid single timestamp") << g3 << QString::fromLatin1("QVideoFrame( QSize(320, 240) , Format_ARGB32, NoHandle, NotMapped, @00:00.900000)");
+
+    QVideoFrame g4(0, QSize(320,240), 640, QVideoFrame::Format_ARGB32);
+    g4.setStartTime(200000000LL);
+    g4.setEndTime(300000000LL);
+    QTest::newRow("more valid") << g4 << QString::fromLatin1("QVideoFrame( QSize(320, 240) , Format_ARGB32, NoHandle, NotMapped, 03:20.00 - 05:00.00)");
+
+    QVideoFrame g5(0, QSize(320,240), 640, QVideoFrame::Format_ARGB32);
+    g5.setStartTime(200000000LL);
+    QTest::newRow("more valid until forever") << g5 << QString::fromLatin1("QVideoFrame( QSize(320, 240) , Format_ARGB32, NoHandle, NotMapped, 03:20.00 - forever)");
+
+    QVideoFrame g6(0, QSize(320,240), 640, QVideoFrame::Format_ARGB32);
+    g6.setStartTime(9000000000LL);
+    QTest::newRow("more valid for long forever") << g6 << QString::fromLatin1("QVideoFrame( QSize(320, 240) , Format_ARGB32, NoHandle, NotMapped, 2:30:00.00 - forever)");
+}
+
+void tst_QVideoFrame::debug()
+{
+    QFETCH(QVideoFrame, frame);
+    QFETCH(QString, stringized);
+
+    QTest::ignoreMessage(QtDebugMsg, stringized.toLatin1().constData());
+    qDebug() << frame;
+}
+
+void tst_QVideoFrame::debugFormat_data()
+{
+    QTest::addColumn<QVideoFrame::PixelFormat>("format");
+    QTest::addColumn<QString>("stringized");
+
+    ADD_ENUM_TEST(Format_Invalid);
+    ADD_ENUM_TEST(Format_ARGB32);
+    ADD_ENUM_TEST(Format_ARGB32_Premultiplied);
+    ADD_ENUM_TEST(Format_RGB32);
+    ADD_ENUM_TEST(Format_RGB24);
+    ADD_ENUM_TEST(Format_RGB565);
+    ADD_ENUM_TEST(Format_RGB555);
+    ADD_ENUM_TEST(Format_ARGB8565_Premultiplied);
+    ADD_ENUM_TEST(Format_BGRA32);
+    ADD_ENUM_TEST(Format_BGRA32_Premultiplied);
+    ADD_ENUM_TEST(Format_BGR32);
+    ADD_ENUM_TEST(Format_BGR24);
+    ADD_ENUM_TEST(Format_BGR565);
+    ADD_ENUM_TEST(Format_BGR555);
+    ADD_ENUM_TEST(Format_BGRA5658_Premultiplied);
+
+    ADD_ENUM_TEST(Format_AYUV444);
+    ADD_ENUM_TEST(Format_AYUV444_Premultiplied);
+    ADD_ENUM_TEST(Format_YUV444);
+    ADD_ENUM_TEST(Format_YUV420P);
+    ADD_ENUM_TEST(Format_YV12);
+    ADD_ENUM_TEST(Format_UYVY);
+    ADD_ENUM_TEST(Format_YUYV);
+    ADD_ENUM_TEST(Format_NV12);
+    ADD_ENUM_TEST(Format_NV21);
+    ADD_ENUM_TEST(Format_IMC1);
+    ADD_ENUM_TEST(Format_IMC2);
+    ADD_ENUM_TEST(Format_IMC3);
+    ADD_ENUM_TEST(Format_IMC4);
+    ADD_ENUM_TEST(Format_Y8);
+    ADD_ENUM_TEST(Format_Y16);
+
+    ADD_ENUM_TEST(Format_Jpeg);
+
+    ADD_ENUM_TEST(Format_CameraRaw);
+    ADD_ENUM_TEST(Format_AdobeDng);
+
+    // User enums are formatted differently
+    QTest::newRow("user 1000") << QVideoFrame::Format_User << QString::fromLatin1("UserType(1000)");
+    QTest::newRow("user 1005") << QVideoFrame::PixelFormat(QVideoFrame::Format_User + 5) << QString::fromLatin1("UserType(1005)");
+}
+
+void tst_QVideoFrame::debugFormat()
+{
+    QFETCH(QVideoFrame::PixelFormat, format);
+    QFETCH(QString, stringized);
+
+    QTest::ignoreMessage(QtDebugMsg, stringized.toLatin1().constData());
+    qDebug() << format;
+}

 QTEST_MAIN(tst_QVideoFrame)

--- a/tests/auto/qvideosurfaceformat/tst_qvideosurfaceformat.cpp
+++ b/tests/auto/qvideosurfaceformat/tst_qvideosurfaceformat.cpp
@@ -45,6 +45,12 @@

 #include <qvideosurfaceformat.h>

+// Adds an enum, and the stringized version
+#define ADD_ENUM_TEST(x) \
+    QTest::newRow(#x) \
+        << QVideoSurfaceFormat::x \
+    << QString(QLatin1String(#x));
+
 class tst_QVideoSurfaceFormat : public QObject
 {
    Q_OBJECT
@@ -70,12 +76,12 @@ private slots:
    void scanLineDirection();
    void frameRate_data();
    void frameRate();
-    void yCbCrColorSpace_data();
-    void yCbCrColorSpace();
    void pixelAspectRatio_data();
    void pixelAspectRatio();
    void sizeHint_data();
    void sizeHint();
+    void yCbCrColorSpaceEnum_data();
+    void yCbCrColorSpaceEnum ();
    void staticPropertyNames();
    void dynamicProperty();
    void compare();
@@ -83,8 +89,6 @@ private slots:
    void assign();

    void isValid();
-    void yCbCrColorSpaceEnum_data();
-    void yCbCrColorSpaceEnum ();
    void copyAllParameters ();
    void assignAllParameters ();

@@ -308,17 +312,16 @@ void tst_QVideoSurfaceFormat::viewport()
 void tst_QVideoSurfaceFormat::scanLineDirection_data()
 {
    QTest::addColumn<QVideoSurfaceFormat::Direction>("direction");
+    QTest::addColumn<QString>("stringized");

-    QTest::newRow("top to bottom")
-            << QVideoSurfaceFormat::TopToBottom;
-
-    QTest::newRow("bottom to top")
-            << QVideoSurfaceFormat::BottomToTop;
+    ADD_ENUM_TEST(TopToBottom);
+    ADD_ENUM_TEST(BottomToTop);
 }

 void tst_QVideoSurfaceFormat::scanLineDirection()
 {
    QFETCH(QVideoSurfaceFormat::Direction, direction);
+    QFETCH(QString, stringized);

    {
        QVideoSurfaceFormat format(QSize(16, 16), QVideoFrame::Format_RGB32);
@@ -340,8 +343,53 @@ void tst_QVideoSurfaceFormat::scanLineDirection()
                qvariant_cast<QVideoSurfaceFormat::Direction>(format.property("scanLineDirection")),
                direction);
    }
+
+    QTest::ignoreMessage(QtDebugMsg, stringized.toLatin1().constData());
+    qDebug() << direction;
 }

+void tst_QVideoSurfaceFormat::yCbCrColorSpaceEnum_data()
+{
+    QTest::addColumn<QVideoSurfaceFormat::YCbCrColorSpace>("colorspace");
+    QTest::addColumn<QString>("stringized");
+
+    ADD_ENUM_TEST(YCbCr_BT601);
+    ADD_ENUM_TEST(YCbCr_BT709);
+    ADD_ENUM_TEST(YCbCr_xvYCC601);
+    ADD_ENUM_TEST(YCbCr_xvYCC709);
+    ADD_ENUM_TEST(YCbCr_JPEG);
+    ADD_ENUM_TEST(YCbCr_CustomMatrix);
+    ADD_ENUM_TEST(YCbCr_Undefined);
+}
+
+/* Test case for Enum YCbCr_BT601, YCbCr_xvYCC709 */
+void tst_QVideoSurfaceFormat::yCbCrColorSpaceEnum()
+{
+    QFETCH(QVideoSurfaceFormat::YCbCrColorSpace, colorspace);
+    QFETCH(QString, stringized);
+
+    {
+        QVideoSurfaceFormat format(QSize(64, 64), QVideoFrame::Format_RGB32);
+        format.setYCbCrColorSpace(colorspace);
+
+        QCOMPARE(format.yCbCrColorSpace(), colorspace);
+        QCOMPARE(qvariant_cast<QVideoSurfaceFormat::YCbCrColorSpace>(format.property("yCbCrColorSpace")),
+                colorspace);
+    }
+    {
+        QVideoSurfaceFormat format(QSize(64, 64), QVideoFrame::Format_RGB32);
+        format.setProperty("yCbCrColorSpace", qVariantFromValue(colorspace));
+
+        QCOMPARE(format.yCbCrColorSpace(), colorspace);
+        QCOMPARE(qvariant_cast<QVideoSurfaceFormat::YCbCrColorSpace>(format.property("yCbCrColorSpace")),
+                colorspace);
+    }
+
+    QTest::ignoreMessage(QtDebugMsg, stringized.toLatin1().constData());
+    qDebug() << colorspace;
+}
+
+
 void tst_QVideoSurfaceFormat::frameRate_data()
 {
    QTest::addColumn<qreal>("frameRate");
@@ -379,42 +427,6 @@ void tst_QVideoSurfaceFormat::frameRate()
    }
 }

-void tst_QVideoSurfaceFormat::yCbCrColorSpace_data()
-{
-    QTest::addColumn<QVideoSurfaceFormat::YCbCrColorSpace>("colorspace");
-
-    QTest::newRow("undefined")
-            << QVideoSurfaceFormat::YCbCr_Undefined;
-    QTest::newRow("bt709")
-            << QVideoSurfaceFormat::YCbCr_BT709;
-    QTest::newRow("xvYCC601")
-            << QVideoSurfaceFormat::YCbCr_xvYCC601;
-    QTest::newRow("JPEG")
-            << QVideoSurfaceFormat::YCbCr_JPEG;
-}
-
-void tst_QVideoSurfaceFormat::yCbCrColorSpace()
-{
-    QFETCH(QVideoSurfaceFormat::YCbCrColorSpace, colorspace);
-
-    {
-        QVideoSurfaceFormat format(QSize(64, 64), QVideoFrame::Format_RGB32);
-        format.setYCbCrColorSpace(colorspace);
-
-        QCOMPARE(format.yCbCrColorSpace(), colorspace);
-        QCOMPARE(qvariant_cast<QVideoSurfaceFormat::YCbCrColorSpace>(format.property("yCbCrColorSpace")),
-                colorspace);
-    }
-    {
-        QVideoSurfaceFormat format(QSize(64, 64), QVideoFrame::Format_RGB32);
-        format.setProperty("yCbCrColorSpace", qVariantFromValue(colorspace));
-
-        QCOMPARE(format.yCbCrColorSpace(), colorspace);
-        QCOMPARE(qvariant_cast<QVideoSurfaceFormat::YCbCrColorSpace>(format.property("yCbCrColorSpace")),
-                colorspace);
-    }
-}
-
 void tst_QVideoSurfaceFormat::pixelAspectRatio_data()
 {
    QTest::addColumn<QSize>("aspectRatio");
@@ -768,54 +780,6 @@ void tst_QVideoSurfaceFormat::assign()
    QCOMPARE(original != copy, true);
 }

-/* Test case for Enum YCbCr_BT601, YCbCr_xvYCC709 */
-
-#define ADD_YCBCR_TEST(x) \
-    QTest::newRow(#x) \
-        << QVideoSurfaceFormat::x \
-    << QString(QLatin1String(#x));
-
-void tst_QVideoSurfaceFormat::yCbCrColorSpaceEnum_data()
-{
-    QTest::addColumn<QVideoSurfaceFormat::YCbCrColorSpace>("colorspace");
-    QTest::addColumn<QString>("stringized");
-
-    ADD_YCBCR_TEST(YCbCr_BT601);
-    ADD_YCBCR_TEST(YCbCr_BT709);
-    ADD_YCBCR_TEST(YCbCr_xvYCC601);
-    ADD_YCBCR_TEST(YCbCr_xvYCC709);
-    ADD_YCBCR_TEST(YCbCr_JPEG);
-    ADD_YCBCR_TEST(YCbCr_CustomMatrix);
-    ADD_YCBCR_TEST(YCbCr_Undefined);
-}
-
-/* Test case for Enum YCbCr_BT601, YCbCr_xvYCC709 */
-void tst_QVideoSurfaceFormat::yCbCrColorSpaceEnum()
-{
-    QFETCH(QVideoSurfaceFormat::YCbCrColorSpace, colorspace);
-    QFETCH(QString, stringized);
-
-    {
-        QVideoSurfaceFormat format(QSize(64, 64), QVideoFrame::Format_RGB32);
-        format.setYCbCrColorSpace(colorspace);
-
-        QCOMPARE(format.yCbCrColorSpace(), colorspace);
-        QCOMPARE(qvariant_cast<QVideoSurfaceFormat::YCbCrColorSpace>(format.property("yCbCrColorSpace")),
-                colorspace);
-    }
-    {
-        QVideoSurfaceFormat format(QSize(64, 64), QVideoFrame::Format_RGB32);
-        format.setProperty("yCbCrColorSpace", qVariantFromValue(colorspace));
-
-        QCOMPARE(format.yCbCrColorSpace(), colorspace);
-        QCOMPARE(qvariant_cast<QVideoSurfaceFormat::YCbCrColorSpace>(format.property("yCbCrColorSpace")),
-                colorspace);
-    }
-
-    QTest::ignoreMessage(QtDebugMsg, stringized.toLatin1().constData());
-    qDebug() << colorspace;
-}
-
 /* Test case for api isValid */
 void tst_QVideoSurfaceFormat::isValid()
 {
--- a/tests/auto/qwavedecoder/tst_qwavedecoder.cpp
+++ b/tests/auto/qwavedecoder/tst_qwavedecoder.cpp
@@ -319,7 +319,6 @@ void tst_QWaveDecoder::readPerByte()
 }

 Q_DECLARE_METATYPE(tst_QWaveDecoder::Corruption)
-Q_DECLARE_METATYPE(QAudioFormat::Endian)

 QTEST_MAIN(tst_QWaveDecoder)