Remove QRegExp from QVariant

Add an operator QVariant() to QRegExp to keep things at source compatible
as possible.

Add a hack to QVariant::load/save() to recognize the old typeid
for QRegExp and stream them correctly as long as the streaming operators
for QRegExp are registered.

Also move the datastream test for QRegExp to tst_qregexp, and adjust it to
the qvariant changes.

Change-Id: I120b38a7541b43ec07a21b17f7f35c55f071eb75
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>

9 files changed, 184 insertions, 93 deletions

diff --git a/tests/auto/corelib/kernel/qmetatype/tst_qmetatype.h b/tests/auto/corelib/kernel/qmetatype/tst_qmetatype.h
index 22bcb69ac9..bf01fdcfcd 100644
--- a/tests/auto/corelib/kernel/qmetatype/tst_qmetatype.h
+++ b/tests/auto/corelib/kernel/qmetatype/tst_qmetatype.h
@@ -223,16 +223,6 @@ template<> struct TestValueFactory<QMetaType::QPersistentModelIndex> {
 template<> struct TestValueFactory<QMetaType::Nullptr> {
     static std::nullptr_t *create() { return new std::nullptr_t; }
 };
-template<> struct TestValueFactory<QMetaType::QRegExp> {
-    static QRegExp *create()
-    {
-#ifndef QT_NO_REGEXP
-        return new QRegExp("A*");
-#else
-        return 0;
-#endif
-    }
-};
 template<> struct TestValueFactory<QMetaType::QRegularExpression> {
     static QRegularExpression *create()
     {
diff --git a/tests/auto/corelib/kernel/qmetatype/typeFlags.bin b/tests/auto/corelib/kernel/qmetatype/typeFlags.bin
index 0aa282efc9..35d922a85c 100644
--- a/tests/auto/corelib/kernel/qmetatype/typeFlags.bin
+++ b/tests/auto/corelib/kernel/qmetatype/typeFlags.bin
diff --git a/tests/auto/corelib/kernel/qvariant/tst_qvariant.cpp b/tests/auto/corelib/kernel/qvariant/tst_qvariant.cpp
index 86465d25fb..c1c475b9c6 100644
--- a/tests/auto/corelib/kernel/qvariant/tst_qvariant.cpp
+++ b/tests/auto/corelib/kernel/qvariant/tst_qvariant.cpp
@@ -171,7 +171,6 @@ private slots:
 
     void toLocale();
 
-    void toRegExp();
     void toRegularExpression();
 
     void url();
@@ -1219,14 +1218,6 @@ void tst_QVariant::toLocale()
     loc = variant.toLocale();
 }
 
-void tst_QVariant::toRegExp()
-{
-    QVariant variant;
-    QRegExp rx = variant.toRegExp();
-    variant = QRegExp("foo");
-    rx = variant.toRegExp();
-}
-
 void tst_QVariant::toRegularExpression()
 {
     QVariant variant;
@@ -1320,8 +1311,6 @@ void tst_QVariant::writeToReadFromDataStream_data()
     QTest::newRow( "uint_valid" ) << QVariant( (uint)123 ) << false;
     QTest::newRow( "qchar" ) << QVariant(QChar('a')) << false;
     QTest::newRow( "qchar_null" ) << QVariant(QChar(0)) << true;
-    QTest::newRow( "regexp" ) << QVariant(QRegExp("foo", Qt::CaseInsensitive)) << false;
-    QTest::newRow( "regexp_empty" ) << QVariant(QRegExp()) << false;
     QTest::newRow( "regularexpression" ) << QVariant(QRegularExpression("abc.*def")) << false;
     QTest::newRow( "regularexpression_empty" ) << QVariant(QRegularExpression()) << false;
 
@@ -1768,7 +1757,6 @@ void tst_QVariant::typeName_data()
     QTest::newRow("38") << int(QVariant::LineF) << QByteArray("QLineF");
     QTest::newRow("39") << int(QVariant::RectF) << QByteArray("QRectF");
     QTest::newRow("40") << int(QVariant::PointF) << QByteArray("QPointF");
-    QTest::newRow("41") << int(QVariant::RegExp) << QByteArray("QRegExp");
     QTest::newRow("44") << int(QVariant::Transform) << QByteArray("QTransform");
     QTest::newRow("45") << int(QVariant::Hash) << QByteArray("QVariantHash");
     QTest::newRow("46") << int(QVariant::Matrix4x4) << QByteArray("QMatrix4x4");
@@ -3902,7 +3890,6 @@ void tst_QVariant::implicitConstruction()
     F(LineF) \
     F(Point) \
     F(PointF) \
-    F(RegExp) \
     F(EasingCurve) \
     F(Uuid) \
     F(ModelIndex) \
diff --git a/tests/auto/corelib/serialization/qdatastream/tst_qdatastream.cpp b/tests/auto/corelib/serialization/qdatastream/tst_qdatastream.cpp
index 419a8138a1..0687ce0ead 100644
--- a/tests/auto/corelib/serialization/qdatastream/tst_qdatastream.cpp
+++ b/tests/auto/corelib/serialization/qdatastream/tst_qdatastream.cpp
@@ -111,9 +111,6 @@ private slots:
     void stream_QString_data();
     void stream_QString();
 
-    void stream_QRegExp_data();
-    void stream_QRegExp();
-
 #if QT_CONFIG(regularexpression)
     void stream_QRegularExpression_data();
     void stream_QRegularExpression();
@@ -232,7 +229,6 @@ private:
     void writeQRegion(QDataStream *s);
     void writeQSize(QDataStream *s);
     void writeQString(QDataStream* dev);
-    void writeQRegExp(QDataStream* dev);
 #if QT_CONFIG(regularexpression)
     void writeQRegularExpression(QDataStream *dev);
 #endif
@@ -266,7 +262,6 @@ private:
     void readQRegion(QDataStream *s);
     void readQSize(QDataStream *s);
     void readQString(QDataStream *s);
-    void readQRegExp(QDataStream *s);
 #if QT_CONFIG(regularexpression)
     void readQRegularExpression(QDataStream *s);
 #endif
@@ -519,71 +514,6 @@ void tst_QDataStream::readQString(QDataStream *s)
 
 // ************************************
 
-static QRegExp QRegExpData(int index)
-{
-    switch (index) {
-    case 0: return QRegExp();
-    case 1: return QRegExp("");
-    case 2: return QRegExp("A", Qt::CaseInsensitive);
-    case 3: return QRegExp("ABCDE FGHI", Qt::CaseSensitive, QRegExp::Wildcard);
-    case 4: return QRegExp("This is a long string", Qt::CaseInsensitive, QRegExp::FixedString);
-    case 5: return QRegExp("And again a string with a \nCRLF", Qt::CaseInsensitive, QRegExp::RegExp);
-    case 6:
-        {
-            QRegExp rx("abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRESTUVWXYZ 1234567890 ~`!@#$%^&*()_-+={[}]|\\:;\"'<,>.?/");
-            rx.setMinimal(true);
-            return rx;
-        }
-    }
-    return QRegExp("foo");
-}
-#define MAX_QREGEXP_DATA 7
-
-void tst_QDataStream::stream_QRegExp_data()
-{
-    stream_data(MAX_QREGEXP_DATA);
-}
-
-void tst_QDataStream::stream_QRegExp()
-{
-    STREAM_IMPL(QRegExp);
-}
-
-void tst_QDataStream::writeQRegExp(QDataStream* s)
-{
-    QRegExp test(QRegExpData(dataIndex(QTest::currentDataTag())));
-    *s << test;
-    *s << QString("Her er det noe tekst");
-    *s << test;
-    *s << QString("nonempty");
-    *s << test;
-    *s << QVariant(test);
-}
-
-void tst_QDataStream::readQRegExp(QDataStream *s)
-{
-    QRegExp R;
-    QString S;
-    QVariant V;
-    QRegExp test(QRegExpData(dataIndex(QTest::currentDataTag())));
-
-    *s >> R;
-    QCOMPARE(R, test);
-    *s >> S;
-    QCOMPARE(S, QString("Her er det noe tekst"));
-    *s >> R;
-    QCOMPARE(R, test);
-    *s >> S;
-    QCOMPARE(S, QString("nonempty"));
-    *s >> R;
-    QCOMPARE(R, test);
-    *s >> V;
-    QCOMPARE(V.type(), QVariant::RegExp);
-    QCOMPARE(V.toRegExp(), test);
-}
-
-// ************************************
-
 #if QT_CONFIG(regularexpression)
 static QRegularExpression QRegularExpressionData(int index)
 {
diff --git a/tests/auto/corelib/kernel/qvariant/stream/qt4.9/qregexp.bin b/tests/auto/corelib/text/qregexp/data/qdatastream_4.9.bin
index db8518e064..db8518e064 100644
--- a/tests/auto/corelib/kernel/qvariant/stream/qt4.9/qregexp.bin
+++ b/tests/auto/corelib/text/qregexp/data/qdatastream_4.9.bin
diff --git a/tests/auto/corelib/kernel/qvariant/stream/qt5.0/qregexp.bin b/tests/auto/corelib/text/qregexp/data/qdatastream_5.0.bin
index db8518e064..db8518e064 100644
--- a/tests/auto/corelib/kernel/qvariant/stream/qt5.0/qregexp.bin
+++ b/tests/auto/corelib/text/qregexp/data/qdatastream_5.0.bin
diff --git a/tests/auto/corelib/text/qregexp/qregexp.pro b/tests/auto/corelib/text/qregexp/qregexp.pro
index 5f6ff0a71c..748e6a248c 100644
--- a/tests/auto/corelib/text/qregexp/qregexp.pro
+++ b/tests/auto/corelib/text/qregexp/qregexp.pro
@@ -2,3 +2,4 @@ CONFIG += testcase
 TARGET = tst_qregexp
 QT = core testlib
 SOURCES = tst_qregexp.cpp
+RESOURCES += qregexp.qrc
diff --git a/tests/auto/corelib/text/qregexp/qregexp.qrc b/tests/auto/corelib/text/qregexp/qregexp.qrc
new file mode 100644
index 0000000000..8fd168793f
--- /dev/null
+++ b/tests/auto/corelib/text/qregexp/qregexp.qrc
@@ -0,0 +1,6 @@
+<RCC>
+    <qresource prefix="/">
+        <file>data/qdatastream_4.9.bin</file>
+        <file>data/qdatastream_5.0.bin</file>
+    </qresource>
+</RCC>
diff --git a/tests/auto/corelib/text/qregexp/tst_qregexp.cpp b/tests/auto/corelib/text/qregexp/tst_qregexp.cpp
index b043d023ea..29ddf3673f 100644
--- a/tests/auto/corelib/text/qregexp/tst_qregexp.cpp
+++ b/tests/auto/corelib/text/qregexp/tst_qregexp.cpp
@@ -1,3 +1,4 @@
+
 /****************************************************************************
 **
 ** Copyright (C) 2016 The Qt Company Ltd.
@@ -83,6 +84,15 @@ private slots:
 
     void filterList();
     void replaceInList();
+
+    void datastream_data();
+    void datastream();
+
+    void datastream2();
+
+private:
+    void readQRegExp(QDataStream *s);
+    void writeQRegExp(QDataStream* dev);
 };
 
 // Testing get/set functions
@@ -1545,5 +1555,172 @@ void tst_QRegExp::replaceInList()
     QCOMPARE( list5, list6 );
 }
 
+static QRegExp QRegExpData(int index)
+{
+    switch (index) {
+    case 0: return QRegExp();
+    case 1: return QRegExp("");
+    case 2: return QRegExp("A", Qt::CaseInsensitive);
+    case 3: return QRegExp("ABCDE FGHI", Qt::CaseSensitive, QRegExp::Wildcard);
+    case 4: return QRegExp("This is a long string", Qt::CaseInsensitive, QRegExp::FixedString);
+    case 5: return QRegExp("And again a string with a \nCRLF", Qt::CaseInsensitive, QRegExp::RegExp);
+    case 6:
+        {
+            QRegExp rx("abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRESTUVWXYZ 1234567890 ~`!@#$%^&*()_-+={[}]|\\:;\"'<,>.?/");
+            rx.setMinimal(true);
+            return rx;
+        }
+    }
+    return QRegExp("foo");
+}
+#define MAX_QREGEXP_DATA 7
+
+void tst_QRegExp::datastream_data()
+{
+    QTest::addColumn<QString>("device");
+    QTest::addColumn<QString>("byteOrder");
+
+    const char * const devices[] = {
+        "file",
+        "bytearray",
+        "buffer",
+        0
+    };
+    for (int d=0; devices[d] != 0; d++) {
+        QString device = devices[d];
+        for (int b=0; b<2; b++) {
+            QString byte_order = b == 0 ? "BigEndian" : "LittleEndian";
+
+            QString tag = device + QLatin1Char('_') + byte_order;
+            for (int e = 0; e < MAX_QREGEXP_DATA; e++) {
+                QTest::newRow(qPrintable(tag + QLatin1Char('_') + QString::number(e))) << device << byte_order;
+            }
+        }
+    }
+}
+
+static int dataIndex(const QString &tag)
+{
+    int pos = tag.lastIndexOf(QLatin1Char('_'));
+    if (pos >= 0) {
+        int ret = 0;
+        QString count = tag.mid(pos + 1);
+        bool ok;
+        ret = count.toInt(&ok);
+        if (ok)
+            return ret;
+    }
+    return -1;
+}
+
+void tst_QRegExp::datastream()
+{
+    QFETCH(QString, device); \
+
+    qRegisterMetaTypeStreamOperators<QRegExp>("QRegExp");
+
+    if (device == "bytearray") { \
+        QByteArray ba; \
+        QDataStream sout(&ba, QIODevice::WriteOnly); \
+        writeQRegExp(&sout); \
+        QDataStream sin(&ba, QIODevice::ReadOnly); \
+        readQRegExp(&sin); \
+    } else if (device == "file") { \
+        QString fileName = "qdatastream.out"; \
+        QFile fOut(fileName); \
+        QVERIFY(fOut.open(QIODevice::WriteOnly)); \
+        QDataStream sout(&fOut); \
+        writeQRegExp(&sout); \
+        fOut.close(); \
+        QFile fIn(fileName); \
+        QVERIFY(fIn.open(QIODevice::ReadOnly)); \
+        QDataStream sin(&fIn); \
+        readQRegExp(&sin); \
+        fIn.close(); \
+    } else if (device == "buffer") { \
+        QByteArray ba(10000, '\0'); \
+        QBuffer bOut(&ba); \
+        bOut.open(QIODevice::WriteOnly); \
+        QDataStream sout(&bOut); \
+        writeQRegExp(&sout); \
+        bOut.close(); \
+        QBuffer bIn(&ba); \
+        bIn.open(QIODevice::ReadOnly); \
+        QDataStream sin(&bIn); \
+        readQRegExp(&sin); \
+        bIn.close(); \
+    }
+}
+
+static void saveQVariantFromDataStream(const QString &fileName, QDataStream::Version version)
+{
+
+    QFile file(fileName);
+    QVERIFY(file.open(QIODevice::ReadOnly));
+    QDataStream dataFileStream(&file);
+
+    QString typeName;
+    dataFileStream >> typeName;
+    QByteArray data = file.readAll();
+    const int id = QMetaType::type(typeName.toLatin1());
+
+    QBuffer buffer;
+    buffer.open(QIODevice::ReadWrite);
+    QDataStream stream(&buffer);
+    stream.setVersion(version);
+
+    QVariant constructedVariant(static_cast<QVariant::Type>(id));
+    QCOMPARE(constructedVariant.userType(), id);
+    stream << constructedVariant;
+
+    // We are testing QVariant there is no point in testing full array.
+    QCOMPARE(buffer.data().left(5), data.left(5));
+
+    buffer.seek(0);
+    QVariant recunstructedVariant;
+    stream >> recunstructedVariant;
+    QCOMPARE(recunstructedVariant.userType(), constructedVariant.userType());
+}
+
+void tst_QRegExp::datastream2()
+{
+    saveQVariantFromDataStream(QLatin1String(":/data/qdatastream_4.9.bin"), QDataStream::Qt_4_9);
+    saveQVariantFromDataStream(QLatin1String(":/data/qdatastream_5.0.bin"), QDataStream::Qt_5_0);
+}
+
+void tst_QRegExp::writeQRegExp(QDataStream* s)
+{
+    QRegExp test(QRegExpData(dataIndex(QTest::currentDataTag())));
+    *s << test;
+    *s << QString("Her er det noe tekst");
+    *s << test;
+    *s << QString("nonempty");
+    *s << test;
+    *s << QVariant(test);
+}
+
+void tst_QRegExp::readQRegExp(QDataStream *s)
+{
+    QRegExp R;
+    QString S;
+    QVariant V;
+    QRegExp test(QRegExpData(dataIndex(QTest::currentDataTag())));
+
+    *s >> R;
+    QCOMPARE(R, test);
+    *s >> S;
+    QCOMPARE(S, QString("Her er det noe tekst"));
+    *s >> R;
+    QCOMPARE(R, test);
+    *s >> S;
+    QCOMPARE(S, QString("nonempty"));
+    *s >> R;
+    QCOMPARE(R, test);
+    *s >> V;
+    QCOMPARE(V.userType(), qMetaTypeId<QRegExp>());
+    QCOMPARE(qvariant_cast<QRegExp>(V), test);
+}
+
+
 QTEST_APPLESS_MAIN(tst_QRegExp)
 #include "tst_qregexp.moc"