tst_qhashfunctions: Test non-zero seeds too

Change-Id: Ib0e40a7a3ebc44329f23fffd14b2e927021a1a2e
Reviewed-by: David Faure <david.faure@kdab.com>

1 files changed, 70 insertions, 44 deletions

diff --git a/tests/auto/corelib/tools/qhashfunctions/tst_qhashfunctions.cpp b/tests/auto/corelib/tools/qhashfunctions/tst_qhashfunctions.cpp
index 0c890eafbc..4a81adf9fe 100644
--- a/tests/auto/corelib/tools/qhashfunctions/tst_qhashfunctions.cpp
+++ b/tests/auto/corelib/tools/qhashfunctions/tst_qhashfunctions.cpp
@@ -37,11 +37,22 @@
 class tst_QHashFunctions : public QObject
 {
     Q_OBJECT
+public:
+    enum {
+        // random value
+        RandomSeed = 1045982819
+    };
+    uint seed;
+
+public slots:
+    void initTestCase();
+    void init();
+
 private Q_SLOTS:
     void qhash();
     void qhash_of_empty_and_null_qstring();
     void qhash_of_empty_and_null_qbytearray();
-    void fp_qhash_of_zero_is_zero();
+    void fp_qhash_of_zero_is_seed();
     void qthash_data();
     void qthash();
     void range();
@@ -50,12 +61,27 @@ private Q_SLOTS:
     void setGlobalQHashSeed();
 };
 
+void tst_QHashFunctions::initTestCase()
+{
+    Q_STATIC_ASSERT(int(RandomSeed) > 0);
+
+    QTest::addColumn<uint>("seedValue");
+    QTest::newRow("zero-seed") << 0U;
+    QTest::newRow("non-zero-seed") << uint(RandomSeed);
+}
+
+void tst_QHashFunctions::init()
+{
+    QFETCH_GLOBAL(uint, seedValue);
+    seed = seedValue;
+}
+
 void tst_QHashFunctions::qhash()
 {
     {
         QBitArray a1;
         QBitArray a2;
-        QVERIFY(qHash(a1) == 0);
+        QCOMPARE(qHash(a1, seed), seed);
 
         a1.resize(1);
         a1.setBit(0, true);
@@ -63,53 +89,53 @@ void tst_QHashFunctions::qhash()
         a2.resize(1);
         a2.setBit(0, false);
 
-        uint h1 = qHash(a1);
-        uint h2 = qHash(a2);
+        uint h1 = qHash(a1, seed);
+        uint h2 = qHash(a2, seed);
 
-        QVERIFY(h1 != h2);
+        QVERIFY(h1 != h2);  // not guaranteed
 
         a2.setBit(0, true);
-        QVERIFY(h1 == qHash(a2));
+        QVERIFY(h1 == qHash(a2, seed));
 
         a1.fill(true, 8);
         a1.resize(7);
 
-        h1 = qHash(a1);
+        h1 = qHash(a1, seed);
 
         a2.fill(true, 7);
-        h2 = qHash(a2);
+        h2 = qHash(a2, seed);
 
         QVERIFY(h1 == h2);
 
         a2.setBit(0, false);
-        uint h3 = qHash(a2);
-        QVERIFY(h2 != h3);
+        uint h3 = qHash(a2, seed);
+        QVERIFY(h2 != h3);  // not guaranteed
 
         a2.setBit(0, true);
-        QVERIFY(h2 == qHash(a2));
+        QVERIFY(h2 == qHash(a2, seed));
 
         a2.setBit(6, false);
-        uint h4 = qHash(a2);
-        QVERIFY(h2 != h4);
+        uint h4 = qHash(a2, seed);
+        QVERIFY(h2 != h4);  // not guaranteed
 
         a2.setBit(6, true);
-        QVERIFY(h2 == qHash(a2));
+        QVERIFY(h2 == qHash(a2, seed));
 
-        QVERIFY(h3 != h4);
+        QVERIFY(h3 != h4);  // not guaranteed
     }
 
     {
         QPair<int, int> p12(1, 2);
         QPair<int, int> p21(2, 1);
 
-        QVERIFY(qHash(p12) == qHash(p12));
-        QVERIFY(qHash(p21) == qHash(p21));
-        QVERIFY(qHash(p12) != qHash(p21));
+        QVERIFY(qHash(p12, seed) == qHash(p12, seed));
+        QVERIFY(qHash(p21, seed) == qHash(p21, seed));
+        QVERIFY(qHash(p12, seed) != qHash(p21, seed));  // not guaranteed
 
         QPair<int, int> pA(0x12345678, 0x12345678);
         QPair<int, int> pB(0x12345675, 0x12345675);
 
-        QVERIFY(qHash(pA) != qHash(pB));
+        QVERIFY(qHash(pA, seed) != qHash(pB, seed));    // not guaranteed
     }
 
     {
@@ -118,14 +144,14 @@ void tst_QHashFunctions::qhash()
 
         using QT_PREPEND_NAMESPACE(qHash);
 
-        QVERIFY(qHash(p12) == qHash(p12));
-        QVERIFY(qHash(p21) == qHash(p21));
-        QVERIFY(qHash(p12) != qHash(p21));
+        QVERIFY(qHash(p12, seed) == qHash(p12, seed));
+        QVERIFY(qHash(p21, seed) == qHash(p21, seed));
+        QVERIFY(qHash(p12, seed) != qHash(p21, seed));  // not guaranteed
 
         std::pair<int, int> pA(0x12345678, 0x12345678);
         std::pair<int, int> pB(0x12345675, 0x12345675);
 
-        QVERIFY(qHash(pA) != qHash(pB));
+        QVERIFY(qHash(pA, seed) != qHash(pB, seed));    // not guaranteed
     }
 }
 
@@ -133,27 +159,27 @@ void tst_QHashFunctions::qhash_of_empty_and_null_qstring()
 {
     QString null, empty("");
     QCOMPARE(null, empty);
-    QCOMPARE(qHash(null), qHash(empty));
+    QCOMPARE(qHash(null, seed), qHash(empty, seed));
 }
 
 void tst_QHashFunctions::qhash_of_empty_and_null_qbytearray()
 {
     QByteArray null, empty("");
     QCOMPARE(null, empty);
-    QCOMPARE(qHash(null), qHash(empty));
+    QCOMPARE(qHash(null, seed), qHash(empty, seed));
 }
 
-void tst_QHashFunctions::fp_qhash_of_zero_is_zero()
+void tst_QHashFunctions::fp_qhash_of_zero_is_seed()
 {
-    QCOMPARE(qHash(-0.0f), 0U);
-    QCOMPARE(qHash( 0.0f), 0U);
+    QCOMPARE(qHash(-0.0f, seed), seed);
+    QCOMPARE(qHash( 0.0f, seed), seed);
 
-    QCOMPARE(qHash(-0.0 ), 0U);
-    QCOMPARE(qHash( 0.0 ), 0U);
+    QCOMPARE(qHash(-0.0 , seed), seed);
+    QCOMPARE(qHash( 0.0 , seed), seed);
 
 #ifndef Q_OS_DARWIN
-    QCOMPARE(qHash(-0.0L), 0U);
-    QCOMPARE(qHash( 0.0L), 0U);
+    QCOMPARE(qHash(-0.0L, seed), seed);
+    QCOMPARE(qHash( 0.0L, seed), seed);
 #endif
 }
 
@@ -188,10 +214,10 @@ void tst_QHashFunctions::range()
     static const size_t numInts = sizeof ints / sizeof *ints;
 
     // empty range just gives the seed:
-    QCOMPARE(qHashRange(ints, ints, 0xdeadbeefU), 0xdeadbeefU);
-    // verify that order matters:
-    QVERIFY(qHashRange(ints, ints + numInts) !=
-            qHashRange(std::reverse_iterator<const int*>(ints + numInts), std::reverse_iterator<const int*>(ints)));
+    QCOMPARE(qHashRange(ints, ints, seed), seed);
+    // verify that order matters (test not guaranteed):
+    QVERIFY(qHashRange(ints, ints + numInts, seed) !=
+            qHashRange(std::reverse_iterator<const int*>(ints + numInts), std::reverse_iterator<const int*>(ints), seed));
 
     {
         // verify that the input iterator category suffices:
@@ -200,13 +226,13 @@ void tst_QHashFunctions::range()
         std::copy(ints, ints + numInts, std::ostream_iterator<int>(sstream, " "));
         sstream.seekg(0);
         std::istream_iterator<int> it(sstream), end;
-        QCOMPARE(qHashRange(ints, ints + numInts), qHashRange(it, end));
+        QCOMPARE(qHashRange(ints, ints + numInts, seed), qHashRange(it, end, seed));
     }
 
     SomeNamespace::Hashable hashables[] = {{0}, {1}, {2}, {3}, {4}, {5}};
     static const size_t numHashables = sizeof hashables / sizeof *hashables;
     // compile check: is qHash() found using ADL?
-    (void)qHashRange(hashables, hashables + numHashables);
+    (void)qHashRange(hashables, hashables + numHashables, seed);
 }
 
 void tst_QHashFunctions::rangeCommutative()
@@ -215,10 +241,10 @@ void tst_QHashFunctions::rangeCommutative()
     static const size_t numInts = sizeof ints / sizeof *ints;
 
     // empty range just gives the seed:
-    QCOMPARE(qHashRangeCommutative(ints, ints, 0xdeadbeefU), 0xdeadbeefU);
-    // verify that order doesn't matter:
-    QCOMPARE(qHashRangeCommutative(ints, ints + numInts),
-             qHashRangeCommutative(std::reverse_iterator<int*>(ints + numInts), std::reverse_iterator<int*>(ints)));
+    QCOMPARE(qHashRangeCommutative(ints, ints, seed), seed);
+    // verify that order doesn't matter (test not guaranteed):
+    QCOMPARE(qHashRangeCommutative(ints, ints + numInts, seed),
+             qHashRangeCommutative(std::reverse_iterator<int*>(ints + numInts), std::reverse_iterator<int*>(ints), seed));
 
     {
         // verify that the input iterator category suffices:
@@ -226,13 +252,13 @@ void tst_QHashFunctions::rangeCommutative()
         std::copy(ints, ints + numInts, std::ostream_iterator<int>(sstream, " "));
         sstream.seekg(0);
         std::istream_iterator<int> it(sstream), end;
-        QCOMPARE(qHashRangeCommutative(ints, ints + numInts), qHashRangeCommutative(it, end));
+        QCOMPARE(qHashRangeCommutative(ints, ints + numInts, seed), qHashRangeCommutative(it, end, seed));
     }
 
     SomeNamespace::Hashable hashables[] = {{0}, {1}, {2}, {3}, {4}, {5}};
     static const size_t numHashables = sizeof hashables / sizeof *hashables;
     // compile check: is qHash() found using ADL?
-    (void)qHashRangeCommutative(hashables, hashables + numHashables);
+    (void)qHashRangeCommutative(hashables, hashables + numHashables, seed);
 }
 
 void tst_QHashFunctions::setGlobalQHashSeed()