qt 6.5.1 original

tests/auto/corelib/tools/qcontiguouscache/CMakeLists.txt

@@ -0,0 +1,11 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
+#####################################################################
+## tst_qcontiguouscache Test:
+#####################################################################
+
+qt_internal_add_test(tst_qcontiguouscache
+    SOURCES
+        tst_qcontiguouscache.cpp
+)

tests/auto/corelib/tools/qcontiguouscache/tst_qcontiguouscache.cpp

@@ -0,0 +1,367 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+#include <QObject>
+#include <QTest>
+#include <QCache>
+#include <QContiguousCache>
+
+#include <QDebug>
+#include <stdio.h>
+
+class tst_QContiguousCache : public QObject
+{
+    Q_OBJECT
+private slots:
+    void assignment();
+
+    void empty();
+    void swap();
+
+    void append_data();
+    void append();
+
+    void prepend_data();
+    void prepend();
+
+    void complexType();
+
+    void operatorAt();
+
+    void setCapacity();
+
+    void zeroCapacity();
+    void modifyZeroCapacityCache();
+};
+
+QTEST_MAIN(tst_QContiguousCache)
+
+void tst_QContiguousCache::assignment()
+{
+    // compile-only test: QTBUG-45783
+   QContiguousCache<int> cc1, cc2;
+   // copy:
+   cc1 = cc2;
+   // move:
+   cc1 = std::move(cc2);
+}
+
+void tst_QContiguousCache::empty()
+{
+    QContiguousCache<int> c(10);
+    QCOMPARE(c.capacity(), 10);
+    QCOMPARE(c.size(), 0);
+    // NOLINTNEXTLINE(qt-port-to-std-compatible-api): Test both size() and count()
+    QCOMPARE(c.count(), 0);
+    QVERIFY(c.isEmpty());
+    c.append(1);
+    // NOLINTNEXTLINE(qt-port-to-std-compatible-api): Test both size() and count()
+    QCOMPARE(c.count(), 1);
+    QCOMPARE(c.size(), 1);
+    QVERIFY(!c.isEmpty());
+    c.clear();
+    QCOMPARE(c.capacity(), 10);
+    QCOMPARE(c.size(), 0);
+    QVERIFY(c.isEmpty());
+    c.prepend(1);
+    QCOMPARE(c.size(), 1);
+    QVERIFY(!c.isEmpty());
+    c.clear();
+    QCOMPARE(c.size(), 0);
+    QVERIFY(c.isEmpty());
+    QCOMPARE(c.capacity(), 10);
+}
+
+void tst_QContiguousCache::swap()
+{
+    QContiguousCache<int> c1(10), c2(100);
+    c1.append(1);
+    c1.swap(c2);
+    QCOMPARE(c1.capacity(), 100);
+    QCOMPARE(c1.size(),    0  );
+    QCOMPARE(c2.capacity(), 10 );
+    QCOMPARE(c2.size(),    1  );
+}
+
+void tst_QContiguousCache::append_data()
+{
+    QTest::addColumn<qsizetype>("start");
+    QTest::addColumn<qsizetype>("count");
+    QTest::addColumn<qsizetype>("cacheSize");
+    QTest::addColumn<bool>("invalidIndexes");
+
+    QTest::newRow("0+30[10]") << qsizetype(0) << qsizetype(30) << qsizetype(10) << false;
+    QTest::newRow("300+30[10]") << qsizetype(300) << qsizetype(30) << qsizetype(10) << false;
+    QTest::newRow("MAX-10+30[10]") << std::numeric_limits<qsizetype>::max()-10 << qsizetype(30) << qsizetype(10) << true;
+}
+
+void tst_QContiguousCache::append()
+{
+    QFETCH(qsizetype, start);
+    QFETCH(qsizetype, count);
+    QFETCH(qsizetype, cacheSize);
+    QFETCH(bool, invalidIndexes);
+
+    qsizetype i, j;
+    QContiguousCache<qsizetype> c(cacheSize);
+
+    i = 1;
+    QCOMPARE(c.available(), cacheSize);
+    if (start == 0)
+        c.append(i++);
+    else
+        c.insert(start, i++);
+    while (i < count) {
+        c.append(i);
+        QCOMPARE(c.available(), qMax(qsizetype(0), cacheSize - i));
+        QCOMPARE(c.first(), qMax(qsizetype(1), i-cacheSize+1));
+        QCOMPARE(c.last(), i);
+        QCOMPARE(c.size(), qMin(i, cacheSize));
+        QCOMPARE(c.isFull(), i >= cacheSize);
+        i++;
+    }
+
+    QCOMPARE(c.areIndexesValid(), !invalidIndexes);
+    if (invalidIndexes)
+        c.normalizeIndexes();
+    QVERIFY(c.areIndexesValid());
+
+    // test taking from end until empty.
+    for (j = 0; j < cacheSize; j++, i--) {
+        QCOMPARE(c.takeLast(), i-1);
+        QCOMPARE(c.size(), cacheSize-j-1);
+        QCOMPARE(c.available(), j+1);
+        QVERIFY(!c.isFull());
+        QCOMPARE(c.isEmpty(), j==cacheSize-1);
+    }
+
+}
+
+void tst_QContiguousCache::prepend_data()
+{
+    QTest::addColumn<int>("start");
+    QTest::addColumn<int>("count");
+    QTest::addColumn<int>("cacheSize");
+    QTest::addColumn<bool>("invalidIndexes");
+
+    QTest::newRow("30-30[10]") << 30 << 30 << 10 << false;
+    QTest::newRow("300-30[10]") << 300 << 30 << 10 << false;
+    QTest::newRow("10-30[10]") << 10 << 30 << 10 << true;
+}
+
+void tst_QContiguousCache::prepend()
+{
+    QFETCH(int, start);
+    QFETCH(int, count);
+    QFETCH(int, cacheSize);
+    QFETCH(bool, invalidIndexes);
+
+    int i, j;
+    QContiguousCache<int> c(cacheSize);
+
+    i = 1;
+    QCOMPARE(c.available(), cacheSize);
+    c.insert(start, i++);
+    while(i < count) {
+        c.prepend(i);
+        QCOMPARE(c.available(), qMax(0, cacheSize - i));
+        QCOMPARE(c.last(), qMax(1, i-cacheSize+1));
+        QCOMPARE(c.first(), i);
+        QCOMPARE(c.size(), qMin(i, cacheSize));
+        QCOMPARE(c.isFull(), i >= cacheSize);
+        i++;
+    }
+
+    QCOMPARE(c.areIndexesValid(), !invalidIndexes);
+    if (invalidIndexes)
+        c.normalizeIndexes();
+    QVERIFY(c.areIndexesValid());
+
+    // test taking from start until empty.
+    for (j = 0; j < cacheSize; j++, i--) {
+        QCOMPARE(c.takeFirst(), i-1);
+        QCOMPARE(c.size(), cacheSize-j-1);
+        QCOMPARE(c.available(), j+1);
+        QVERIFY(!c.isFull());
+        QCOMPARE(c.isEmpty(), j==cacheSize-1);
+    }
+}
+
+struct RefCountingClassData
+{
+    QBasicAtomicInt ref;
+    static RefCountingClassData shared_null;
+};
+
+RefCountingClassData RefCountingClassData::shared_null = {
+    Q_BASIC_ATOMIC_INITIALIZER(1)
+};
+
+class RefCountingClass
+{
+public:
+    RefCountingClass() : d(&RefCountingClassData::shared_null) { d->ref.ref(); }
+
+    RefCountingClass(const RefCountingClass &other)
+    {
+        d = other.d;
+        d->ref.ref();
+    }
+
+    ~RefCountingClass()
+    {
+        if (!d->ref.deref())
+            delete d;
+    }
+
+    RefCountingClass &operator=(const RefCountingClass &other)
+    {
+        if (!d->ref.deref())
+            delete d;
+        d = other.d;
+        d->ref.ref();
+        return *this;
+    }
+
+    int refCount() const { return d->ref.loadRelaxed(); }
+private:
+    RefCountingClassData *d;
+};
+
+void tst_QContiguousCache::complexType()
+{
+    RefCountingClass original;
+
+    QContiguousCache<RefCountingClass> contiguousCache(10);
+    contiguousCache.append(original);
+    QCOMPARE(original.refCount(), 3);
+    contiguousCache.removeFirst();
+    QCOMPARE(original.refCount(), 2); // shared null, 'original'.
+    contiguousCache.append(original);
+    QCOMPARE(original.refCount(), 3);
+    contiguousCache.clear();
+    QCOMPARE(original.refCount(), 2);
+
+    for(int i = 0; i < 100; ++i)
+        contiguousCache.insert(i, original);
+
+    QCOMPARE(original.refCount(), 12); // shared null, 'original', + 10 in contiguousCache.
+
+    contiguousCache.clear();
+    QCOMPARE(original.refCount(), 2);
+    for (int i = 0; i < 100; i++)
+        contiguousCache.append(original);
+
+    QCOMPARE(original.refCount(), 12); // shared null, 'original', + 10 in contiguousCache.
+    contiguousCache.clear();
+    QCOMPARE(original.refCount(), 2);
+
+    for (int i = 0; i < 100; i++)
+        contiguousCache.prepend(original);
+
+    QCOMPARE(original.refCount(), 12); // shared null, 'original', + 10 in contiguousCache.
+    contiguousCache.clear();
+    QCOMPARE(original.refCount(), 2);
+
+    for (int i = 0; i < 100; i++)
+        contiguousCache.append(original);
+
+    contiguousCache.takeLast();
+    QCOMPARE(original.refCount(), 11);
+
+    contiguousCache.takeFirst();
+    QCOMPARE(original.refCount(), 10);
+}
+
+void tst_QContiguousCache::operatorAt()
+{
+    RefCountingClass original;
+    QContiguousCache<RefCountingClass> contiguousCache(10);
+
+    for (int i = 25; i < 35; ++i)
+        contiguousCache[i] = original;
+
+    QCOMPARE(original.refCount(), 12); // shared null, orig, items in cache
+
+    // verify const access does not copy items.
+    const QContiguousCache<RefCountingClass> copy(contiguousCache);
+    for (int i = 25; i < 35; ++i)
+        QCOMPARE(copy[i].refCount(), 12);
+
+    // verify modifying the original increments ref count (e.g. does a detach)
+    contiguousCache[25] = original;
+    QCOMPARE(original.refCount(), 22);
+}
+
+void tst_QContiguousCache::setCapacity()
+{
+    int i;
+    QContiguousCache<int> contiguousCache(100);
+    for (i = 280; i < 310; ++i)
+        contiguousCache.insert(i, i);
+    QCOMPARE(contiguousCache.capacity(), 100);
+    QCOMPARE(contiguousCache.size(), 30);
+    QCOMPARE(contiguousCache.firstIndex(), 280);
+    QCOMPARE(contiguousCache.lastIndex(), 309);
+
+    for (i = contiguousCache.firstIndex(); i <= contiguousCache.lastIndex(); ++i) {
+        QVERIFY(contiguousCache.containsIndex(i));
+        QCOMPARE(contiguousCache.at(i), i);
+    }
+
+    contiguousCache.setCapacity(150);
+
+    QCOMPARE(contiguousCache.capacity(), 150);
+    QCOMPARE(contiguousCache.size(), 30);
+    QCOMPARE(contiguousCache.firstIndex(), 280);
+    QCOMPARE(contiguousCache.lastIndex(), 309);
+
+    for (i = contiguousCache.firstIndex(); i <= contiguousCache.lastIndex(); ++i) {
+        QVERIFY(contiguousCache.containsIndex(i));
+        QCOMPARE(contiguousCache.at(i), i);
+    }
+
+    contiguousCache.setCapacity(20);
+
+    QCOMPARE(contiguousCache.capacity(), 20);
+    QCOMPARE(contiguousCache.size(), 20);
+    QCOMPARE(contiguousCache.firstIndex(), 290);
+    QCOMPARE(contiguousCache.lastIndex(), 309);
+
+    for (i = contiguousCache.firstIndex(); i <= contiguousCache.lastIndex(); ++i) {
+        QVERIFY(contiguousCache.containsIndex(i));
+        QCOMPARE(contiguousCache.at(i), i);
+    }
+}
+
+void tst_QContiguousCache::zeroCapacity()
+{
+    QContiguousCache<int> contiguousCache;
+    QCOMPARE(contiguousCache.capacity(),0);
+    contiguousCache.setCapacity(10);
+    QCOMPARE(contiguousCache.capacity(),10);
+    contiguousCache.setCapacity(0);
+    QCOMPARE(contiguousCache.capacity(),0);
+}
+
+void tst_QContiguousCache::modifyZeroCapacityCache()
+{
+    {
+        QContiguousCache<int> contiguousCache;
+        contiguousCache.insert(0, 42);
+    }
+    {
+        QContiguousCache<int> contiguousCache;
+        contiguousCache.insert(1, 42);
+    }
+    {
+        QContiguousCache<int> contiguousCache;
+        contiguousCache.append(42);
+    }
+    {
+        QContiguousCache<int> contiguousCache;
+        contiguousCache.prepend(42);
+    }
+}
+
+#include "tst_qcontiguouscache.moc"