Q[Multi]Hash: fix squeeze()

When calling QHash::reserve(), or when creating the
internal QHashPrivate::Data structure, the value 0
for the size parameter is reserved for performing
the squeeze operation.

However commit 8a984ab772dd194e39094e728b869e65912912a7
broke it, by using the 0 value in QHashPrivate::Data
constructors as a mark that no resizing needs to be done.

This patch reverts the problematic commit (also applying
some later fixes to the code), and adds the missing
tests for Q[Multi]Hash::squeeze().

Pick-to: 6.3 6.2
Change-Id: Id644df7b2beb008e6a37b2c89b709adfbd893e25
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>

1 files changed, 94 insertions, 1 deletions

diff --git a/tests/auto/corelib/tools/qhash/tst_qhash.cpp b/tests/auto/corelib/tools/qhash/tst_qhash.cpp
index 6f59fe4436..994963781c 100644
--- a/tests/auto/corelib/tools/qhash/tst_qhash.cpp
+++ b/tests/auto/corelib/tools/qhash/tst_qhash.cpp
@@ -105,6 +105,9 @@ private slots:
     void detachAndReferences();
 
     void lookupUsingKeyIterator();
+
+    void squeeze();
+    void squeezeShared();
 };
 
 struct IdentityTracker {
@@ -2694,7 +2697,7 @@ void tst_QHash::reserveLessThanCurrentAmount()
 
         // Make sure that hash still has all elements
         for (int i = 0; i < 1000; ++i)
-            QCOMPARE(hash.values(i), QList<int>() << i * 10 + 1 << i * 10);
+            QCOMPARE(hash.values(i), QList<int>({ i * 10 + 1, i * 10 }));
     }
 }
 
@@ -2774,5 +2777,95 @@ void tst_QHash::lookupUsingKeyIterator()
         QVERIFY(!hash[*it].isEmpty());
 }
 
+void tst_QHash::squeeze()
+{
+    {
+        QHash<int, int> hash;
+        hash.reserve(1000);
+        for (int i = 0; i < 10; ++i)
+            hash.insert(i, i * 10);
+        QVERIFY(hash.isDetached());
+        const size_t buckets = hash.bucket_count();
+        const qsizetype size = hash.size();
+
+        hash.squeeze();
+
+        QVERIFY(hash.bucket_count() < buckets);
+        QCOMPARE(hash.size(), size);
+        for (int i = 0; i < size; ++i)
+            QCOMPARE(hash.value(i), i * 10);
+    }
+    {
+        QMultiHash<int, int> hash;
+        hash.reserve(1000);
+        for (int i = 0; i < 10; ++i) {
+            hash.insert(i, i * 10);
+            hash.insert(i, i * 10 + 1);
+        }
+        QVERIFY(hash.isDetached());
+        const size_t buckets = hash.bucket_count();
+        const qsizetype size = hash.size();
+
+        hash.squeeze();
+
+        QVERIFY(hash.bucket_count() < buckets);
+        QCOMPARE(hash.size(), size);
+        for (int i = 0; i < (size / 2); ++i)
+            QCOMPARE(hash.values(i), QList<int>({ i * 10 + 1, i * 10 }));
+    }
+}
+
+void tst_QHash::squeezeShared()
+{
+    {
+        QHash<int, int> hash;
+        hash.reserve(1000);
+        for (int i = 0; i < 10; ++i)
+            hash.insert(i, i * 10);
+
+        QHash<int, int> other = hash;
+
+        // Check that when squeezing a hash with shared d_ptr, the number of
+        // buckets actually decreases.
+        QVERIFY(!other.isDetached());
+        const size_t buckets = other.bucket_count();
+        const qsizetype size = other.size();
+
+        other.squeeze();
+
+        QCOMPARE(hash.bucket_count(), buckets);
+        QVERIFY(other.bucket_count() < buckets);
+
+        QCOMPARE(other.size(), size);
+        for (int i = 0; i < size; ++i)
+            QCOMPARE(other.value(i), i * 10);
+    }
+    {
+        QMultiHash<int, int> hash;
+        hash.reserve(1000);
+        for (int i = 0; i < 10; ++i) {
+            hash.insert(i, i * 10);
+            hash.insert(i, i * 10 + 1);
+        }
+
+        QMultiHash<int, int> other = hash;
+
+        // Check that when squeezing a hash with shared d_ptr, the number of
+        // buckets actually decreases.
+        QVERIFY(!other.isDetached());
+        const size_t buckets = other.bucket_count();
+        const qsizetype size = other.size();
+
+        other.squeeze();
+
+        QCOMPARE(hash.bucket_count(), buckets);
+        QVERIFY(other.bucket_count() < buckets);
+
+        QCOMPARE(other.size(), size);
+        for (int i = 0; i < (size / 2); ++i)
+            QCOMPARE(other.values(i), QList<int>({ i * 10 + 1, i * 10 }));
+    }
+}
+
 QTEST_APPLESS_MAIN(tst_QHash)
 #include "tst_qhash.moc"