12 files changed, 605 insertions, 121 deletions

diff --git a/tests/auto/gui/painting/painting.pro b/tests/auto/gui/painting/painting.pro
index 831fffab30..26e84c1b15 100644
--- a/tests/auto/gui/painting/painting.pro
+++ b/tests/auto/gui/painting/painting.pro
@@ -3,6 +3,7 @@ SUBDIRS=\
    qpainterpath \
    qpainterpathstroker \
    qcolor \
+   qcolorspace \
    qbrush \
    qregion \
    qpagelayout \
diff --git a/tests/auto/gui/painting/qbrush/tst_qbrush.cpp b/tests/auto/gui/painting/qbrush/tst_qbrush.cpp
index ce6ce15767..f35d4f330b 100644
--- a/tests/auto/gui/painting/qbrush/tst_qbrush.cpp
+++ b/tests/auto/gui/painting/qbrush/tst_qbrush.cpp
@@ -338,9 +338,9 @@ void tst_QBrush::gradientPresets()
     QCOMPARE(lg->finalStop(), QPointF(1, 0));
 
     QCOMPARE(lg->stops().size(), 3);
-    QCOMPARE(lg->stops().at(0), QGradientStop(0, QColor(QLatin1Literal("#ff9a9e"))));
-    QCOMPARE(lg->stops().at(1), QGradientStop(0.99, QColor(QLatin1Literal("#fad0c4"))));
-    QCOMPARE(lg->stops().at(2), QGradientStop(1, QColor(QLatin1Literal("#fad0c4"))));
+    QCOMPARE(lg->stops().at(0), QGradientStop(0, QColor(QLatin1String("#ff9a9e"))));
+    QCOMPARE(lg->stops().at(1), QGradientStop(0.99, QColor(QLatin1String("#fad0c4"))));
+    QCOMPARE(lg->stops().at(2), QGradientStop(1, QColor(QLatin1String("#fad0c4"))));
 
 
     QGradient invalidPreset(QGradient::Preset(-1));
diff --git a/tests/auto/gui/painting/qcolor/tst_qcolor.cpp b/tests/auto/gui/painting/qcolor/tst_qcolor.cpp
index 17289e0b85..90a216e14a 100644
--- a/tests/auto/gui/painting/qcolor/tst_qcolor.cpp
+++ b/tests/auto/gui/painting/qcolor/tst_qcolor.cpp
@@ -33,7 +33,7 @@
 
 #include <qcolor.h>
 #include <qdebug.h>
-#include <private/qcolorprofile_p.h>
+#include <private/qcolortrclut_p.h>
 #include <private/qdrawingprimitive_sse2_p.h>
 #include <qrgba64.h>
 
@@ -70,6 +70,7 @@ private slots:
     void setBlue();
 
     void setRgb();
+    void setRgbF();
     void setRgba();
     void setHsv();
     void setCmyk();
@@ -93,8 +94,8 @@ private slots:
 
     void convertTo();
 
-    void light();
-    void dark();
+    void lighter();
+    void darker();
 
     void specConstructor_data();
     void specConstructor();
@@ -187,28 +188,28 @@ void tst_QColor::getSetCheck()
     // void QColor::setRedF(qreal)
     obj1.setRedF(0.0);
     QCOMPARE(obj1.redF(), qreal(0.0));
-    obj1.setRedF(-0.2);
-    QCOMPARE(obj1.redF(), qreal(0.0)); // range<0.0, 1.0
-    obj1.setRedF(1.1);
-    QCOMPARE(obj1.redF(), qreal(1.0)); // range<0.0, 1.0
+    obj1.setRedF(-0.25);
+    QCOMPARE(obj1.redF(), qreal(-0.25));
+    obj1.setRedF(1.25);
+    QCOMPARE(obj1.redF(), qreal(1.25));
 
     // qreal QColor::greenF()
     // void QColor::setGreenF(qreal)
     obj1.setGreenF(0.0);
     QCOMPARE(obj1.greenF(), qreal(0.0));
-    obj1.setGreenF(-0.2);
-    QCOMPARE(obj1.greenF(), qreal(0.0)); // range<0.0, 1.0
-    obj1.setGreenF(1.1);
-    QCOMPARE(obj1.greenF(), qreal(1.0)); // range<0.0, 1.0
+    obj1.setGreenF(-0.25);
+    QCOMPARE(obj1.greenF(), qreal(-0.25));
+    obj1.setGreenF(1.5);
+    QCOMPARE(obj1.greenF(), qreal(1.5));
 
     // qreal QColor::blueF()
     // void QColor::setBlueF(qreal)
     obj1.setBlueF(0.0);
     QCOMPARE(obj1.blueF(), qreal(0.0));
-    obj1.setBlueF(-0.2);
-    QCOMPARE(obj1.blueF(), qreal(0.0)); // range<0.0, 1.0
-    obj1.setBlueF(1.1);
-    QCOMPARE(obj1.blueF(), qreal(1.0)); // range<0.0, 1.0
+    obj1.setBlueF(-0.5);
+    QCOMPARE(obj1.blueF(), qreal(-0.5));
+    obj1.setBlueF(2.0);
+    QCOMPARE(obj1.blueF(), qreal(2.0));
 
     // QRgb QColor::rgba()
     // void QColor::setRgba(QRgb)
@@ -677,30 +678,81 @@ void tst_QColor::setRgb()
 {
     QColor color;
 
-    for (int A = 0; A <= USHRT_MAX; ++A) {
-        {
-            // 0-255
-            int a = A >> 8;
-            QRgb rgb = qRgba(0, 0, 0, a);
+    for (int a = 0; a <= 255; ++a) {
+        QRgb rgb = qRgba(0, 0, 0, a);
 
-            color.setRgb(0, 0, 0, a);
-            QCOMPARE(color.alpha(), a);
-            QCOMPARE(color.rgb(),  qRgb(0, 0, 0));
+        color.setRgb(0, 0, 0, a);
+        QCOMPARE(color.alpha(), a);
+        QCOMPARE(color.rgb(),  qRgb(0, 0, 0));
 
-            color.setRgb(rgb);
-            QCOMPARE(color.alpha(), 255);
-            QCOMPARE(color.rgb(),   qRgb(0, 0, 0));
+        color.setRgb(rgb);
+        QCOMPARE(color.alpha(), 255);
+        QCOMPARE(color.rgb(),   qRgb(0, 0, 0));
 
-            int r, g, b, a2;
-            color.setRgb(0, 0, 0, a);
-            color.getRgb(&r, &g, &b, &a2);
-            QCOMPARE(a2, a);
+        int r, g, b, a2;
+        color.setRgb(0, 0, 0, a);
+        color.getRgb(&r, &g, &b, &a2);
+        QCOMPARE(a2, a);
 
-            QColor c(0, 0, 0);
-            c.setAlpha(a);
-            QCOMPARE(c.alpha(), a);
-        }
+        QColor c(0, 0, 0);
+        c.setAlpha(a);
+        QCOMPARE(c.alpha(), a);
+    }
 
+    for (int r = 0; r <= 255; ++r) {
+        QRgb rgb = qRgb(r, 0, 0);
+
+        color.setRgb(r, 0, 0);
+        QCOMPARE(color.red(), r);
+        QCOMPARE(color.rgb(), rgb);
+
+        color.setRgb(rgb);
+        QCOMPARE(color.red(), r);
+        QCOMPARE(color.rgb(), rgb);
+
+        int r2, g, b, a;
+        color.getRgb(&r2, &g, &b, &a);
+        QCOMPARE(r2, r);
+    }
+
+    for (int g = 0; g <= 255; ++g) {
+        QRgb rgb = qRgb(0, g, 0);
+
+        color.setRgb(0, g, 0);
+        QCOMPARE(color.green(), g);
+        QCOMPARE(color.rgb(),   rgb);
+
+        color.setRgb(rgb);
+        QCOMPARE(color.green(), g);
+        QCOMPARE(color.rgb(),   rgb);
+
+        int r, g2, b, a;
+        color.getRgb(&r, &g2, &b, &a);
+        QCOMPARE(g2, g);
+    }
+
+    for (int b = 0; b <= 255; ++b) {
+        QRgb rgb = qRgb(0, 0, b);
+
+        color.setRgb(0, 0, b);
+        QCOMPARE(color.blue(),  b);
+        QCOMPARE(color.rgb(),   rgb);
+
+        color.setRgb(rgb);
+        QCOMPARE(color.blue(),  b);
+        QCOMPARE(color.rgb(),   rgb);
+
+        int r, g, b2, a;
+        color.getRgb(&r, &g, &b2, &a);
+        QCOMPARE(b2, b);
+    }
+}
+
+void tst_QColor::setRgbF()
+{
+    QColor color;
+
+    for (int A = 0; A <= USHRT_MAX; ++A) {
         {
             // 0.0-1.0
             qreal a = A / qreal(USHRT_MAX);
@@ -720,24 +772,6 @@ void tst_QColor::setRgb()
 
     for (int R = 0; R <= USHRT_MAX; ++R) {
         {
-            // 0-255
-            int r = R >> 8;
-            QRgb rgb = qRgb(r, 0, 0);
-
-            color.setRgb(r, 0, 0);
-            QCOMPARE(color.red(), r);
-            QCOMPARE(color.rgb(), rgb);
-
-            color.setRgb(rgb);
-            QCOMPARE(color.red(), r);
-            QCOMPARE(color.rgb(), rgb);
-
-            int r2, g, b, a;
-            color.getRgb(&r2, &g, &b, &a);
-            QCOMPARE(r2, r);
-        }
-
-        {
             // 0.0-1.0
             qreal r = R / qreal(USHRT_MAX);
             color.setRgbF(r, 0.0, 0.0);
@@ -751,24 +785,6 @@ void tst_QColor::setRgb()
 
     for (int G = 0; G <= USHRT_MAX; ++G) {
         {
-            // 0-255
-            int g = G >> 8;
-            QRgb rgb = qRgb(0, g, 0);
-
-            color.setRgb(0, g, 0);
-            QCOMPARE(color.green(), g);
-            QCOMPARE(color.rgb(),   rgb);
-
-            color.setRgb(rgb);
-            QCOMPARE(color.green(), g);
-            QCOMPARE(color.rgb(),   rgb);
-
-            int r, g2, b, a;
-            color.getRgb(&r, &g2, &b, &a);
-            QCOMPARE(g2, g);
-        }
-
-        {
             // 0.0-1.0
             qreal g = G / qreal(USHRT_MAX);
             color.setRgbF(0.0, g, 0.0);
@@ -782,32 +798,53 @@ void tst_QColor::setRgb()
 
     for (int B = 0; B <= USHRT_MAX; ++B) {
         {
-            // 0-255
-            int b = B >> 8;
-            QRgb rgb = qRgb(0, 0, b);
+            // 0.0-1.0
+            qreal b = B / qreal(USHRT_MAX);
+            color.setRgbF(0.0, 0.0, b);
+            QCOMPARE(color.blueF(), b);
 
-            color.setRgb(0, 0, b);
-            QCOMPARE(color.blue(),  b);
-            QCOMPARE(color.rgb(),   rgb);
+            qreal r, g, b2, a;
+            color.getRgbF(&r, &g, &b2, &a);
+            QCOMPARE(b2, b);
+        }
+    }
 
-            color.setRgb(rgb);
-            QCOMPARE(color.blue(),  b);
-            QCOMPARE(color.rgb(),   rgb);
+    for (int R = -128; R <= 512; ++R) {
+        {
+            // extended RGB
+            qreal r = R / qreal(256);
+            color.setRgbF(r, 0.0, 0.0);
+            QCOMPARE(qfloat16(color.redF()), qfloat16(r));
 
-            int r, g, b2, a;
-            color.getRgb(&r, &g, &b2, &a);
-            QCOMPARE(b2, b);
+            qreal r2, g, b, a;
+            color.getRgbF(&r2, &g, &b, &a);
+            QCOMPARE(qfloat16(r2), qfloat16(r));
         }
+    }
 
+    for (int G = -128; G <= 512; ++G) {
         {
-            // 0.0-1.0
-            qreal b = B / qreal(USHRT_MAX);
+            // extended RGB
+            qreal g = G / qreal(256);
+            color.setRgbF(0.0, g, 0.0);
+            QCOMPARE(qfloat16(color.greenF()), qfloat16(g));
+
+            qreal r, g2, b, a;
+            color.getRgbF(&r, &g2, &b, &a);
+            QCOMPARE(qfloat16(g2), qfloat16(g));
+        }
+    }
+
+    for (int B = -128; B <= 512; ++B) {
+        {
+            // extended RGB
+            qreal b = B / qreal(256);
             color.setRgbF(0.0, 0.0, b);
-            QCOMPARE(color.blueF(), b);
+            QCOMPARE(qfloat16(color.blueF()), qfloat16(b));
 
             qreal r, g, b2, a;
             color.getRgbF(&r, &g, &b2, &a);
-            QCOMPARE(b2, b);
+            QCOMPARE(qfloat16(b2), qfloat16(b));
         }
     }
 }
@@ -1382,17 +1419,17 @@ void tst_QColor::convertTo()
     QCOMPARE(invalid.spec(), QColor::Invalid);
 }
 
-void tst_QColor::light()
+void tst_QColor::lighter()
 {
     QColor gray(Qt::gray);
-    QColor lighter = gray.light();
+    QColor lighter = gray.lighter();
     QVERIFY(lighter.value() > gray.value());
 }
 
-void tst_QColor::dark()
+void tst_QColor::darker()
 {
     QColor gray(Qt::gray);
-    QColor darker = gray.dark();
+    QColor darker = gray.darker();
     QVERIFY(darker.value() < gray.value());
 }
 
@@ -1632,14 +1669,13 @@ void tst_QColor::qcolorprofile_data()
     QTest::newRow("gamma=1.7") << qreal(1.7) << 2;
     QTest::newRow("gamma=2.0") << qreal(2.0) << 8;
     QTest::newRow("gamma=2.31") << qreal(2.31) << 33;
-    QTest::newRow("SRgb") << qreal(0.0) << 7;
 }
 
 void tst_QColor::qcolorprofile()
 {
     QFETCH(qreal, gammaC);
     QFETCH(int, tolerance);
-    QColorProfile *cp = (gammaC == 0) ? QColorProfile::fromSRgb(): QColorProfile::fromGamma(gammaC);
+    QColorTrcLut *cp = QColorTrcLut::fromGamma(gammaC);
 
     // Test we are accurate for most values after converting through gamma-correction.
     int error = 0;
diff --git a/tests/auto/gui/painting/qcolorspace/qcolorspace.pro b/tests/auto/gui/painting/qcolorspace/qcolorspace.pro
new file mode 100644
index 0000000000..14bd699bf7
--- /dev/null
+++ b/tests/auto/gui/painting/qcolorspace/qcolorspace.pro
@@ -0,0 +1,9 @@
+CONFIG += testcase
+QT += testlib gui-private core-private
+
+TARGET = tst_qcolorspace
+SOURCES  += tst_qcolorspace.cpp
+
+RESOURCES += $$files(resources/*)
+
+TESTDATA += resources/*
diff --git a/tests/auto/gui/painting/qcolorspace/resources/HP_ZR30w.icc b/tests/auto/gui/painting/qcolorspace/resources/HP_ZR30w.icc
new file mode 100644
index 0000000000..b3f860714c
--- /dev/null
+++ b/tests/auto/gui/painting/qcolorspace/resources/HP_ZR30w.icc
diff --git a/tests/auto/gui/painting/qcolorspace/resources/ProPhoto.jpg b/tests/auto/gui/painting/qcolorspace/resources/ProPhoto.jpg
new file mode 100644
index 0000000000..481d35ca8e
--- /dev/null
+++ b/tests/auto/gui/painting/qcolorspace/resources/ProPhoto.jpg
diff --git a/tests/auto/gui/painting/qcolorspace/resources/sRGB2014.icc b/tests/auto/gui/painting/qcolorspace/resources/sRGB2014.icc
new file mode 100644
index 0000000000..49afbfef10
--- /dev/null
+++ b/tests/auto/gui/painting/qcolorspace/resources/sRGB2014.icc
diff --git a/tests/auto/gui/painting/qcolorspace/tst_qcolorspace.cpp b/tests/auto/gui/painting/qcolorspace/tst_qcolorspace.cpp
new file mode 100644
index 0000000000..291a25fede
--- /dev/null
+++ b/tests/auto/gui/painting/qcolorspace/tst_qcolorspace.cpp
@@ -0,0 +1,379 @@
+/****************************************************************************
+**
+** Copyright (C) 2018 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the test suite of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:GPL-EXCEPT$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3 as published by the Free Software
+** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#include <QtTest/QtTest>
+
+#include <qcolorspace.h>
+#include <qimage.h>
+#include <qimagereader.h>
+
+#include <private/qcolorspace_p.h>
+
+Q_DECLARE_METATYPE(QColorSpace::ColorSpaceId)
+Q_DECLARE_METATYPE(QColorSpace::Gamut)
+Q_DECLARE_METATYPE(QColorSpace::TransferFunction)
+
+class tst_QColorSpace : public QObject
+{
+    Q_OBJECT
+
+public:
+    tst_QColorSpace();
+
+private slots:
+    void namedColorSpaces_data();
+    void namedColorSpaces();
+
+    void toIccProfile_data();
+    void toIccProfile();
+
+    void fromIccProfile_data();
+    void fromIccProfile();
+
+    void imageConversion_data();
+    void imageConversion();
+
+    void loadImage();
+
+    void gamut();
+    void primariesXyz();
+    void primaries2_data();
+    void primaries2();
+    void invalidPrimaries();
+};
+
+tst_QColorSpace::tst_QColorSpace()
+{ }
+
+
+void tst_QColorSpace::namedColorSpaces_data()
+{
+    QTest::addColumn<QColorSpace::ColorSpaceId>("colorSpaceId");
+    QTest::addColumn<QColorSpace::Gamut>("gamutId");
+    QTest::addColumn<QColorSpace::TransferFunction>("transferFunctionId");
+
+    QTest::newRow("sRGB") << QColorSpace::SRgb
+                          << QColorSpace::Gamut::SRgb
+                          << QColorSpace::TransferFunction::SRgb;
+    QTest::newRow("sRGB Linear") << QColorSpace::SRgbLinear
+                                 << QColorSpace::Gamut::SRgb
+                                 << QColorSpace::TransferFunction::Linear;
+    QTest::newRow("Adobe RGB") << QColorSpace::AdobeRgb
+                               << QColorSpace::Gamut::AdobeRgb
+                               << QColorSpace::TransferFunction::Gamma;
+    QTest::newRow("Display-P3") << QColorSpace::DisplayP3
+                                << QColorSpace::Gamut::DciP3D65
+                                << QColorSpace::TransferFunction::SRgb;
+    QTest::newRow("ProPhoto RGB") << QColorSpace::ProPhotoRgb
+                                  << QColorSpace::Gamut::ProPhotoRgb
+                                  << QColorSpace::TransferFunction::ProPhotoRgb;
+    QTest::newRow("BT.2020") << QColorSpace::Bt2020
+                             << QColorSpace::Gamut::Bt2020
+                             << QColorSpace::TransferFunction::Bt2020;
+}
+
+void tst_QColorSpace::namedColorSpaces()
+{
+    QFETCH(QColorSpace::ColorSpaceId, colorSpaceId);
+    QFETCH(QColorSpace::Gamut, gamutId);
+    QFETCH(QColorSpace::TransferFunction, transferFunctionId);
+
+    QColorSpace colorSpace = colorSpaceId;
+
+    QVERIFY(colorSpace.isValid());
+
+    QCOMPARE(colorSpace.colorSpaceId(), colorSpaceId);
+    QCOMPARE(colorSpace.gamut(), gamutId);
+    QCOMPARE(colorSpace.transferFunction(), transferFunctionId);
+}
+
+
+void tst_QColorSpace::toIccProfile_data()
+{
+    namedColorSpaces_data();
+}
+
+void tst_QColorSpace::toIccProfile()
+{
+    QFETCH(QColorSpace::ColorSpaceId, colorSpaceId);
+    QFETCH(QColorSpace::Gamut, gamutId);
+    QFETCH(QColorSpace::TransferFunction, transferFunctionId);
+
+    Q_UNUSED(gamutId);
+    Q_UNUSED(transferFunctionId);
+
+    QColorSpace colorSpace = colorSpaceId;
+    QByteArray iccProfile = colorSpace.iccProfile();
+    QVERIFY(!iccProfile.isEmpty());
+
+    QColorSpace colorSpace2 = QColorSpace::fromIccProfile(iccProfile);
+    QVERIFY(colorSpace2.isValid());
+
+    QCOMPARE(colorSpace2, colorSpace);
+
+    QByteArray iccProfile2 = colorSpace2.iccProfile();
+    QVERIFY(!iccProfile2.isEmpty());
+
+    QCOMPARE(iccProfile2, iccProfile);
+}
+
+void tst_QColorSpace::fromIccProfile_data()
+{
+    QTest::addColumn<QString>("testProfile");
+    QTest::addColumn<QColorSpace::ColorSpaceId>("colorSpaceId");
+    QTest::addColumn<QColorSpace::TransferFunction>("transferFunction");
+    QTest::addColumn<QString>("description");
+
+    QString prefix = QFINDTESTDATA("resources/");
+    // Read the official sRGB ICCv2 profile:
+    QTest::newRow("sRGB2014 (ICCv2)") << prefix + "sRGB2014.icc" << QColorSpace::SRgb
+                                           << QColorSpace::TransferFunction::SRgb << QString("sRGB2014");
+    // My monitor's profile:
+    QTest::newRow("HP ZR30w (ICCv4)") << prefix + "HP_ZR30w.icc" << QColorSpace::Unknown
+                                      << QColorSpace::TransferFunction::Gamma << QString("HP Z30i");
+}
+
+void tst_QColorSpace::fromIccProfile()
+{
+    QFETCH(QString, testProfile);
+    QFETCH(QColorSpace::ColorSpaceId, colorSpaceId);
+    QFETCH(QColorSpace::TransferFunction, transferFunction);
+    QFETCH(QString, description);
+
+    QFile file(testProfile);
+    file.open(QIODevice::ReadOnly);
+    QByteArray iccProfile = file.readAll();
+    QColorSpace fileColorSpace = QColorSpace::fromIccProfile(iccProfile);
+    QVERIFY(fileColorSpace.isValid());
+
+    QCOMPARE(fileColorSpace.colorSpaceId(), colorSpaceId);
+    QCOMPARE(fileColorSpace.transferFunction(), transferFunction);
+    QCOMPARE(QColorSpacePrivate::get(fileColorSpace)->description, description);
+}
+
+void tst_QColorSpace::imageConversion_data()
+{
+    QTest::addColumn<QColorSpace::ColorSpaceId>("fromColorSpace");
+    QTest::addColumn<QColorSpace::ColorSpaceId>("toColorSpace");
+    QTest::addColumn<int>("tolerance");
+
+    QTest::newRow("sRGB -> Display-P3") << QColorSpace::SRgb << QColorSpace::DisplayP3 << 0;
+    QTest::newRow("sRGB -> Adobe RGB") << QColorSpace::SRgb << QColorSpace::AdobeRgb << 2;
+    QTest::newRow("Display-P3 -> sRGB") << QColorSpace::DisplayP3 << QColorSpace::SRgb << 0;
+    QTest::newRow("Adobe RGB -> sRGB") << QColorSpace::AdobeRgb << QColorSpace::SRgb << 2;
+    QTest::newRow("Display-P3 -> Adobe RGB") << QColorSpace::DisplayP3 << QColorSpace::AdobeRgb << 2;
+    QTest::newRow("Display-P3 -> BT.2020") << QColorSpace::DisplayP3 << QColorSpace::Bt2020 << 4;
+    QTest::newRow("sRGB -> sRGB Linear") << QColorSpace::SRgb << QColorSpace::SRgbLinear << 0;
+}
+
+void tst_QColorSpace::imageConversion()
+{
+    QFETCH(QColorSpace::ColorSpaceId, fromColorSpace);
+    QFETCH(QColorSpace::ColorSpaceId, toColorSpace);
+    QFETCH(int, tolerance);
+
+    QImage testImage(256, 1, QImage::Format_RGB32);
+
+    for (int i = 0; i < 256; ++i)
+        testImage.setPixel(i, 0, qRgb(i, i, i));
+
+    testImage.setColorSpace(fromColorSpace);
+    QCOMPARE(testImage.colorSpace(), QColorSpace(fromColorSpace));
+
+    testImage.convertToColorSpace(toColorSpace);
+    QCOMPARE(testImage.colorSpace(), QColorSpace(toColorSpace));
+
+    int lastRed = 0;
+    int lastGreen = 0;
+    int lastBlue = 0;
+    for (int i = 0; i < 256; ++i) {
+        QRgb p = testImage.pixel(i, 0);
+        QVERIFY(qRed(p) >= lastRed);
+        QVERIFY(qGreen(p) >= lastGreen);
+        QVERIFY(qBlue(p) >= lastBlue);
+        lastRed = qRed(p);
+        lastGreen = qGreen(p);
+        lastBlue = qBlue(p);
+    }
+
+    lastRed = 0;
+    lastGreen = 0;
+    lastBlue = 0;
+    testImage.convertToColorSpace(fromColorSpace);
+    QCOMPARE(testImage.colorSpace(), QColorSpace(fromColorSpace));
+    for (int i = 0; i < 256; ++i) {
+        QRgb p = testImage.pixel(i, 0);
+        QVERIFY(qAbs(qRed(p) - qGreen(p)) <= tolerance);
+        QVERIFY(qAbs(qRed(p) - qBlue(p)) <= tolerance);
+        QVERIFY((lastRed   - qRed(p))   <= (tolerance / 2));
+        QVERIFY((lastGreen - qGreen(p)) <= (tolerance / 2));
+        QVERIFY((lastBlue  - qBlue(p))  <= (tolerance / 2));
+        lastRed = qRed(p);
+        lastGreen = qGreen(p);
+        lastBlue = qBlue(p);
+    }
+}
+
+
+void tst_QColorSpace::loadImage()
+{
+    QString prefix = QFINDTESTDATA("resources/");
+    QImageReader reader(prefix + "ProPhoto.jpg");
+    QImage image = reader.read();
+
+    QVERIFY(!image.isNull());
+    QVERIFY(image.colorSpace().isValid());
+    QCOMPARE(image.colorSpace().colorSpaceId(), QColorSpace::ProPhotoRgb);
+    QVERIFY(!image.colorSpace().iccProfile().isEmpty());
+
+    QColorSpace defaultProPhotoRgb = QColorSpace::ProPhotoRgb;
+    QVERIFY(!defaultProPhotoRgb.iccProfile().isEmpty());
+
+    // Test the iccProfile getter returns the ICC profile from the image
+    // which since we didn't write it, isn't identical to our defaults.
+    QVERIFY(defaultProPhotoRgb.iccProfile() != image.colorSpace().iccProfile());
+
+    QColorTransform transform = image.colorSpace().transformationToColorSpace(QColorSpace::SRgb);
+    qreal maxRed = 0;
+    qreal maxBlue = 0;
+    qreal maxRed2 = 0;
+    qreal maxBlue2 = 0;
+    for (int y = 0; y < image.height(); ++y) {
+        for (int x = 0; x < image.width(); ++x) {
+            QColor p = image.pixelColor(x, y);
+            maxRed = std::max(maxRed, p.redF());
+            maxBlue = std::max(maxBlue, p.blueF());
+            p = transform.map(p);
+            maxRed2 = std::max(maxRed2, p.redF());
+            maxBlue2 = std::max(maxBlue2, p.blueF());
+
+        }
+    }
+    // ProPhotoRgb can be a lot more red and blue than SRgb can, so it will have lower values.
+    QVERIFY(maxRed2 > maxRed);
+    QVERIFY(maxBlue2 > maxBlue);
+}
+
+void tst_QColorSpace::gamut()
+{
+    QColor black = QColor::fromRgbF(0.0, 0.0, 0.0);
+    QColor white = QColor::fromRgbF(1.0, 1.0, 1.0);
+    QColor red = QColor::fromRgbF(1.0, 0.0, 0.0);
+    QColor green = QColor::fromRgbF(0.0, 1.0, 0.0);
+    QColor blue = QColor::fromRgbF(0.0, 0.0, 1.0);
+
+    QColorTransform toAdobeRgb = QColorSpace(QColorSpace::SRgb).transformationToColorSpace(QColorSpace::AdobeRgb);
+
+    QColor tblack = toAdobeRgb.map(black);
+    QColor twhite = toAdobeRgb.map(white);
+    QColor tred = toAdobeRgb.map(red);
+    QColor tgreen = toAdobeRgb.map(green);
+    QColor tblue = toAdobeRgb.map(blue);
+
+    // Black is black
+    QCOMPARE(tblack, black);
+
+    // This white hasn't changed
+    QCOMPARE(twhite, white);
+
+    // Adobe's red and blue gamut corners are the same as sRGB's
+    // So, a color in the red corner, will stay in the red corner
+    // the same for blue, but not for green.
+    QVERIFY(tred.greenF() < 0.001);
+    QVERIFY(tred.blueF() < 0.001);
+    QVERIFY(tblue.redF() < 0.001);
+    QVERIFY(tblue.greenF() < 0.001);
+    QVERIFY(tgreen.redF() > 0.2);
+    QVERIFY(tgreen.blueF() > 0.2);
+}
+
+void tst_QColorSpace::primariesXyz()
+{
+    QColorSpace sRgb = QColorSpace::SRgb;
+    QColorSpace adobeRgb = QColorSpace::AdobeRgb;
+    QColorSpace displayP3 = QColorSpace::DisplayP3;
+    QColorSpace proPhotoRgb = QColorSpace::ProPhotoRgb;
+    QColorSpace bt2020 = QColorSpace::Bt2020;
+
+    // Check if our calculated matrices, match the precalculated ones.
+    QCOMPARE(QColorSpacePrivate::get(sRgb)->toXyz, QColorMatrix::toXyzFromSRgb());
+    QCOMPARE(QColorSpacePrivate::get(adobeRgb)->toXyz, QColorMatrix::toXyzFromAdobeRgb());
+    QCOMPARE(QColorSpacePrivate::get(displayP3)->toXyz, QColorMatrix::toXyzFromDciP3D65());
+    QCOMPARE(QColorSpacePrivate::get(proPhotoRgb)->toXyz, QColorMatrix::toXyzFromProPhotoRgb());
+    QCOMPARE(QColorSpacePrivate::get(bt2020)->toXyz, QColorMatrix::toXyzFromBt2020());
+}
+
+void tst_QColorSpace::primaries2_data()
+{
+    QTest::addColumn<QColorSpace::Gamut>("gamut");
+
+    QTest::newRow("sRGB") << QColorSpace::Gamut::SRgb;
+    QTest::newRow("DCI-P3 (D65)") << QColorSpace::Gamut::DciP3D65;
+    QTest::newRow("Adobe RGB (1998)") << QColorSpace::Gamut::AdobeRgb;
+    QTest::newRow("ProPhoto RGB") << QColorSpace::Gamut::ProPhotoRgb;
+    QTest::newRow("BT.2020") << QColorSpace::Gamut::Bt2020;
+}
+
+void tst_QColorSpace::primaries2()
+{
+    QFETCH(QColorSpace::Gamut, gamut);
+    QColorSpacePrimaries primaries(gamut);
+
+    QColorSpace original(gamut,  QColorSpace::TransferFunction::Linear);
+    QColorSpace custom1(primaries.whitePoint, primaries.redPoint,
+                        primaries.greenPoint, primaries.bluePoint, QColorSpace::TransferFunction::Linear);
+    QCOMPARE(original, custom1);
+
+    // A custom color swizzled color-space:
+    QColorSpace custom2(primaries.whitePoint, primaries.bluePoint,
+                        primaries.greenPoint, primaries.redPoint, QColorSpace::TransferFunction::Linear);
+
+    QVERIFY(custom1 != custom2);
+    QColor color1(255, 127, 63);
+    QColor color2 = custom1.transformationToColorSpace(custom2).map(color1);
+    QCOMPARE(color2.red(),   color1.blue());
+    QCOMPARE(color2.green(), color1.green());
+    QCOMPARE(color2.blue(),  color1.red());
+    QCOMPARE(color2.alpha(), color1.alpha());
+    QColor color3 = custom2.transformationToColorSpace(custom1).map(color2);
+    QCOMPARE(color3.red(),   color1.red());
+    QCOMPARE(color3.green(), color1.green());
+    QCOMPARE(color3.blue(),  color1.blue());
+    QCOMPARE(color3.alpha(), color1.alpha());
+}
+
+void tst_QColorSpace::invalidPrimaries()
+{
+    QColorSpace custom(QPointF(), QPointF(), QPointF(), QPointF(), QColorSpace::TransferFunction::Linear);
+    QVERIFY(!custom.isValid());
+    QCOMPARE(custom.colorSpaceId(), QColorSpace::Undefined);
+}
+
+QTEST_MAIN(tst_QColorSpace)
+#include "tst_qcolorspace.moc"
diff --git a/tests/auto/gui/painting/qpainter/tst_qpainter.cpp b/tests/auto/gui/painting/qpainter/tst_qpainter.cpp
index bc0baed15c..0efeb9b356 100644
--- a/tests/auto/gui/painting/qpainter/tst_qpainter.cpp
+++ b/tests/auto/gui/painting/qpainter/tst_qpainter.cpp
@@ -123,14 +123,18 @@ private slots:
     void drawPath2();
     void drawPath3();
 
+#if QT_DEPRECATED_SINCE(5, 13)
     void drawRoundRect_data() { fillData(); }
     void drawRoundRect();
+#endif
+    void drawRoundedRect_data() { fillData(); }
+    void drawRoundedRect();
 
     void qimageFormats_data();
     void qimageFormats();
     void textOnTransparentImage();
 
-#ifndef QT_NO_WIDGETS
+#if !defined(QT_NO_WIDGETS) && QT_DEPRECATED_SINCE(5, 13)
     void initFrom();
 #endif
 
@@ -185,10 +189,12 @@ private slots:
     void gradientPixelFormat_data();
     void gradientPixelFormat();
 
+#if QT_CONFIG(raster_64bit)
     void linearGradientRgb30_data();
     void linearGradientRgb30();
     void radialGradientRgb30_data();
     void radialGradientRgb30();
+#endif
 
     void fpe_pixmapTransform();
     void fpe_zeroLengthLines();
@@ -368,10 +374,10 @@ void tst_QPainter::getSetCheck()
 
     // bool QPainter::matrixEnabled()
     // void QPainter::setMatrixEnabled(bool)
-    obj1.setMatrixEnabled(false);
-    QCOMPARE(false, obj1.matrixEnabled());
-    obj1.setMatrixEnabled(true);
-    QCOMPARE(true, obj1.matrixEnabled());
+    obj1.setWorldMatrixEnabled(false);
+    QCOMPARE(false, obj1.worldMatrixEnabled());
+    obj1.setWorldMatrixEnabled(true);
+    QCOMPARE(true, obj1.worldMatrixEnabled());
 
     // bool QPainter::viewTransformEnabled()
     // void QPainter::setViewTransformEnabled(bool)
@@ -677,12 +683,14 @@ static QRect getPaintedSize(const QPixmap &pm, const QColor &background)
 }
 
 #ifndef QT_NO_WIDGETS
+
+#if QT_DEPRECATED_SINCE(5, 13)
 void tst_QPainter::initFrom()
 {
     QWidget *widget = new QWidget();
     QPalette pal = widget->palette();
-    pal.setColor(QPalette::Foreground, QColor(255, 0, 0));
-    pal.setBrush(QPalette::Background, QColor(0, 255, 0));
+    pal.setColor(QPalette::WindowText, QColor(255, 0, 0));
+    pal.setBrush(QPalette::Window, QColor(0, 255, 0));
     widget->setPalette(pal);
     widget->show();
 
@@ -696,11 +704,12 @@ void tst_QPainter::initFrom()
     p.initFrom(widget);
 
     QCOMPARE(p.font(), font);
-    QCOMPARE(p.pen().color(), pal.color(QPalette::Foreground));
-    QCOMPARE(p.background(), pal.background());
+    QCOMPARE(p.pen().color(), pal.color(QPalette::WindowText));
+    QCOMPARE(p.background(), pal.window());
 
     delete widget;
 }
+#endif
 
 void tst_QPainter::drawBorderPixmap()
 {
@@ -1544,6 +1553,7 @@ void tst_QPainter::drawClippedEllipse()
 
 }
 
+#if QT_DEPRECATED_SINCE(5, 13)
 void tst_QPainter::drawRoundRect()
 {
     QFETCH(QRect, rect);
@@ -1578,6 +1588,42 @@ void tst_QPainter::drawRoundRect()
         QCOMPARE(painted.height(), rect.height() + increment);
     }
 }
+#endif
+
+void tst_QPainter::drawRoundedRect()
+{
+    QFETCH(QRect, rect);
+    QFETCH(bool, usePen);
+
+#ifdef Q_OS_DARWIN
+    if (QTest::currentDataTag() == QByteArray("rect(6, 12, 3, 14) with pen") ||
+        QTest::currentDataTag() == QByteArray("rect(6, 17, 3, 25) with pen") ||
+        QTest::currentDataTag() == QByteArray("rect(10, 6, 10, 3) with pen") ||
+        QTest::currentDataTag() == QByteArray("rect(10, 12, 10, 14) with pen") ||
+        QTest::currentDataTag() == QByteArray("rect(13, 45, 17, 80) with pen") ||
+        QTest::currentDataTag() == QByteArray("rect(13, 50, 17, 91) with pen") ||
+        QTest::currentDataTag() == QByteArray("rect(17, 6, 24, 3) with pen") ||
+        QTest::currentDataTag() == QByteArray("rect(24, 12, 38, 14) with pen"))
+        QSKIP("The Mac paint engine is off-by-one on certain rect sizes");
+#endif
+    QPixmap pixmap(rect.x() + rect.width() + 10,
+                   rect.y() + rect.height() + 10);
+    {
+        pixmap.fill(Qt::white);
+        QPainter p(&pixmap);
+        p.setRenderHint(QPainter::Qt4CompatiblePainting);
+        p.setPen(usePen ? QPen(Qt::black) : QPen(Qt::NoPen));
+        p.setBrush(Qt::black);
+        p.drawRoundedRect(rect, 25, 25, Qt::RelativeSize);
+        p.end();
+
+        int increment = usePen ? 1 : 0;
+
+        const QRect painted = getPaintedSize(pixmap, Qt::white);
+        QCOMPARE(painted.width(), rect.width() + increment);
+        QCOMPARE(painted.height(), rect.height() + increment);
+    }
+}
 
 void tst_QPainter::qimageFormats_data()
 {
@@ -1660,9 +1706,13 @@ void tst_QPainter::combinedMatrix()
 
     p.translate(0.5, 0.5);
 
+    QTransform ct = p.combinedTransform();
+#if QT_DEPRECATED_SINCE(5, 13)
     QMatrix cm = p.combinedMatrix();
+    QCOMPARE(cm, ct.toAffine());
+#endif
 
-    QPointF pt = QPointF(0, 0) * cm;
+    QPointF pt = QPointF(0, 0) * ct.toAffine();
 
     QCOMPARE(pt.x(), 48.0);
     QCOMPARE(pt.y(), 16.0);
@@ -1977,7 +2027,7 @@ void tst_QPainter::clippedFillPath_data()
                                << pen2;
 
     path = QPainterPath();
-    path.addRoundRect(QRect(15, 15, 50, 50), 20);
+    path.addRoundedRect(QRect(15, 15, 50, 50), 20, Qt::RelativeSize);
     QTest::newRow("round rect 0") << QSize(100, 100) << path
                                   << QRect(15, 15, 49, 49)
                                   << QBrush(Qt::NoBrush)
@@ -3195,7 +3245,7 @@ void tst_QPainter::largeImagePainting()
         p.translate(4, 0);
     }
 
-    p.resetMatrix();
+    p.resetTransform();
 
     for (int i = 4; i < img.height(); i += 4) {
         p.translate(0, 4);
@@ -3946,6 +3996,7 @@ void tst_QPainter::gradientInterpolation()
     }
 }
 
+#if QT_CONFIG(raster_64bit)
 void tst_QPainter::linearGradientRgb30_data()
 {
     QTest::addColumn<QColor>("stop0");
@@ -4004,6 +4055,7 @@ void tst_QPainter::radialGradientRgb30()
         QVERIFY(qGray(p1.rgb()) >= qGray(p2.rgb()));
     }
 }
+#endif
 
 void tst_QPainter::drawPolygon()
 {
@@ -4084,14 +4136,18 @@ void tst_QPainter::inactivePainter()
     p.setClipRegion(region);
     p.setClipping(true);
 
+#if QT_DEPRECATED_SINCE(5, 13)
     p.combinedMatrix();
+#endif
     p.combinedTransform();
 
     p.compositionMode();
     p.setCompositionMode(QPainter::CompositionMode_Plus);
 
     p.device();
+#if QT_DEPRECATED_SINCE(5, 13)
     p.deviceMatrix();
+#endif
     p.deviceTransform();
 
     p.font();
@@ -4115,7 +4171,9 @@ void tst_QPainter::inactivePainter()
     p.setRenderHint(QPainter::Antialiasing, true);
     p.setRenderHints(QPainter::Antialiasing | QPainter::SmoothPixmapTransform, false);
 
+#if QT_DEPRECATED_SINCE(5, 13)
     p.resetMatrix();
+#endif
     p.resetTransform();
     p.rotate(1);
     p.scale(2, 2);
@@ -4131,8 +4189,10 @@ void tst_QPainter::inactivePainter()
     p.window();
     p.setWindow(QRect(10, 10, 620, 460));
 
+#if QT_DEPRECATED_SINCE(5, 13)
     p.worldMatrix();
     p.setWorldMatrix(QMatrix().translate(43, 21), true);
+#endif
     p.setWorldMatrixEnabled(true);
 
     p.transform();
@@ -4884,14 +4944,18 @@ void tst_QPainter::blendARGBonRGB_data()
                                      << QPainter::CompositionMode_SourceOver << qRgba(255, 0, 0, 85) << 85;
     QTest::newRow("ARGB_PM over RGB30") << QImage::Format_RGB30 << QImage::Format_ARGB32_Premultiplied
                                         << QPainter::CompositionMode_SourceOver << qRgba(85, 0, 0, 85) << 85;
+#if QT_CONFIG(raster_64bit)
     QTest::newRow("ARGB source RGB30") << QImage::Format_RGB30 << QImage::Format_ARGB32
                                        << QPainter::CompositionMode_Source << qRgba(255, 0, 0, 85) << 85;
     QTest::newRow("ARGB source RGB30") << QImage::Format_RGB30 << QImage::Format_ARGB32
                                        << QPainter::CompositionMode_Source << qRgba(255, 0, 0, 120) << 85;
+#endif
     QTest::newRow("ARGB_PM source RGB30") << QImage::Format_RGB30 << QImage::Format_ARGB32_Premultiplied
                                           << QPainter::CompositionMode_Source << qRgba(85, 0, 0, 85) << 85;
+#if QT_CONFIG(raster_64bit)
     QTest::newRow("ARGB_PM source RGB30") << QImage::Format_RGB30 << QImage::Format_ARGB32_Premultiplied
                                           << QPainter::CompositionMode_Source << qRgba(180, 0, 0, 180) << 170;
+#endif
     QTest::newRow("ARGB source-in RGB30") << QImage::Format_RGB30 << QImage::Format_ARGB32
                                           << QPainter::CompositionMode_SourceIn << qRgba(255, 0, 0, 85) << 85;
     QTest::newRow("ARGB_PM source-in RGB30") << QImage::Format_RGB30 << QImage::Format_ARGB32_Premultiplied
diff --git a/tests/auto/gui/painting/qpathclipper/paths.cpp b/tests/auto/gui/painting/qpathclipper/paths.cpp
index 077527e1a0..1328befd1b 100644
--- a/tests/auto/gui/painting/qpathclipper/paths.cpp
+++ b/tests/auto/gui/painting/qpathclipper/paths.cpp
@@ -578,7 +578,7 @@ QPainterPath Paths::node()
     m_rect.setHeight(100);
 
     QPainterPath shape;
-    shape.addRoundRect(m_rect, 25);
+    shape.addRoundedRect(m_rect, 25, Qt::RelativeSize);
 
     const int conWidth = 10;
     const int xOffset  = 7;
diff --git a/tests/auto/gui/painting/qpdfwriter/tst_qpdfwriter.cpp b/tests/auto/gui/painting/qpdfwriter/tst_qpdfwriter.cpp
index c1a8f7f0de..9e9b0db366 100644
--- a/tests/auto/gui/painting/qpdfwriter/tst_qpdfwriter.cpp
+++ b/tests/auto/gui/painting/qpdfwriter/tst_qpdfwriter.cpp
@@ -154,12 +154,7 @@ void tst_QPdfWriter::testPageMetrics()
 
     if (setMargins) {
         // Setup the given margins
-        QPdfWriter::Margins margins;
-        margins.left = leftMMf;
-        margins.right = rightMMf;
-        margins.top = topMMf;
-        margins.bottom = bottomMMf;
-        writer.setMargins(margins);
+        writer.setPageMargins({leftMMf, topMMf, rightMMf, bottomMMf}, QPageLayout::Millimeter);
         QCOMPARE(writer.margins().left, leftMMf);
         QCOMPARE(writer.margins().right, rightMMf);
         QCOMPARE(writer.margins().top, topMMf);
@@ -169,7 +164,7 @@ void tst_QPdfWriter::testPageMetrics()
 
     // Set the given size, in Portrait mode
     if (pageSize < 0) {
-        writer.setPageSizeMM(sizeMMf);
+        writer.setPageSize(QPageSize(sizeMMf, QPageSize::Millimeter));
         QCOMPARE(writer.pageSize(), QPdfWriter::Custom);
         QCOMPARE(writer.pageLayout().pageSize().id(), QPageSize::Custom);
     } else {
@@ -221,7 +216,7 @@ void tst_QPdfWriter::testPageMetrics()
 
     // Now while in Landscape mode, set the size again, results should be the same
     if (pageSize < 0) {
-        writer.setPageSizeMM(sizeMMf);
+        writer.setPageSize(QPageSize(sizeMMf, QPageSize::Millimeter));
         QCOMPARE(writer.pageSize(), QPdfWriter::Custom);
         QCOMPARE(writer.pageLayout().pageSize().id(), QPageSize::Custom);
     } else {
@@ -255,7 +250,7 @@ void tst_QPdfWriter::qtbug59443()
     QTemporaryFile file;
     QVERIFY2(file.open(), qPrintable(file.errorString()));
     QPdfWriter writer(file.fileName());
-    writer.setPageSize(QPdfWriter::A4);
+    writer.setPageSize(QPageSize(QPageSize::A4));
     QTextDocument doc;
     doc.documentLayout()->setPaintDevice(&writer);
 
diff --git a/tests/auto/gui/painting/qpen/tst_qpen.cpp b/tests/auto/gui/painting/qpen/tst_qpen.cpp
index ef65d653ce..295ae27d17 100644
--- a/tests/auto/gui/painting/qpen/tst_qpen.cpp
+++ b/tests/auto/gui/painting/qpen/tst_qpen.cpp
@@ -95,7 +95,7 @@ void tst_QPen::move()
     QPen p1(Qt::black);
 
     // check that moving does the right thing:
-    QPen p2 = qMove(p1); // could be move or copy construction, so don't check p1's state
+    QPen p2 = std::move(p1); // could be move or copy construction, so don't check p1's state
     QCOMPARE(p2.color(), QColor(Qt::black));
 
     // this, executed ehre, would crash:
@@ -110,7 +110,7 @@ void tst_QPen::move()
     QCOMPARE(p1.color(), QColor(Qt::yellow));
 
     // check that moved-from QPens p2, p3 can still be safely destroyed:
-    QPen p5 = qMove(p2);
+    QPen p5 = std::move(p2);
 
     // intentionally no more statements beyond this point
 }
@@ -120,7 +120,7 @@ void tst_QPen::move_assign()
     QPen p1(Qt::black), p2(Qt::white);
 
     // check that moving does the right thing:
-    p2 = qMove(p1); // could be move or copy assignment, so don't check p1's state
+    p2 = std::move(p1); // could be move or copy assignment, so don't check p1's state
     QCOMPARE(p2.color(), QColor(Qt::black));
 
     // check that move-assigned-from QPen p1 can still be used, albeit
@@ -137,7 +137,7 @@ void tst_QPen::move_assign()
 
     // check that moved-from QPens p2, p3 can still be safely destroyed:
     QPen p5;
-    p5 = qMove(p2);
+    p5 = std::move(p2);
 
     // intentionally no more statements beyond this point
 }