Fixes for QPlaceResult + unit tests

-Comparing QPlaceResult objects resulted in a crash
due to a comparison function incorrectly calling itself recursively.
-Copying a QPlaceResult object did not copy the data fields
from QPlaceSearchResult

This patch fixes the above issues and also has a comprehensive
set of unit tests for QPlaceResult.

Task-number: QTBUG-26611

Change-Id: I9b6dcc90e5f061d2e268051c682291adf1b04c7b
Reviewed-by: Aaron McCarthy <aaron.mccarthy@nokia.com>

1 files changed, 129 insertions, 9 deletions

diff --git a/tests/auto/qgeocoordinate/qlocationtestutils_p.h b/tests/auto/qgeocoordinate/qlocationtestutils_p.h
index 67f7c322..c40441dd 100644
--- a/tests/auto/qgeocoordinate/qlocationtestutils_p.h
+++ b/tests/auto/qgeocoordinate/qlocationtestutils_p.h
@@ -42,21 +42,141 @@
 #ifndef QLOCATIONTESTUTILS_P_H
 #define QLOCATIONTESTUTILS_P_H
 
+#include <QDebug>
 #include <QString>
 #include <QTest>
 
-class QLocationTestUtils
+namespace QLocationTestUtils
 {
-public:
-    static bool hasDefaultSource();
-    static bool hasDefaultMonitor();
+    bool hasDefaultSource();
+    bool hasDefaultMonitor();
 
-    static QString addNmeaChecksumAndBreaks(const QString &sentence);
+    QString addNmeaChecksumAndBreaks(const QString &sentence);
 
-    static QString createRmcSentence(const QDateTime &dt);
-    static QString createGgaSentence(const QTime &time);
-    static QString createGgaSentence(int lat, int lng, const QTime &time);
-    static QString createZdaSentence(const QDateTime &dt);
+    QString createRmcSentence(const QDateTime &dt);
+    QString createGgaSentence(const QTime &time);
+    QString createGgaSentence(int lat, int lng, const QTime &time);
+    QString createZdaSentence(const QDateTime &dt);
+
+    //The purpose of compareEquality() is to test equality
+    //operators where it is expected that A == B.
+    template<typename A, typename B>
+    bool compareEquality(const A &first, const B &second) {
+        if (first != second) {
+            qWarning() << "compareEquality() failed: first != second";
+            return false;
+        }
+
+        if (second != first) {
+            qWarning() << "compareEquality() failed: second != first";
+            return false;
+        }
+
+        if (!(first == second)) {
+            qWarning() << "compareEquality() failed: !(first == second)";
+            return false;
+        }
+
+        if (!(second == first)) {
+            qWarning() << "compareEquality() failed: !(second == first)";
+            return false;
+        }
+
+        return true;
+    }
+
+    //The purpose of compareInequality() is to test equality
+    //operators where it is expected that A != B.
+    //Using !compareEquality(...) is not sufficient because
+    //only the first operator checked would end up being tested.
+    template<typename A, typename B>
+    bool compareInequality(const A &first, const B &second) {
+        if (!(first != second)){
+            qWarning() << "compareInequality() failed: !(first != second)";
+            return false;
+        }
+
+        if (!(second != first)) {
+            qWarning() << "compareInequality() failed: !(second != first)";
+            return false;
+        }
+
+        if (first == second) {
+            qWarning() << "compareInequality() failed: first == second)";
+            return false;
+        }
+
+        if (second == first) {
+            qWarning() << "compareInequality() failed: second == first";
+            return false;
+        }
+        return true;
+    }
+
+    // Tests conversions between sub and base classes
+    // TC (test case) must implement:
+    // SubClass initialSubObject();
+    // bool checkType(const BaseClass &)
+    // void detach(BaseClass *) - calls a mutator method, but doesn't actually modify the
+    //                            property to something different.
+    // void setSubClassProperty(SubClass *) - sets a property in the subclass instance
+    template<typename TC, typename BaseClass, typename SubClass>
+    void testConversion(TC *tc) {
+        SubClass sub = tc->initialSubObject();
+        //check conversion from SubClass -> BaseClass
+        //using assignment operator
+        BaseClass base;
+        base = sub;
+        QVERIFY(QLocationTestUtils::compareEquality(base, sub));
+        QVERIFY(tc->checkType(base));
+
+        //check comparing base classes
+        BaseClass base2;
+        base2 = sub;
+        QVERIFY(QLocationTestUtils::compareEquality(base, base2));
+
+        //check conversion from BaseClass -> SubClass
+        //using assignment operator
+        SubClass sub2;
+        sub2 = base;
+        QVERIFY(QLocationTestUtils::compareEquality(sub, sub2));
+        QVERIFY(tc->checkType(sub2));
+
+        //check that equality still holds with detachment of underlying data pointer
+        tc->detach(&base);
+        sub2 = base;
+        QVERIFY(QLocationTestUtils::compareEquality(sub, sub2));
+        QVERIFY(QLocationTestUtils::compareEquality(sub, base));
+        QVERIFY(QLocationTestUtils::compareEquality(base, base2));
+
+        //check that comparing objects are not the same
+        //when an underlying subclass field has been modified
+        tc->setSubClassProperty(&sub2);
+        base2 = sub2;
+        QVERIFY(QLocationTestUtils::compareInequality(sub, sub2));
+        QVERIFY(QLocationTestUtils::compareInequality(sub, base2));
+        QVERIFY(QLocationTestUtils::compareInequality(base, base2));
+
+        //check conversion from SubClass -> BaseClass
+        //using copy constructor
+        BaseClass base3(sub);
+        QVERIFY(QLocationTestUtils::compareEquality(sub, base3));
+        QVERIFY(QLocationTestUtils::compareEquality(base, base3));
+
+        //check conversion from BaseClass -> SubClass
+        //using copy constructor
+        SubClass sub3(base3);
+        QVERIFY(QLocationTestUtils::compareEquality(sub, sub3));
+
+        //check conversion to subclass using a default base class instance
+        BaseClass baseDefault;
+        SubClass subDefault;
+        SubClass sub4(baseDefault);
+        QVERIFY(QLocationTestUtils::compareEquality(sub4, subDefault));
+
+        SubClass sub5 = baseDefault;
+        QVERIFY(QLocationTestUtils::compareEquality(sub5, subDefault));
+    }
 };
 
 #endif