From dbd55cdaf367bdc9d6774bcb9927cbe19f18065f Mon Sep 17 00:00:00 2001
From: Giuseppe D'Angelo <giuseppe.dangelo@kdab.com>
Date: Tue, 25 Apr 2017 15:58:57 +0100
Subject: QHash/QMultiHash: fix operator==

The existing QHash::operator== does not work when the same
keys appear in different order between the two hashes being compared.
However, relying on iteration order on a QHash is (as usual) a bad
idea and one should never do it.

Task-number: QTBUG-60395
Change-Id: Ifb39a6779230e26bbd6fdba82ccc0247b9cdc6ed
Reviewed-by: Lars Knoll <lars.knoll@qt.io>
---
 tests/auto/corelib/tools/qhash/tst_qhash.cpp | 69 +++++++++++++++++++++++++++-
 1 file changed, 67 insertions(+), 2 deletions(-)

(limited to 'tests/auto/corelib/tools/qhash')

diff --git a/tests/auto/corelib/tools/qhash/tst_qhash.cpp b/tests/auto/corelib/tools/qhash/tst_qhash.cpp
index 0c5f1a7afb..943b4316ff 100644
--- a/tests/auto/corelib/tools/qhash/tst_qhash.cpp
+++ b/tests/auto/corelib/tools/qhash/tst_qhash.cpp
@@ -51,7 +51,7 @@ private slots:
     void contains(); // copied from tst_QMap
     void qhash();
     void take(); // copied from tst_QMap
-    void operator_eq(); // copied from tst_QMap
+    void operator_eq(); // slightly modified from tst_QMap
     void rehash_isnt_quadratic();
     void dont_need_default_constructor();
     void qmultihash_specific();
@@ -771,7 +771,7 @@ void tst_QHash::take()
     QVERIFY(!map.contains(3));
 }
 
-//copied from tst_QMap
+// slightly modified from tst_QMap
 void tst_QHash::operator_eq()
 {
     {
@@ -848,6 +848,71 @@ void tst_QHash::operator_eq()
         QVERIFY(a != b);
         QVERIFY(!(a == b));
     }
+
+    // unlike multi-maps, multi-hashes should be equal iff their contents are equal,
+    // regardless of insertion or iteration order
+
+    {
+        QHash<int, int> a;
+        QHash<int, int> b;
+
+        a.insertMulti(0, 0);
+        a.insertMulti(0, 1);
+
+        b.insertMulti(0, 1);
+        b.insertMulti(0, 0);
+
+        QVERIFY(a == b);
+        QVERIFY(!(a != b));
+    }
+
+    {
+        QHash<int, int> a;
+        QHash<int, int> b;
+
+        enum { Count = 100 };
+
+        for (int key = 0; key < Count; ++key) {
+            for (int value = 0; value < Count; ++value)
+                a.insertMulti(key, value);
+        }
+
+        for (int key = Count - 1; key >= 0; --key) {
+            for (int value = 0; value < Count; ++value)
+                b.insertMulti(key, value);
+        }
+
+        QVERIFY(a == b);
+        QVERIFY(!(a != b));
+    }
+
+    {
+        QHash<int, int> a;
+        QHash<int, int> b;
+
+        enum {
+            Count = 100,
+            KeyStep = 17,   // coprime with Count
+            ValueStep = 23, // coprime with Count
+        };
+
+        for (int key = 0; key < Count; ++key) {
+            for (int value = 0; value < Count; ++value)
+                a.insertMulti(key, value);
+        }
+
+        // Generates two permutations of [0, Count) for the keys and values,
+        // so that b will be identical to a, just built in a very different order.
+
+        for (int k = 0; k < Count; ++k) {
+           const int key = (k * KeyStep) % Count;
+           for (int v = 0; v < Count; ++v)
+               b.insertMulti(key, (v * ValueStep) % Count);
+        }
+
+        QVERIFY(a == b);
+        QVERIFY(!(a != b));
+    }
 }
 
 void tst_QHash::compare()
-- 
cgit v1.2.3