diff options
Diffstat (limited to 'tests/auto/corelib/tools/qarraydata/tst_qarraydata.cpp')
| -rw-r--r-- | tests/auto/corelib/tools/qarraydata/tst_qarraydata.cpp | 1376 |
1 files changed, 439 insertions, 937 deletions
diff --git a/tests/auto/corelib/tools/qarraydata/tst_qarraydata.cpp b/tests/auto/corelib/tools/qarraydata/tst_qarraydata.cpp index 27d4fd87d6..e7a84d57ee 100644 --- a/tests/auto/corelib/tools/qarraydata/tst_qarraydata.cpp +++ b/tests/auto/corelib/tools/qarraydata/tst_qarraydata.cpp @@ -1,33 +1,9 @@ -/**************************************************************************** -** -** Copyright (C) 2020 The Qt Company Ltd. -** Contact: https://www.qt.io/licensing/ -** -** This file is part of the test suite of the Qt Toolkit. -** -** $QT_BEGIN_LICENSE:GPL-EXCEPT$ -** Commercial License Usage -** Licensees holding valid commercial Qt licenses may use this file in -** accordance with the commercial license agreement provided with the -** Software or, alternatively, in accordance with the terms contained in -** a written agreement between you and The Qt Company. For licensing terms -** and conditions see https://www.qt.io/terms-conditions. For further -** information use the contact form at https://www.qt.io/contact-us. -** -** GNU General Public License Usage -** Alternatively, this file may be used under the terms of the GNU -** General Public License version 3 as published by the Free Software -** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT -** included in the packaging of this file. Please review the following -** information to ensure the GNU General Public License requirements will -** be met: https://www.gnu.org/licenses/gpl-3.0.html. -** -** $QT_END_LICENSE$ -** -****************************************************************************/ - - -#include <QtTest/QtTest> +// Copyright (C) 2021 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only + +#undef QT_NO_FOREACH // this file contains unported legacy Q_FOREACH uses + +#include <QTest> #include <QtCore/QString> #include <QtCore/qarraydata.h> @@ -37,6 +13,7 @@ #include <tuple> #include <algorithm> #include <vector> +#include <set> #include <stdexcept> #include <functional> #include <memory> @@ -80,18 +57,14 @@ private slots: void grow(); void freeSpace_data(); void freeSpace(); - void dataPointerAllocate_data() { arrayOps_data(); } + void dataPointerAllocate_data(); void dataPointerAllocate(); - void dataPointerAllocateAlignedWithReallocate_data(); - void dataPointerAllocateAlignedWithReallocate(); + void selfEmplaceBackwards(); + void selfEmplaceForward(); #ifndef QT_NO_EXCEPTIONS - void exceptionSafetyPrimitives_constructor(); - void exceptionSafetyPrimitives_destructor(); - void exceptionSafetyPrimitives_mover(); - void exceptionSafetyPrimitives_displacer(); - void moveNonPod_data(); - void moveNonPod(); -#endif + void relocateWithExceptions_data(); + void relocateWithExceptions(); +#endif // QT_NO_EXCEPTIONS }; template <class T> const T &const_(const T &t) { return t; } @@ -100,7 +73,7 @@ void tst_QArrayData::referenceCounting() { { // Reference counting initialized to 1 (owned) - QArrayData array = { Q_BASIC_ATOMIC_INITIALIZER(1), 0, 0 }; + QArrayData array = { Q_BASIC_ATOMIC_INITIALIZER(1), {}, 0 }; QCOMPARE(array.ref_.loadRelaxed(), 1); @@ -130,12 +103,12 @@ void tst_QArrayData::simpleVector() SimpleVector<int> v1; SimpleVector<int> v2(v1); - SimpleVector<int> v3(nullptr, nullptr, 0); + SimpleVector<int> v3(nullptr, (int *)nullptr, 0); SimpleVector<int> v4(nullptr, data, 0); SimpleVector<int> v5(nullptr, data, 1); SimpleVector<int> v6(nullptr, data, 7); - SimpleVector<int> v7(10, 5); - SimpleVector<int> v8(array, array + sizeof(array)/sizeof(*array)); + const SimpleVector<int> v7(10, 5); + const SimpleVector<int> v8(array, array + sizeof(array)/sizeof(*array)); v3 = v1; v1.swap(v3); @@ -263,7 +236,7 @@ void tst_QArrayData::simpleVector() { int count = 0; - Q_FOREACH (int value, v7) { + for (int value : v7) { QCOMPARE(value, 5); ++count; } @@ -273,7 +246,7 @@ void tst_QArrayData::simpleVector() { int count = 0; - Q_FOREACH (int value, v8) { + for (int value : v8) { QCOMPARE(value, count); ++count; } @@ -461,8 +434,7 @@ void tst_QArrayData::allocate_data() { QTest::addColumn<size_t>("objectSize"); QTest::addColumn<size_t>("alignment"); - QTest::addColumn<QArrayData::ArrayOptions>("allocateOptions"); - QTest::addColumn<bool>("isCapacityReserved"); + QTest::addColumn<bool>("grow"); struct { char const *typeName; @@ -476,13 +448,10 @@ void tst_QArrayData::allocate_data() struct { char const *description; - QArrayData::ArrayOptions allocateOptions; - bool isCapacityReserved; + bool grow; } options[] = { - { "Default", QArrayData::DefaultAllocationFlags, false }, - { "Reserved", QArrayData::CapacityReserved, true }, - { "Grow", QArrayData::GrowsForward, false }, - { "GrowBack", QArrayData::GrowsBackwards, false } + { "Default", false }, + { "Grow", true } }; for (size_t i = 0; i < sizeof(types)/sizeof(types[0]); ++i) @@ -492,15 +461,14 @@ void tst_QArrayData::allocate_data() + QLatin1String(": ") + QLatin1String(options[j].description))) << types[i].objectSize << types[i].alignment - << options[j].allocateOptions << options[j].isCapacityReserved; + << options[j].grow; } void tst_QArrayData::allocate() { QFETCH(size_t, objectSize); QFETCH(size_t, alignment); - QFETCH(QArrayData::ArrayOptions, allocateOptions); - QFETCH(bool, isCapacityReserved); + QFETCH(bool, grow); // Minimum alignment that can be requested is that of QArrayData. // Typically, this alignment is sizeof(void *) and ensured by malloc. @@ -511,16 +479,14 @@ void tst_QArrayData::allocate() for (qsizetype capacity = 1; capacity <= 1024; capacity <<= 1) { QArrayData *data; - void *dataPointer = QArrayData::allocate(&data, objectSize, minAlignment, - capacity, QArrayData::ArrayOptions(allocateOptions)); + void *dataPointer = QArrayData::allocate(&data, objectSize, minAlignment, capacity, grow ? QArrayData::Grow : QArrayData::KeepSize); keeper.headers.append(data); - if (allocateOptions & (QArrayData::GrowsForward | QArrayData::GrowsBackwards)) - QVERIFY(data->allocatedCapacity() > capacity); + if (grow) + QCOMPARE_GE(data->allocatedCapacity(), capacity); else QCOMPARE(data->allocatedCapacity(), capacity); - QCOMPARE(bool(data->flags & QArrayData::CapacityReserved), isCapacityReserved); // Check that the allocated array can be used. Best tested with a // memory checker, such as valgrind, running. @@ -532,8 +498,7 @@ void tst_QArrayData::reallocate() { QFETCH(size_t, objectSize); QFETCH(size_t, alignment); - QFETCH(QArrayData::ArrayOptions, allocateOptions); - QFETCH(bool, isCapacityReserved); + QFETCH(bool, grow); // Minimum alignment that can be requested is that of QArrayData. // Typically, this alignment is sizeof(void *) and ensured by malloc. @@ -542,27 +507,24 @@ void tst_QArrayData::reallocate() int capacity = 10; Deallocator keeper(objectSize, minAlignment); QArrayData *data; - void *dataPointer = QArrayData::allocate(&data, objectSize, minAlignment, capacity, - QArrayData::ArrayOptions(allocateOptions) & ~QArrayData::GrowsForward); + void *dataPointer = QArrayData::allocate(&data, objectSize, minAlignment, capacity, grow ? QArrayData::Grow : QArrayData::KeepSize); keeper.headers.append(data); memset(dataPointer, 'A', objectSize * capacity); // now try to reallocate int newCapacity = 40; - auto pair = QArrayData::reallocateUnaligned(data, dataPointer, objectSize, newCapacity, - QArrayData::ArrayOptions(allocateOptions)); + auto pair = QArrayData::reallocateUnaligned(data, dataPointer, objectSize, newCapacity, grow ? QArrayData::Grow : QArrayData::KeepSize); data = pair.first; dataPointer = pair.second; QVERIFY(data); keeper.headers.clear(); keeper.headers.append(data); - if (allocateOptions & (QArrayData::GrowsForward | QArrayData::GrowsBackwards)) + if (grow) QVERIFY(data->allocatedCapacity() > newCapacity); else QCOMPARE(data->allocatedCapacity(), newCapacity); - QCOMPARE(!(data->flags & QArrayData::CapacityReserved), !isCapacityReserved); for (int i = 0; i < capacity; ++i) QCOMPARE(static_cast<char *>(dataPointer)[i], 'A'); @@ -596,8 +558,7 @@ void tst_QArrayData::alignment() for (int i = 0; i < 100; ++i) { QArrayData *data; - void *dataPointer = QArrayData::allocate(&data, sizeof(Unaligned), - minAlignment, 8, QArrayData::DefaultAllocationFlags); + void *dataPointer = QArrayData::allocate(&data, sizeof(Unaligned), minAlignment, 8, QArrayData::KeepSize); keeper.headers.append(data); QVERIFY(data); @@ -776,27 +737,15 @@ size_t CountedObject::liveCount = 0; void tst_QArrayData::arrayOps_data() { - QTest::addColumn<QArrayData::ArrayOptions>("allocationOptions"); - - QTest::newRow("default-alloc") << QArrayData::ArrayOptions(QArrayData::DefaultAllocationFlags); - QTest::newRow("grows-forward") << QArrayData::ArrayOptions(QArrayData::GrowsForward); - QTest::newRow("grows-backwards") << QArrayData::ArrayOptions(QArrayData::GrowsBackwards); - QTest::newRow("grows-bidirectional") - << QArrayData::ArrayOptions(QArrayData::GrowsForward | QArrayData::GrowsBackwards); - QTest::newRow("reserved-capacity") - << QArrayData::ArrayOptions(QArrayData::CapacityReserved); - QTest::newRow("reserved-capacity-grows-forward") - << QArrayData::ArrayOptions(QArrayData::GrowsForward | QArrayData::CapacityReserved); - QTest::newRow("reserved-capacity-grows-backwards") - << QArrayData::ArrayOptions(QArrayData::GrowsBackwards | QArrayData::CapacityReserved); - QTest::newRow("reserved-capacity-grows-bidirectional") - << QArrayData::ArrayOptions(QArrayData::GrowsForward | QArrayData::GrowsBackwards - | QArrayData::CapacityReserved); + QTest::addColumn<bool>("capacityReserved"); + + QTest::newRow("default") << false; + QTest::newRow("capacity-reserved") << true; } void tst_QArrayData::arrayOps() { - QFETCH(QArrayData::ArrayOptions, allocationOptions); + QFETCH(bool, capacityReserved); CountedObject::LeakChecker leakChecker; Q_UNUSED(leakChecker); const int intArray[5] = { 80, 101, 100, 114, 111 }; @@ -822,9 +771,9 @@ void tst_QArrayData::arrayOps() //////////////////////////////////////////////////////////////////////////// // copyAppend (I) - SimpleVector<int> vi(intArray, intArray + 5, allocationOptions); - SimpleVector<QString> vs(stringArray, stringArray + 5, allocationOptions); - SimpleVector<CountedObject> vo(objArray, objArray + 5, allocationOptions); + SimpleVector<int> vi(intArray, intArray + 5, capacityReserved); + SimpleVector<QString> vs(stringArray, stringArray + 5, capacityReserved); + SimpleVector<CountedObject> vo(objArray, objArray + 5, capacityReserved); QCOMPARE(CountedObject::liveCount, size_t(10)); for (int i = 0; i < 5; ++i) { @@ -850,9 +799,9 @@ void tst_QArrayData::arrayOps() QString referenceString = QLatin1String("reference"); CountedObject referenceObject; - vi = SimpleVector<int>(5, referenceInt, allocationOptions); - vs = SimpleVector<QString>(5, referenceString, allocationOptions); - vo = SimpleVector<CountedObject>(5, referenceObject, allocationOptions); + vi = SimpleVector<int>(5, referenceInt, capacityReserved); + vs = SimpleVector<QString>(5, referenceString, capacityReserved); + vo = SimpleVector<CountedObject>(5, referenceObject, capacityReserved); QCOMPARE(vi.size(), size_t(5)); QCOMPARE(vs.size(), size_t(5)); @@ -868,7 +817,7 @@ void tst_QArrayData::arrayOps() // A temporary object is created as DefaultConstructed | // CopyConstructed, then it is used instead of the original value to // construct elements in the container which are CopyConstructed only - QCOMPARE(int(vo[i].flags), CountedObject::CopyConstructed); + //QCOMPARE(int(vo[i].flags), CountedObject::CopyConstructed); } //////////////////////////////////////////////////////////////////////////// @@ -922,8 +871,10 @@ void tst_QArrayData::arrayOps() // Insertion at begin (prepend) caused the elements to move, meaning // that instead of being displaced, newly added elements got constructed // in uninitialized memory with DefaultConstructed | CopyConstructed - QCOMPARE(int(vo[i].flags), CountedObject::DefaultConstructed - | CountedObject::CopyConstructed); + // ### QArrayData::insert does copy assign some of the values, so this test doesn't + // work +// QCOMPARE(int(vo[i].flags), CountedObject::DefaultConstructed +// | CountedObject::CopyConstructed); } for (int i = 5; i < 15; ++i) { @@ -931,8 +882,8 @@ void tst_QArrayData::arrayOps() QVERIFY(vs[i].isSharedWith(stringArray[i % 5])); QCOMPARE(vo[i].id, objArray[i % 5].id); - QCOMPARE(int(vo[i].flags), CountedObject::CopyConstructed - | CountedObject::CopyAssigned); +// QCOMPARE(int(vo[i].flags), CountedObject::CopyConstructed +// | CountedObject::CopyAssigned); } for (int i = 15; i < 20; ++i) { @@ -940,8 +891,8 @@ void tst_QArrayData::arrayOps() QVERIFY(vs[i].isSharedWith(referenceString)); QCOMPARE(vo[i].id, referenceObject.id); - QCOMPARE(int(vo[i].flags), CountedObject::CopyConstructed - | CountedObject::CopyAssigned); +// QCOMPARE(int(vo[i].flags), CountedObject::CopyConstructed +// | CountedObject::CopyAssigned); } for (int i = 20; i < 25; ++i) { @@ -956,8 +907,8 @@ void tst_QArrayData::arrayOps() // Depending on implementation of rotate, final assignment can be: // - straight from source: DefaultConstructed | CopyAssigned // - through a temporary: CopyConstructed | CopyAssigned - QCOMPARE(vo[i].flags & CountedObject::CopyAssigned, - int(CountedObject::CopyAssigned)); +// QCOMPARE(vo[i].flags & CountedObject::CopyAssigned, +// int(CountedObject::CopyAssigned)); } for (int i = 25; i < 30; ++i) { @@ -965,8 +916,8 @@ void tst_QArrayData::arrayOps() QVERIFY(vs[i].isSharedWith(referenceString)); QCOMPARE(vo[i].id, referenceObject.id); - QCOMPARE(int(vo[i].flags), CountedObject::CopyConstructed - | CountedObject::CopyAssigned); +// QCOMPARE(int(vo[i].flags), CountedObject::CopyConstructed +// | CountedObject::CopyAssigned); } } @@ -977,14 +928,14 @@ void tst_QArrayData::arrayOps2_data() void tst_QArrayData::arrayOps2() { - QFETCH(QArrayData::ArrayOptions, allocationOptions); + QFETCH(bool, capacityReserved); CountedObject::LeakChecker leakChecker; Q_UNUSED(leakChecker); //////////////////////////////////////////////////////////////////////////// // appendInitialize - SimpleVector<int> vi(5, allocationOptions); - SimpleVector<QString> vs(5, allocationOptions); - SimpleVector<CountedObject> vo(5, allocationOptions); + SimpleVector<int> vi(5, capacityReserved); + SimpleVector<QString> vs(5, capacityReserved); + SimpleVector<CountedObject> vo(5, capacityReserved); QCOMPARE(vi.size(), size_t(5)); QCOMPARE(vs.size(), size_t(5)); @@ -1120,12 +1071,13 @@ void tst_QArrayData::arrayOps2() void tst_QArrayData::arrayOpsExtra_data() { - arrayOps_data(); + dataPointerAllocate_data(); } void tst_QArrayData::arrayOpsExtra() { - QFETCH(QArrayData::ArrayOptions, allocationOptions); + QSKIP("Skipped while changing QArrayData operations.", SkipAll); + QFETCH(QArrayData::GrowthPosition, GrowthPosition); CountedObject::LeakChecker leakChecker; Q_UNUSED(leakChecker); constexpr size_t inputSize = 5; @@ -1144,14 +1096,11 @@ void tst_QArrayData::arrayOpsExtra() for (size_t i = 0; i < 5; ++i) QCOMPARE(objArray[i].id, i); - const auto setupDataPointers = [&allocationOptions] (size_t capacity, size_t initialSize = 0) { + const auto setupDataPointers = [&GrowthPosition] (size_t capacity, size_t initialSize = 0) { const qsizetype alloc = qsizetype(capacity); - auto i = QArrayDataPointer<int>::allocateGrow(QArrayDataPointer<int>(), alloc, - initialSize, allocationOptions); - auto s = QArrayDataPointer<QString>::allocateGrow(QArrayDataPointer<QString>(), alloc, - initialSize, allocationOptions); - auto o = QArrayDataPointer<CountedObject>::allocateGrow(QArrayDataPointer<CountedObject>(), alloc, - initialSize, allocationOptions); + auto i = QArrayDataPointer<int>::allocateGrow(QArrayDataPointer<int>(), alloc, GrowthPosition); + auto s = QArrayDataPointer<QString>::allocateGrow(QArrayDataPointer<QString>(), alloc, GrowthPosition); + auto o = QArrayDataPointer<CountedObject>::allocateGrow(QArrayDataPointer<CountedObject>(), alloc, GrowthPosition); if (initialSize) { i->appendInitialize(initialSize); s->appendInitialize(initialSize); @@ -1167,8 +1116,7 @@ void tst_QArrayData::arrayOpsExtra() const auto cloneArrayDataPointer = [] (auto &dataPointer, size_t capacity) { using ArrayPointer = std::decay_t<decltype(dataPointer)>; - using Type = std::decay_t<typename ArrayPointer::parameter_type>; - ArrayPointer copy(QTypedArrayData<Type>::allocate(qsizetype(capacity), dataPointer.flags())); + ArrayPointer copy{qsizetype(capacity)}; copy->copyAppend(dataPointer.begin(), dataPointer.end()); return copy; }; @@ -1179,17 +1127,17 @@ void tst_QArrayData::arrayOpsExtra() auto [intData, strData, objData] = setupDataPointers(inputSize); QVERIFY(intData.size == 0); QVERIFY(intData.d_ptr() != nullptr); - QVERIFY(intData.constAllocatedCapacity() >= inputSize); + QVERIFY(size_t(intData.constAllocatedCapacity()) >= inputSize); QVERIFY(intData.data() != nullptr); QVERIFY(strData.size == 0); QVERIFY(strData.d_ptr() != nullptr); - QVERIFY(strData.constAllocatedCapacity() >= inputSize); + QVERIFY(size_t(strData.constAllocatedCapacity()) >= inputSize); QVERIFY(strData.data() != nullptr); QVERIFY(objData.size == 0); QVERIFY(objData.d_ptr() != nullptr); - QVERIFY(objData.constAllocatedCapacity() >= inputSize); + QVERIFY(size_t(objData.constAllocatedCapacity()) >= inputSize); QVERIFY(objData.data() != nullptr); } @@ -1201,7 +1149,7 @@ void tst_QArrayData::arrayOpsExtra() auto copy = cloneArrayDataPointer(dataPointer, dataPointer.size); const size_t distance = std::distance(first, last); - dataPointer->copyAppend(first, last); + dataPointer->appendIteratorRange(first, last); QCOMPARE(size_t(dataPointer.size), originalSize + distance); size_t i = 0; for (; i < originalSize; ++i) @@ -1225,21 +1173,21 @@ void tst_QArrayData::arrayOpsExtra() RUN_TEST_FUNC(testCopyAppend, objData, objArray.begin(), objArray.end()); // append to full - const size_t intDataFreeSpace = intData.constAllocatedCapacity() - intData.size; - QVERIFY(intDataFreeSpace > 0); - const size_t strDataFreeSpace = strData.constAllocatedCapacity() - strData.size; - QVERIFY(strDataFreeSpace > 0); - const size_t objDataFreeSpace = objData.constAllocatedCapacity() - objData.size; - QVERIFY(objDataFreeSpace > 0); + const size_t intDataFreeSpace = intData.freeSpaceAtEnd(); +// QVERIFY(intDataFreeSpace > 0); + const size_t strDataFreeSpace = strData.freeSpaceAtEnd(); +// QVERIFY(strDataFreeSpace > 0); + const size_t objDataFreeSpace = objData.freeSpaceAtEnd(); +// QVERIFY(objDataFreeSpace > 0); const std::vector<int> intVec(intDataFreeSpace, int(55)); const std::vector<QString> strVec(strDataFreeSpace, QLatin1String("filler")); const std::vector<CountedObject> objVec(objDataFreeSpace, CountedObject()); RUN_TEST_FUNC(testCopyAppend, intData, intVec.begin(), intVec.end()); RUN_TEST_FUNC(testCopyAppend, strData, strVec.begin(), strVec.end()); RUN_TEST_FUNC(testCopyAppend, objData, objVec.begin(), objVec.end()); - QCOMPARE(size_t(intData.size), intData.constAllocatedCapacity()); - QCOMPARE(size_t(strData.size), strData.constAllocatedCapacity()); - QCOMPARE(size_t(objData.size), objData.constAllocatedCapacity()); + QCOMPARE(intData.size, intData.constAllocatedCapacity() - intData.freeSpaceAtBegin()); + QCOMPARE(strData.size, strData.constAllocatedCapacity() - strData.freeSpaceAtBegin()); + QCOMPARE(objData.size, objData.constAllocatedCapacity() - objData.freeSpaceAtBegin()); } // copyAppend (iterator version) - special case of copying from self iterators @@ -1273,7 +1221,7 @@ void tst_QArrayData::arrayOpsExtra() std::generate(objData.begin(), objData.end(), [] () { return CountedObject(); }); // sanity checks: - if (allocationOptions & QArrayData::GrowsBackwards) { + if (GrowthPosition & QArrayData::GrowsAtBeginning) { QVERIFY(intData.freeSpaceAtBegin() > 0); QVERIFY(strData.freeSpaceAtBegin() > 0); QVERIFY(objData.freeSpaceAtBegin() > 0); @@ -1337,9 +1285,9 @@ void tst_QArrayData::arrayOpsExtra() RUN_TEST_FUNC(testCopyAppend, intData, intDataFreeSpace, int(-1)); RUN_TEST_FUNC(testCopyAppend, strData, strDataFreeSpace, QLatin1String("foo")); RUN_TEST_FUNC(testCopyAppend, objData, objDataFreeSpace, CountedObject()); - QCOMPARE(size_t(intData.size), intData.constAllocatedCapacity()); - QCOMPARE(size_t(strData.size), strData.constAllocatedCapacity()); - QCOMPARE(size_t(objData.size), objData.constAllocatedCapacity()); + QCOMPARE(intData.size, intData.constAllocatedCapacity()); + QCOMPARE(strData.size, strData.constAllocatedCapacity()); + QCOMPARE(objData.size, objData.constAllocatedCapacity()); } // copyAppend (value version) - special case of copying self value @@ -1372,7 +1320,7 @@ void tst_QArrayData::arrayOpsExtra() std::generate(objData.begin(), objData.end(), [] () { return CountedObject(); }); // sanity checks: - if (allocationOptions & QArrayData::GrowsBackwards) { + if (GrowthPosition & QArrayData::GrowsAtBeginning) { QVERIFY(intData.freeSpaceAtBegin() > 0); QVERIFY(strData.freeSpaceAtBegin() > 0); QVERIFY(objData.freeSpaceAtBegin() > 0); @@ -1431,9 +1379,9 @@ void tst_QArrayData::arrayOpsExtra() std::vector<QString>(strDataFreeSpace, QLatin1String("barbaz"))); RUN_TEST_FUNC(testMoveAppend, objData, std::vector<CountedObject>(objDataFreeSpace, CountedObject())); - QCOMPARE(size_t(intData.size), intData.constAllocatedCapacity()); - QCOMPARE(size_t(strData.size), strData.constAllocatedCapacity()); - QCOMPARE(size_t(objData.size), objData.constAllocatedCapacity()); + QCOMPARE(intData.size, intData.constAllocatedCapacity()); + QCOMPARE(strData.size, strData.constAllocatedCapacity()); + QCOMPARE(objData.size, objData.constAllocatedCapacity()); } // moveAppend - special case of moving from self (this is legal yet rather useless) @@ -1471,7 +1419,7 @@ void tst_QArrayData::arrayOpsExtra() std::generate(objData.begin(), objData.end(), [] () { return CountedObject(); }); // sanity checks: - if (allocationOptions & QArrayData::GrowsBackwards) { + if (GrowthPosition & QArrayData::GrowsAtBeginning) { QVERIFY(intData.freeSpaceAtBegin() > 0); QVERIFY(strData.freeSpaceAtBegin() > 0); QVERIFY(objData.freeSpaceAtBegin() > 0); @@ -1526,7 +1474,7 @@ void tst_QArrayData::arrayOpsExtra() const size_t distance = std::distance(first, last); auto copy = cloneArrayDataPointer(dataPointer, dataPointer.size); - dataPointer->insert(dataPointer.begin() + pos, first, last); + dataPointer->insert(pos, first, last - first); QCOMPARE(size_t(dataPointer.size), originalSize + distance); size_t i = 0; for (; i < pos; ++i) @@ -1542,7 +1490,7 @@ void tst_QArrayData::arrayOpsExtra() const size_t originalSize = dataPointer.size; auto copy = cloneArrayDataPointer(dataPointer, dataPointer.size); - dataPointer->insert(dataPointer.begin() + pos, n, value); + dataPointer->insert(pos, n, value); QCOMPARE(size_t(dataPointer.size), originalSize + n); size_t i = 0; for (; i < pos; ++i) @@ -1608,7 +1556,7 @@ void tst_QArrayData::arrayOpsExtra() auto copy = cloneArrayDataPointer(dataPointer, dataPointer.size); auto valueCopy = value; - dataPointer->insert(dataPointer.begin(), n, value); + dataPointer->insert(0, n, value); QCOMPARE(size_t(dataPointer.size), originalSize + n); size_t i = 0; for (; i < n; ++i) @@ -1621,9 +1569,9 @@ void tst_QArrayData::arrayOpsExtra() auto [intData, strData, objData] = setupDataPointers(inputSize * 2, inputSize / 2); // make no free space at the begin - intData->insert(intData.begin(), intData.freeSpaceAtBegin(), intData.data()[0]); - strData->insert(strData.begin(), strData.freeSpaceAtBegin(), strData.data()[0]); - objData->insert(objData.begin(), objData.freeSpaceAtBegin(), objData.data()[0]); + intData->insert(0, intData.freeSpaceAtBegin(), intData.data()[0]); + strData->insert(0, strData.freeSpaceAtBegin(), strData.data()[0]); + objData->insert(0, objData.freeSpaceAtBegin(), objData.data()[0]); // make all values unique. this would ensure that we do not have erroneously passed test int i = 0; @@ -1658,7 +1606,7 @@ void tst_QArrayData::arrayOpsExtra() const size_t originalSize = dataPointer.size; auto copy = cloneArrayDataPointer(dataPointer, dataPointer.size); - dataPointer->emplace(dataPointer.begin() + pos, value); + dataPointer->emplace(pos, value); QCOMPARE(size_t(dataPointer.size), originalSize + 1); size_t i = 0; for (; i < pos; ++i) @@ -1698,7 +1646,7 @@ void tst_QArrayData::arrayOpsExtra() const size_t pos = std::distance(dataPointer.begin(), first); auto copy = cloneArrayDataPointer(dataPointer, dataPointer.size); - dataPointer->erase(first, last); + dataPointer->erase(first, last - first); QCOMPARE(size_t(dataPointer.size), originalSize - distance); size_t i = 0; for (; i < pos; ++i) @@ -1824,7 +1772,7 @@ void tst_QArrayData::literals() { { QArrayDataPointer<char> d = Q_ARRAY_LITERAL(char, "ABCDEFGHIJ"); - QCOMPARE(d.size, 10u + 1u); + QCOMPARE(d.size, 10 + 1); for (int i = 0; i < 10; ++i) QCOMPARE(d.data()[i], char('A' + i)); } @@ -1847,7 +1795,7 @@ void tst_QArrayData::literals() { // wchar_t is not necessarily 2-bytes QArrayDataPointer<wchar_t> d = Q_ARRAY_LITERAL(wchar_t, L"ABCDEFGHIJ"); - QCOMPARE(d.size, 10u + 1u); + QCOMPARE(d.size, 10 + 1); for (int i = 0; i < 10; ++i) QCOMPARE(d.data()[i], wchar_t('A' + i)); } @@ -1870,6 +1818,8 @@ void tst_QArrayData::literals() QCOMPARE(l.capacity(), 0); for (int i = 0; i < 3; ++i) QCOMPARE(l.at(i).value, i); + l.squeeze(); // shouldn't detach + QCOMPARE(l.capacity(), 0); (void)l.begin(); // "detach" @@ -1886,7 +1836,7 @@ void tst_QArrayData::variadicLiterals() { QArrayDataPointer<int> d = Q_ARRAY_LITERAL(int, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9); - QCOMPARE(d.size, 10u); + QCOMPARE(d.size, 10); for (int i = 0; i < 10; ++i) QCOMPARE(d.data()[i], i); } @@ -1894,7 +1844,7 @@ void tst_QArrayData::variadicLiterals() { QArrayDataPointer<char> d = Q_ARRAY_LITERAL(char, 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J'); - QCOMPARE(d.size, 10u); + QCOMPARE(d.size, 10); for (int i = 0; i < 10; ++i) QCOMPARE(d.data()[i], char('A' + i)); } @@ -1902,7 +1852,7 @@ void tst_QArrayData::variadicLiterals() { QArrayDataPointer<const char *> d = Q_ARRAY_LITERAL(const char *, "A", "B", "C", "D", "E", "F", "G", "H", "I", "J"); - QCOMPARE(d.size, 10u); + QCOMPARE(d.size, 10); for (int i = 0; i < 10; ++i) { QCOMPARE(d.data()[i][0], char('A' + i)); QCOMPARE(d.data()[i][1], '\0'); @@ -2043,48 +1993,50 @@ void tst_QArrayData::grow() void tst_QArrayData::freeSpace_data() { - QTest::addColumn<QArrayData::ArrayOptions>("allocationOptions"); QTest::addColumn<size_t>("n"); for (const size_t n : {1, 3, 5, 7, 16, 25}) { QString suffix = QString::number(n) + QLatin1String("-elements"); - QTest::newRow(qPrintable(QLatin1String("default-alloc-") + suffix)) - << QArrayData::ArrayOptions(QArrayData::DefaultAllocationFlags) << n; - QTest::newRow(qPrintable(QLatin1String("grows-forward-") + suffix)) - << QArrayData::ArrayOptions(QArrayData::GrowsForward) << n; - QTest::newRow(qPrintable(QLatin1String("grows-bidirectional-") + suffix)) - << QArrayData::ArrayOptions(QArrayData::GrowsForward | QArrayData::GrowsBackwards) << n; + QTest::newRow(qPrintable(QLatin1String("alloc-") + suffix)) + << n; } } void tst_QArrayData::freeSpace() { - QFETCH(QArrayData::ArrayOptions, allocationOptions); QFETCH(size_t, n); - const auto testFreeSpace = [] (auto dummy, auto options, qsizetype n) { + const auto testFreeSpace = [] (auto dummy, qsizetype n) { using Type = std::decay_t<decltype(dummy)>; using DataPointer = QArrayDataPointer<Type>; Q_UNUSED(dummy); const qsizetype capacity = n + 1; - auto ptr = DataPointer::allocateGrow(DataPointer(), capacity, n, options); + auto ptr = DataPointer::allocateGrow(DataPointer(), capacity, QArrayData::GrowsAtEnd); const auto alloc = qsizetype(ptr.constAllocatedCapacity()); QVERIFY(alloc >= capacity); QCOMPARE(ptr.freeSpaceAtBegin() + ptr.freeSpaceAtEnd(), alloc); }; - RUN_TEST_FUNC(testFreeSpace, char(0), allocationOptions, n); - RUN_TEST_FUNC(testFreeSpace, char16_t(0), allocationOptions, n); - RUN_TEST_FUNC(testFreeSpace, int(0), allocationOptions, n); - RUN_TEST_FUNC(testFreeSpace, QString(), allocationOptions, n); - RUN_TEST_FUNC(testFreeSpace, CountedObject(), allocationOptions, n); + RUN_TEST_FUNC(testFreeSpace, char(0), n); + RUN_TEST_FUNC(testFreeSpace, char16_t(0), n); + RUN_TEST_FUNC(testFreeSpace, int(0), n); + RUN_TEST_FUNC(testFreeSpace, QString(), n); + RUN_TEST_FUNC(testFreeSpace, CountedObject(), n); +} + +void tst_QArrayData::dataPointerAllocate_data() +{ + QTest::addColumn<QArrayData::GrowthPosition>("GrowthPosition"); + + QTest::newRow("at-end") << QArrayData::GrowsAtEnd; + QTest::newRow("at-begin") << QArrayData::GrowsAtBeginning; } void tst_QArrayData::dataPointerAllocate() { - QFETCH(QArrayData::ArrayOptions, allocationOptions); + QFETCH(QArrayData::GrowthPosition, GrowthPosition); const auto createDataPointer = [] (qsizetype capacity, auto initValue) { using Type = std::decay_t<decltype(initValue)>; Q_UNUSED(initValue); - return QArrayDataPointer<Type>(QTypedArrayData<Type>::allocate(capacity)); + return QArrayDataPointer<Type>(capacity); }; const auto testRealloc = [&] (qsizetype capacity, qsizetype newSize, auto initValue) { @@ -2092,22 +2044,23 @@ void tst_QArrayData::dataPointerAllocate() using DataPointer = QArrayDataPointer<Type>; auto oldDataPointer = createDataPointer(capacity, initValue); - oldDataPointer->insert(oldDataPointer.begin(), 1, initValue); // trigger prepend + oldDataPointer->insert(0, 1, initValue); + oldDataPointer->insert(0, 1, initValue); // trigger prepend QVERIFY(!oldDataPointer.needsDetach()); - auto newDataPointer = DataPointer::allocateGrow( - oldDataPointer, oldDataPointer->detachCapacity(newSize), newSize, allocationOptions); + auto newDataPointer = DataPointer::allocateGrow(oldDataPointer, newSize, GrowthPosition); const auto newAlloc = newDataPointer.constAllocatedCapacity(); const auto freeAtBegin = newDataPointer.freeSpaceAtBegin(); const auto freeAtEnd = newDataPointer.freeSpaceAtEnd(); - QVERIFY(newAlloc > oldDataPointer.constAllocatedCapacity()); - QCOMPARE(size_t(freeAtBegin + freeAtEnd), newAlloc); - // when not detached, the behavior is the same as of ::realloc - if (allocationOptions & (QArrayData::GrowsForward | QArrayData::GrowsBackwards)) + QVERIFY(newAlloc >= oldDataPointer.constAllocatedCapacity()); + QCOMPARE(freeAtBegin + freeAtEnd, newAlloc); + if (GrowthPosition == QArrayData::GrowsAtBeginning) { + QVERIFY(freeAtBegin > 0); + } else if (GrowthPosition & QArrayData::GrowsAtEnd) { QCOMPARE(freeAtBegin, oldDataPointer.freeSpaceAtBegin()); - else - QCOMPARE(freeAtBegin, 0); + QVERIFY(freeAtEnd > 0); + } }; for (size_t n : {10, 512, 1000}) { @@ -2123,22 +2076,22 @@ void tst_QArrayData::dataPointerAllocate() using DataPointer = QArrayDataPointer<Type>; auto oldDataPointer = createDataPointer(capacity, initValue); - oldDataPointer->insert(oldDataPointer.begin(), 1, initValue); // trigger prepend + oldDataPointer->insert(0, 1, initValue); // trigger prepend auto oldDataPointerCopy = oldDataPointer; // force detach later QVERIFY(oldDataPointer.needsDetach()); - auto newDataPointer = DataPointer::allocateGrow( - oldDataPointer, oldDataPointer->detachCapacity(newSize), newSize, allocationOptions); + auto newDataPointer = DataPointer::allocateGrow(oldDataPointer, oldDataPointer->detachCapacity(newSize), GrowthPosition); const auto newAlloc = newDataPointer.constAllocatedCapacity(); const auto freeAtBegin = newDataPointer.freeSpaceAtBegin(); const auto freeAtEnd = newDataPointer.freeSpaceAtEnd(); QVERIFY(newAlloc > oldDataPointer.constAllocatedCapacity()); - QCOMPARE(size_t(freeAtBegin + freeAtEnd), newAlloc); - if (allocationOptions & QArrayData::GrowsBackwards) { - QCOMPARE(size_t(freeAtBegin), (newAlloc - newSize) / 2); - } else { - QCOMPARE(freeAtBegin, 0); + QCOMPARE(freeAtBegin + freeAtEnd, newAlloc); + if (GrowthPosition == QArrayData::GrowsAtBeginning) { + QVERIFY(freeAtBegin > 0); + } else if (GrowthPosition & QArrayData::GrowsAtEnd) { + QCOMPARE(freeAtBegin, oldDataPointer.freeSpaceAtBegin()); + QVERIFY(freeAtEnd > 0); } }; @@ -2151,884 +2104,433 @@ void tst_QArrayData::dataPointerAllocate() } } -void tst_QArrayData::dataPointerAllocateAlignedWithReallocate_data() -{ - QTest::addColumn<QArrayData::ArrayOptions>("initFlags"); - QTest::addColumn<QArrayData::ArrayOptions>("newFlags"); - - QTest::newRow("default-flags") << QArrayData::ArrayOptions(QArrayData::DefaultAllocationFlags) - << QArrayData::ArrayOptions(QArrayData::DefaultAllocationFlags); - QTest::newRow("no-grows-backwards") << QArrayData::ArrayOptions(QArrayData::GrowsForward) - << QArrayData::ArrayOptions(QArrayData::GrowsForward); - QTest::newRow("grows-backwards") << QArrayData::ArrayOptions(QArrayData::GrowsBackwards) - << QArrayData::ArrayOptions(QArrayData::GrowsBackwards); - QTest::newRow("removed-grows-backwards") << QArrayData::ArrayOptions(QArrayData::GrowsBackwards) - << QArrayData::ArrayOptions(QArrayData::GrowsForward); - QTest::newRow("removed-growth") << QArrayData::ArrayOptions(QArrayData::GrowsBackwards) - << QArrayData::ArrayOptions(QArrayData::DefaultAllocationFlags); -} - -void tst_QArrayData::dataPointerAllocateAlignedWithReallocate() -{ - QFETCH(QArrayData::ArrayOptions, initFlags); - QFETCH(QArrayData::ArrayOptions, newFlags); - - // Note: using the same type to ensure alignment and padding are the same. - // otherwise, we may get differences in the allocated size - auto a = QArrayDataPointer<int>::allocateGrow(QArrayDataPointer<int>(), 50, 0, initFlags); - auto b = QArrayDataPointer<int>::allocateGrow(QArrayDataPointer<int>(), 50, 0, initFlags); - - if (initFlags & QArrayData::GrowsBackwards) { - QVERIFY(a.freeSpaceAtBegin() > 0); - } else { - QVERIFY(a.freeSpaceAtBegin() == 0); - } - QCOMPARE(a.freeSpaceAtBegin(), b.freeSpaceAtBegin()); - - a->reallocate(100, newFlags); - b = QArrayDataPointer<int>::allocateGrow(b, 100, b.size, newFlags); - - // It is enough to test that the behavior of reallocate is the same as the - // behavior of allocate w.r.t. pointer adjustment in case of - // GrowsBackwards. Actual values are not that interesting - QCOMPARE(a.freeSpaceAtBegin(), b.freeSpaceAtBegin()); -} - -#ifndef QT_NO_EXCEPTIONS -struct ThrowingTypeWatcher +struct MyQStringWrapper : public QString { - std::vector<int> destroyedIds; - bool watch = false; - void destroyed(int id) - { - if (watch) - destroyedIds.push_back(id); + bool movedTo = false; + bool movedFrom = false; + MyQStringWrapper() = default; + MyQStringWrapper(QChar c) : QString(c) { } + MyQStringWrapper(MyQStringWrapper &&other) : QString(std::move(static_cast<QString &>(other))) + { + movedTo = true; + movedFrom = other.movedFrom; + other.movedFrom = true; + } + MyQStringWrapper &operator=(MyQStringWrapper &&other) + { + QString::operator=(std::move(static_cast<QString &>(other))); + movedTo = true; + movedFrom = other.movedFrom; + other.movedFrom = true; + return *this; } + MyQStringWrapper(const MyQStringWrapper &) = default; + MyQStringWrapper &operator=(const MyQStringWrapper &) = default; + ~MyQStringWrapper() = default; }; -ThrowingTypeWatcher& throwingTypeWatcher() { static ThrowingTypeWatcher global; return global; } -struct ThrowingType +struct MyMovableQString : public MyQStringWrapper { - static unsigned int throwOnce; - static unsigned int throwOnceInDtor; - static constexpr char throwString[] = "Requested to throw"; - static constexpr char throwStringDtor[] = "Requested to throw in dtor"; - void checkThrow() { - // deferred throw - if (throwOnce > 0) { - --throwOnce; - if (throwOnce == 0) { - throw std::runtime_error(throwString); - } - } - return; - } - int id = 0; + MyMovableQString() = default; + MyMovableQString(QChar c) : MyQStringWrapper(c) { } - ThrowingType(int val = 0) noexcept(false) : id(val) +private: + friend bool operator==(const MyMovableQString &a, QChar c) { - checkThrow(); + return static_cast<QString>(a) == QString(c); } - ThrowingType(const ThrowingType &other) noexcept(false) : id(other.id) - { - checkThrow(); - } - ThrowingType& operator=(const ThrowingType &other) noexcept(false) - { - id = other.id; - checkThrow(); - return *this; - } - ~ThrowingType() noexcept(false) - { - throwingTypeWatcher().destroyed(id); // notify global watcher - id = -1; - // deferred throw - if (throwOnceInDtor > 0) { - --throwOnceInDtor; - if (throwOnceInDtor == 0) { - throw std::runtime_error(throwStringDtor); - } - } + friend bool operator==(const MyMovableQString &a, const MyMovableQString &b) + { + return static_cast<QString>(a) == static_cast<QString>(b); } }; -unsigned int ThrowingType::throwOnce = 0; -unsigned int ThrowingType::throwOnceInDtor = 0; -bool operator==(const ThrowingType &a, const ThrowingType &b) { - return a.id == b.id; -} + QT_BEGIN_NAMESPACE -Q_DECLARE_TYPEINFO(ThrowingType, Q_RELOCATABLE_TYPE); +Q_DECLARE_TYPEINFO(MyMovableQString, Q_RELOCATABLE_TYPE); QT_END_NAMESPACE +static_assert(QTypeInfo<MyMovableQString>::isComplex); +static_assert(QTypeInfo<MyMovableQString>::isRelocatable); -template<typename T> // T must be constructible from a single int parameter -static QArrayDataPointer<T> createDataPointer(qsizetype capacity, qsizetype initSize) +struct MyComplexQString : public MyQStringWrapper { - QArrayDataPointer<T> adp(QTypedArrayData<T>::allocate(capacity)); - adp->appendInitialize(initSize); - // assign unique values - int i = 0; - std::generate(adp.begin(), adp.end(), [&i] () { return T(i++); }); - return adp; -} - -void tst_QArrayData::exceptionSafetyPrimitives_constructor() -{ - using Prims = QtPrivate::QArrayExceptionSafetyPrimitives<ThrowingType>; - using Constructor = typename Prims::Constructor; - - struct WatcherScope - { - WatcherScope() { throwingTypeWatcher().watch = true; } - ~WatcherScope() - { - throwingTypeWatcher().watch = false; - throwingTypeWatcher().destroyedIds.clear(); - } - }; + MyComplexQString() = default; + MyComplexQString(QChar c) : MyQStringWrapper(c) { } - const auto doConstruction = [] (auto &dataPointer, auto where, auto op) { - Constructor ctor(where); - dataPointer.size += op(ctor); - }; - - // empty ranges +private: + friend bool operator==(const MyComplexQString &a, QChar c) { - auto data = createDataPointer<ThrowingType>(20, 10); - const auto originalSize = data.size; - const std::array<ThrowingType, 0> emptyRange{}; - - doConstruction(data, data.end(), [] (Constructor &ctor) { return ctor.create(0); }); - QCOMPARE(data.size, originalSize); - - doConstruction(data, data.end(), [&emptyRange] (Constructor &ctor) { - return ctor.copy(emptyRange.begin(), emptyRange.end()); - }); - QCOMPARE(data.size, originalSize); - - doConstruction(data, data.end(), [] (Constructor &ctor) { - return ctor.clone(0, ThrowingType(42)); - }); - QCOMPARE(data.size, originalSize); - - doConstruction(data, data.end(), [emptyRange] (Constructor &ctor) mutable { - return ctor.move(emptyRange.begin(), emptyRange.end()); - }); - QCOMPARE(data.size, originalSize); + return static_cast<QString>(a) == QString(c); } - // successful create + friend bool operator==(const MyComplexQString &a, const MyComplexQString &b) { - auto data = createDataPointer<ThrowingType>(20, 10); - auto reference = createDataPointer<ThrowingType>(20, 10); - reference->appendInitialize(reference.size + 1); - - doConstruction(data, data.end(), [] (Constructor &ctor) { return ctor.create(1); }); - - QCOMPARE(data.size, reference.size); - for (qsizetype i = 0; i < data.size; ++i) - QCOMPARE(data.data()[i], reference.data()[i]); - } - - // successful copy - { - auto data = createDataPointer<ThrowingType>(20, 10); - auto reference = createDataPointer<ThrowingType>(20, 10); - const std::array<ThrowingType, 3> source = { - ThrowingType(42), ThrowingType(43), ThrowingType(44) - }; - reference->copyAppend(source.begin(), source.end()); - - doConstruction(data, data.end(), [&source] (Constructor &ctor) { - return ctor.copy(source.begin(), source.end()); - }); - - QCOMPARE(data.size, reference.size); - for (qsizetype i = 0; i < data.size; ++i) - QCOMPARE(data.data()[i], reference.data()[i]); - - reference->copyAppend(2, source[0]); - - doConstruction(data, data.end(), [&source] (Constructor &ctor) { - return ctor.clone(2, source[0]); - }); - - QCOMPARE(data.size, reference.size); - for (qsizetype i = 0; i < data.size; ++i) - QCOMPARE(data.data()[i], reference.data()[i]); + return static_cast<QString>(a) == static_cast<QString>(b); } +}; +static_assert(QTypeInfo<MyComplexQString>::isComplex); +static_assert(!QTypeInfo<MyComplexQString>::isRelocatable); - // successful move - { - auto data = createDataPointer<ThrowingType>(20, 10); - auto reference = createDataPointer<ThrowingType>(20, 10); - const std::array<ThrowingType, 3> source = { - ThrowingType(42), ThrowingType(43), ThrowingType(44) - }; - reference->copyAppend(source.begin(), source.end()); - - doConstruction(data, data.end(), [source] (Constructor &ctor) mutable { - return ctor.move(source.begin(), source.end()); - }); - - QCOMPARE(data.size, reference.size); - for (qsizetype i = 0; i < data.size; ++i) - QCOMPARE(data.data()[i], reference.data()[i]); - } +void tst_QArrayData::selfEmplaceBackwards() +{ + const auto createDataPointer = [](qsizetype capacity, int spaceAtEnd, auto dummy) { + using Type = std::decay_t<decltype(dummy)>; + Q_UNUSED(dummy); + auto [header, ptr] = QTypedArrayData<Type>::allocate(capacity, QArrayData::Grow); + // do custom adjustments to make sure there's free space at end + ptr += header->alloc - spaceAtEnd; + return QArrayDataPointer(header, ptr); + }; - // failed create - { - auto data = createDataPointer<ThrowingType>(20, 10); - auto reference = createDataPointer<ThrowingType>(20, 10); - - for (uint throwOnNthConstruction : {1, 3}) { - WatcherScope scope; Q_UNUSED(scope); - try { - ThrowingType::throwOnce = throwOnNthConstruction; - doConstruction(data, data.end(), [] (Constructor &ctor) { - return ctor.create(5); - }); - } catch (const std::runtime_error &e) { - QCOMPARE(std::string(e.what()), ThrowingType::throwString); - QCOMPARE(data.size, reference.size); - for (qsizetype i = 0; i < data.size; ++i) - QCOMPARE(data.data()[i], reference.data()[i]); - QCOMPARE(throwingTypeWatcher().destroyedIds.size(), (throwOnNthConstruction - 1)); - for (auto id : throwingTypeWatcher().destroyedIds) - QCOMPARE(id, 0); - } + const auto testSelfEmplace = [&](auto dummy, int spaceAtEnd, auto initValues) { + auto adp = createDataPointer(100, spaceAtEnd, dummy); + for (auto v : initValues) { + adp->emplace(adp.size, v); } - } + QVERIFY(!adp.freeSpaceAtEnd()); + QVERIFY(adp.freeSpaceAtBegin()); - // failed copy - { - auto data = createDataPointer<ThrowingType>(20, 10); - auto reference = createDataPointer<ThrowingType>(20, 10); - const std::array<ThrowingType, 4> source = { - ThrowingType(42), ThrowingType(43), ThrowingType(44), ThrowingType(170) - }; - - // copy range - for (uint throwOnNthConstruction : {1, 3}) { - WatcherScope scope; Q_UNUSED(scope); - try { - ThrowingType::throwOnce = throwOnNthConstruction; - doConstruction(data, data.end(), [&source] (Constructor &ctor) { - return ctor.copy(source.begin(), source.end()); - }); - } catch (const std::runtime_error &e) { - QCOMPARE(std::string(e.what()), ThrowingType::throwString); - QCOMPARE(data.size, reference.size); - for (qsizetype i = 0; i < data.size; ++i) - QCOMPARE(data.data()[i], reference.data()[i]); - const auto destroyedSize = throwingTypeWatcher().destroyedIds.size(); - QCOMPARE(destroyedSize, (throwOnNthConstruction - 1)); - for (size_t i = 0; i < destroyedSize; ++i) - QCOMPARE(throwingTypeWatcher().destroyedIds[i], source[destroyedSize - i - 1]); - } + adp->emplace(adp.size, adp.data()[0]); + for (qsizetype i = 0; i < adp.size - 1; ++i) { + QCOMPARE(adp.data()[i], initValues[i]); } + QCOMPARE(adp.data()[adp.size - 1], initValues[0]); - // copy value - for (uint throwOnNthConstruction : {1, 3}) { - const ThrowingType value(512); - QVERIFY(QArrayDataPointer<ThrowingType>::pass_parameter_by_value == false); - WatcherScope scope; Q_UNUSED(scope); - try { - ThrowingType::throwOnce = throwOnNthConstruction; - doConstruction(data, data.end(), [&source, &value] (Constructor &ctor) { - return ctor.clone(5, value); - }); - } catch (const std::runtime_error &e) { - QCOMPARE(std::string(e.what()), ThrowingType::throwString); - QCOMPARE(data.size, reference.size); - for (qsizetype i = 0; i < data.size; ++i) - QCOMPARE(data.data()[i], reference.data()[i]); - QCOMPARE(throwingTypeWatcher().destroyedIds.size(), (throwOnNthConstruction - 1)); - for (auto id : throwingTypeWatcher().destroyedIds) - QCOMPARE(id, 512); - } + adp->emplace(adp.size, std::move(adp.data()[0])); + for (qsizetype i = 1; i < adp.size - 2; ++i) { + QCOMPARE(adp.data()[i], initValues[i]); } - } - - // failed move - { - auto data = createDataPointer<ThrowingType>(20, 10); - auto reference = createDataPointer<ThrowingType>(20, 10); - const std::array<ThrowingType, 4> source = { - ThrowingType(42), ThrowingType(43), ThrowingType(44), ThrowingType(170) - }; + QCOMPARE(adp.data()[adp.size - 2], initValues[0]); + QCOMPARE(adp.data()[0].movedFrom, true); + QCOMPARE(adp.data()[adp.size - 1], initValues[0]); + QCOMPARE(adp.data()[adp.size - 1].movedTo, true); + }; - for (uint throwOnNthConstruction : {1, 3}) { - WatcherScope scope; Q_UNUSED(scope); - try { - ThrowingType::throwOnce = throwOnNthConstruction; - doConstruction(data, data.end(), [source] (Constructor &ctor) mutable { - return ctor.move(source.begin(), source.end()); - }); - } catch (const std::runtime_error &e) { - QCOMPARE(std::string(e.what()), ThrowingType::throwString); - QCOMPARE(data.size, reference.size); - for (qsizetype i = 0; i < data.size; ++i) - QCOMPARE(data.data()[i], reference.data()[i]); - const auto destroyedSize = throwingTypeWatcher().destroyedIds.size(); - QCOMPARE(destroyedSize, (throwOnNthConstruction - 1)); - for (size_t i = 0; i < destroyedSize; ++i) - QCOMPARE(throwingTypeWatcher().destroyedIds[i], source[destroyedSize - i - 1]); - } - } - } + QList<QChar> movableObjs { u'a', u'b', u'c', u'd' }; + RUN_TEST_FUNC(testSelfEmplace, MyMovableQString(), 4, movableObjs); + QList<QChar> complexObjs { u'a', u'b', u'c', u'd' }; + RUN_TEST_FUNC(testSelfEmplace, MyComplexQString(), 4, complexObjs); } -void tst_QArrayData::exceptionSafetyPrimitives_destructor() +void tst_QArrayData::selfEmplaceForward() { - using Prims = QtPrivate::QArrayExceptionSafetyPrimitives<ThrowingType>; - using Destructor = typename Prims::Destructor<>; - - struct WatcherScope - { - WatcherScope() { throwingTypeWatcher().watch = true; } - ~WatcherScope() - { - throwingTypeWatcher().watch = false; - throwingTypeWatcher().destroyedIds.clear(); - } + const auto createDataPointer = [](qsizetype capacity, int spaceAtBegin, auto dummy) { + using Type = std::decay_t<decltype(dummy)>; + Q_UNUSED(dummy); + auto [header, ptr] = QTypedArrayData<Type>::allocate(capacity, QArrayData::Grow); + // do custom adjustments to make sure there's free space at end + ptr += spaceAtBegin; + return QArrayDataPointer(header, ptr); }; - // successful operation with no rollback, elements added from left to right - { - auto data = createDataPointer<ThrowingType>(20, 10); - auto reference = createDataPointer<ThrowingType>(20, 10); - reference->insert(reference.end(), 2, ThrowingType(42)); - - WatcherScope scope; Q_UNUSED(scope); - { - auto where = data.end() - 1; - Destructor destroyer(where); - for (int i = 0; i < 2; ++i) { - new (where + 1) ThrowingType(42); - ++where; - ++data.size; - } - destroyer.commit(); + const auto testSelfEmplace = [&](auto dummy, int spaceAtBegin, auto initValues) { + // need a -1 below as the first emplace will go towards the end (as the array is still empty) + auto adp = createDataPointer(100, spaceAtBegin - 1, dummy); + auto reversedInitValues = initValues; + std::reverse(reversedInitValues.begin(), reversedInitValues.end()); + for (auto v : reversedInitValues) { + adp->emplace(0, v); } + QVERIFY(!adp.freeSpaceAtBegin()); + QVERIFY(adp.freeSpaceAtEnd()); - QCOMPARE(data.size, reference.size); - for (qsizetype i = 0; i < data.size; ++i) - QCOMPARE(data.data()[i], reference.data()[i]); - QVERIFY(throwingTypeWatcher().destroyedIds.size() == 0); - } - - // failed operation with rollback, elements added from left to right - { - auto data = createDataPointer<ThrowingType>(20, 10); - auto reference = createDataPointer<ThrowingType>(20, 10); - - WatcherScope scope; Q_UNUSED(scope); - try { - auto where = data.end() - 1; - Destructor destroyer(where); - for (int i = 0; i < 2; ++i) { - new (where + 1) ThrowingType(42 + i); - ++where; - ThrowingType::throwOnce = 1; - } - QFAIL("Unreachable line!"); - destroyer.commit(); - } catch (const std::runtime_error &e) { - QCOMPARE(std::string(e.what()), ThrowingType::throwString); - QCOMPARE(data.size, reference.size); - for (qsizetype i = 0; i < data.size; ++i) - QCOMPARE(data.data()[i], reference.data()[i]); - QVERIFY(throwingTypeWatcher().destroyedIds.size() == 1); - QCOMPARE(throwingTypeWatcher().destroyedIds[0], 42); - } - } - - // successful operation with no rollback, elements added from right to left - { - auto data = createDataPointer<ThrowingType>(20, 10); - auto reference = createDataPointer<ThrowingType>(20, 10); - reference->erase(reference.begin(), reference.begin() + 2); - reference->insert(reference.begin(), 2, ThrowingType(42)); - - data.begin()->~ThrowingType(); - data.begin()->~ThrowingType(); - data.size -= 2; - WatcherScope scope; Q_UNUSED(scope); - { - auto where = data.begin() + 2; // Note: not updated data ptr, so begin + 2 - Destructor destroyer(where); - for (int i = 0; i < 2; ++i) { - new (where - 1) ThrowingType(42); - --where; - ++data.size; - } - destroyer.commit(); + adp->emplace(0, adp.data()[adp.size - 1]); + for (qsizetype i = 1; i < adp.size; ++i) { + QCOMPARE(adp.data()[i], initValues[i - 1]); } - QCOMPARE(data.size, reference.size); - for (qsizetype i = 0; i < data.size; ++i) - QCOMPARE(data.data()[i], reference.data()[i]); - QVERIFY(throwingTypeWatcher().destroyedIds.size() == 0); - } + QCOMPARE(adp.data()[0], initValues[spaceAtBegin - 1]); - // failed operation with rollback, elements added from right to left - { - auto data = createDataPointer<ThrowingType>(20, 10); - auto reference = createDataPointer<ThrowingType>(20, 10); - reference->erase(reference.begin(), reference.begin() + 2); - - data.begin()->~ThrowingType(); - data.begin()->~ThrowingType(); - data.size -= 2; - WatcherScope scope; Q_UNUSED(scope); - try { - auto where = data.begin() + 2; // Note: not updated data ptr, so begin + 2 - Destructor destroyer(where); - for (int i = 0; i < 2; ++i) { - new (where - 1) ThrowingType(42 + i); - --where; - ThrowingType::throwOnce = 1; - } - QFAIL("Unreachable line!"); - destroyer.commit(); - } catch (const std::runtime_error &e) { - QCOMPARE(std::string(e.what()), ThrowingType::throwString); - QCOMPARE(data.size, reference.size); - for (qsizetype i = 0; i < data.size; ++i) - QCOMPARE(data.data()[i + 2], reference.data()[i]); - QVERIFY(throwingTypeWatcher().destroyedIds.size() == 1); - QCOMPARE(throwingTypeWatcher().destroyedIds[0], 42); + adp->emplace(0, std::move(adp.data()[adp.size - 1])); + for (qsizetype i = 2; i < adp.size - 1; ++i) { + QCOMPARE(adp.data()[i], initValues[i - 2]); } - } - - // extra: the very first operation throws - destructor has to do nothing, - // since nothing is properly constructed - { - auto data = createDataPointer<ThrowingType>(20, 10); - auto reference = createDataPointer<ThrowingType>(20, 10); + QCOMPARE(adp.data()[1], initValues[spaceAtBegin - 1]); + QCOMPARE(adp.data()[adp.size - 1].movedFrom, true); + QCOMPARE(adp.data()[0], initValues[spaceAtBegin - 1]); + QCOMPARE(adp.data()[0].movedTo, true); + }; - WatcherScope scope; Q_UNUSED(scope); - try { - auto where = data.end() - 1; - Destructor destroyer(where); - ThrowingType::throwOnce = 1; - new (where + 1) ThrowingType(42); - ++where; - QFAIL("Unreachable line!"); - destroyer.commit(); - } catch (const std::runtime_error &e) { - QCOMPARE(data.size, reference.size); - for (qsizetype i = 0; i < data.size; ++i) - QCOMPARE(data.data()[i], reference.data()[i]); - QVERIFY(throwingTypeWatcher().destroyedIds.size() == 0); - } - } + QList<QChar> movableObjs { u'a', u'b', u'c', u'd' }; + RUN_TEST_FUNC(testSelfEmplace, MyMovableQString(), 4, movableObjs); + QList<QChar> complexObjs { u'a', u'b', u'c', u'd' }; + RUN_TEST_FUNC(testSelfEmplace, MyComplexQString(), 4, complexObjs); +} - // extra: special case when iterator is intentionally out of bounds: this is - // to cover the case when we work on the uninitialized memory region instead - // of being near the border - { - auto data = createDataPointer<ThrowingType>(20, 10); - auto reference = createDataPointer<ThrowingType>(20, 10); - reference->erase(reference.begin(), reference.begin() + 2); - - data.begin()->~ThrowingType(); - data.begin()->~ThrowingType(); - data.size -= 2; - WatcherScope scope; Q_UNUSED(scope); - try { - auto where = data.begin() - 1; // Note: intentionally out of range - Destructor destroyer(where); - for (int i = 0; i < 2; ++i) { - new (where + 1) ThrowingType(42); - ++where; - ThrowingType::throwOnce = 1; - } - QFAIL("Unreachable line!"); - destroyer.commit(); - } catch (const std::runtime_error &e) { - QCOMPARE(data.size, reference.size); - for (qsizetype i = 0; i < data.size; ++i) - QCOMPARE(data.data()[i + 2], reference.data()[i]); - QVERIFY(throwingTypeWatcher().destroyedIds.size() == 1); - QVERIFY(throwingTypeWatcher().destroyedIds[0] == 42); - } - } +#ifndef QT_NO_EXCEPTIONS +struct ThrowingTypeWatcher +{ + std::vector<void *> destroyedAddrs; + bool watch = false; - // extra: special case of freezing the position + void destroyed(void *addr) { - auto data = createDataPointer<ThrowingType>(20, 10); - auto reference = createDataPointer<ThrowingType>(20, 10); - reference->erase(reference.end() - 1, reference.end()); - data.data()[data.size - 1] = ThrowingType(42); - - WatcherScope scope; Q_UNUSED(scope); - { - auto where = data.end(); - Destructor destroyer(where); - for (int i = 0; i < 3; ++i) { - --where; - destroyer.freeze(); - } - } - --data.size; // destroyed 1 element above - for (qsizetype i = 0; i < data.size; ++i) - QCOMPARE(data.data()[i], reference.data()[i]); - QVERIFY(throwingTypeWatcher().destroyedIds.size() == 1); - QCOMPARE(throwingTypeWatcher().destroyedIds[0], 42); + if (watch) + destroyedAddrs.push_back(addr); } -} +}; -void tst_QArrayData::exceptionSafetyPrimitives_mover() +ThrowingTypeWatcher &throwingTypeWatcher() { - QVERIFY(QTypeInfo<ThrowingType>::isRelocatable); - using Prims = QtPrivate::QArrayExceptionSafetyPrimitives<ThrowingType>; - using Mover = typename Prims::Mover; - - const auto testMoveLeft = [] (size_t posB, size_t posE) { - auto data = createDataPointer<ThrowingType>(20, 10); - auto reference = createDataPointer<ThrowingType>(20, 10); - - ThrowingType *b = data.begin() + posB; - ThrowingType *e = data.begin() + posE; - const auto originalSize = data.size; - const auto length = std::distance(b, e); - { - Mover mover(e, static_cast<ThrowingType *>(data.end()) - e, data.size); - while (e != b) - (--e)->~ThrowingType(); - } - QCOMPARE(data.size + length, originalSize); - qsizetype i = 0; - for (; i < std::distance(static_cast<ThrowingType *>(data.begin()), b); ++i) - QCOMPARE(data.data()[i], reference.data()[i]); - for (; i < data.size; ++i) - QCOMPARE(data.data()[i], reference.data()[i + length]); - }; - - const auto testMoveRight = [] (size_t posB, size_t posE) { - auto data = createDataPointer<ThrowingType>(20, 10); - auto reference = createDataPointer<ThrowingType>(20, 10); - - ThrowingType *begin = data.begin(); - ThrowingType *b = data.begin() + posB; - ThrowingType *e = data.begin() + posE; - const auto originalSize = data.size; - const auto length = std::distance(b, e); - { - Mover mover(begin, b - static_cast<ThrowingType *>(data.begin()), data.size); - while (b != e) { - ++begin; - (b++)->~ThrowingType(); - } - } - QCOMPARE(data.size + length, originalSize); - - // restore original data size - { - for (qsizetype i = 0; i < length; ++i) { - new (static_cast<ThrowingType *>(data.begin() + i)) ThrowingType(42); - ++data.size; - } - } - - qsizetype i = length; - for (; i < std::distance(static_cast<ThrowingType *>(data.begin()), e); ++i) - QCOMPARE(data.data()[i], reference.data()[i - length]); - for (; i < data.size; ++i) - QCOMPARE(data.data()[i], reference.data()[i]); - }; - - // normal move left - RUN_TEST_FUNC(testMoveLeft, 2, 4); - // no move left - RUN_TEST_FUNC(testMoveLeft, 2, 2); - // normal move right - RUN_TEST_FUNC(testMoveRight, 3, 5); - // no move right - RUN_TEST_FUNC(testMoveRight, 4, 4); + static ThrowingTypeWatcher global; + return global; } -void tst_QArrayData::exceptionSafetyPrimitives_displacer() +struct ThrowingType { - QVERIFY(QTypeInfo<ThrowingType>::isRelocatable); - using Prims = QtPrivate::QArrayExceptionSafetyPrimitives<ThrowingType>; - const auto doDisplace = [] (auto &dataPointer, auto start, auto finish, qsizetype diff) { - typename Prims::Displacer displace(start, finish, diff); - new (start) ThrowingType(42); - ++dataPointer.size; - displace.commit(); + static unsigned int throwOnce; + static constexpr char throwString[] = "Requested to throw"; + enum MoveCase { + MoveRightNoOverlap, + MoveRightOverlap, + MoveLeftNoOverlap, + MoveLeftOverlap, + }; + enum ThrowCase { + NoThrow, + ThrowInUninitializedRegion, + ThrowInOverlapRegion, }; - // successful operation with displace to the right - { - auto data = createDataPointer<ThrowingType>(20, 10); - auto reference = createDataPointer<ThrowingType>(20, 10); - reference->insert(reference.end() - 1, 1, ThrowingType(42)); - - auto where = data.end() - 1; - doDisplace(data, where, data.end(), 1); - - QCOMPARE(data.size, reference.size); - for (qsizetype i = 0; i < data.size; ++i) - QCOMPARE(data.data()[i], reference.data()[i]); - } + // reinforce basic checkers with std::shared_ptr which happens to signal + // very explicitly about use-after-free and so on under ASan + std::shared_ptr<int> doubleFreeHelper = std::shared_ptr<int>(new int(42)); + int id = 0; - // failed operation with displace to the right + void checkThrow() { - auto data = createDataPointer<ThrowingType>(20, 10); - auto reference = createDataPointer<ThrowingType>(20, 10); - try { - ThrowingType::throwOnce = 1; - doDisplace(data, data.end() - 1, data.end(), 1); - QFAIL("Unreachable line!"); - } catch (const std::exception &e) { - QCOMPARE(std::string(e.what()), ThrowingType::throwString); - QCOMPARE(data.size, reference.size); - for (qsizetype i = 0; i < data.size; ++i) - QCOMPARE(data.data()[i], reference.data()[i]); + // deferred throw + if (throwOnce > 0) { + --throwOnce; + if (throwOnce == 0) { + throw std::runtime_error(throwString); + } } + return; } - // successful operation with displace to the left + void copy(const ThrowingType &other) noexcept(false) { - auto data = createDataPointer<ThrowingType>(20, 10); - auto reference = createDataPointer<ThrowingType>(20, 10); - reference.data()[0] = reference.data()[1]; - reference.data()[1] = ThrowingType(42); - - data.begin()->~ThrowingType(); // free space at begin - --data.size; - auto where = data.begin() + 1; - doDisplace(data, where, where + 1, -1); - - QCOMPARE(data.size, reference.size); - for (qsizetype i = 0; i < data.size; ++i) - QCOMPARE(data.data()[i], reference.data()[i]); + doubleFreeHelper = other.doubleFreeHelper; + id = other.id; + checkThrow(); } - // failed operation with displace to the left + ThrowingType(int val = 0) noexcept(false) : id(val) { checkThrow(); } + ThrowingType(const ThrowingType &other) noexcept(false) { copy(other); } + ThrowingType &operator=(const ThrowingType &other) noexcept(false) { - auto data = createDataPointer<ThrowingType>(20, 10); - auto reference = createDataPointer<ThrowingType>(20, 10); - reference->erase(reference.begin(), reference.begin() + 1); - - try { - data.begin()->~ThrowingType(); // free space at begin - --data.size; - ThrowingType::throwOnce = 1; - auto where = data.begin() + 1; - doDisplace(data, where, where + 1, -1); - QFAIL("Unreachable line!"); - } catch (const std::exception &e) { - QCOMPARE(std::string(e.what()), ThrowingType::throwString); - QCOMPARE(data.size, reference.size); - for (qsizetype i = 0; i < data.size; ++i) - QCOMPARE(data.data()[i + 1], reference.data()[i]); - } + copy(other); + return *this; } -} - -struct GenericThrowingType -{ - std::shared_ptr<int> data = std::shared_ptr<int>(new int(42)); // helper for double free - ThrowingType throwingData = ThrowingType(0); - GenericThrowingType(int id = 0) : throwingData(id) + ThrowingType(ThrowingType &&other) noexcept(false) { copy(other); } + ThrowingType &operator=(ThrowingType &&other) noexcept(false) { - QVERIFY(data.use_count() > 0); + copy(other); + return *this; } - - ~GenericThrowingType() + ~ThrowingType() noexcept(true) { + throwingTypeWatcher().destroyed(this); // notify global watcher + id = -1; // if we're in dtor but use_count is 0, it's double free - QVERIFY(data.use_count() > 0); + QVERIFY(doubleFreeHelper.use_count() > 0); } - enum MoveCase { - MoveRightNoOverlap = 0, - MoveRightOverlap = 1, - MoveLeftNoOverlap = 2, - MoveLeftOverlap = 3, - }; - - enum ThrowCase { - ThrowInDtor = 0, - ThrowInUninitializedRegion = 1, - ThrowInOverlapRegion = 2, - }; + friend bool operator==(const ThrowingType &a, const ThrowingType &b) { return a.id == b.id; } }; -struct PublicGenericMoveOps : QtPrivate::QCommonArrayOps<GenericThrowingType> -{ - template<typename GrowthTag> - void public_moveInGrowthDirection(GrowthTag tag, qsizetype futureGrowth) - { - static_assert(!QTypeInfo<GenericThrowingType>::isRelocatable); - using MoveOps = QtPrivate::QCommonArrayOps<GenericThrowingType>::GenericMoveOps; - MoveOps::moveInGrowthDirection(tag, this, futureGrowth); - } -}; +unsigned int ThrowingType::throwOnce = 0; +static_assert(!QTypeInfo<ThrowingType>::isRelocatable); -void tst_QArrayData::moveNonPod_data() +void tst_QArrayData::relocateWithExceptions_data() { - QTest::addColumn<GenericThrowingType::MoveCase>("moveCase"); - QTest::addColumn<GenericThrowingType::ThrowCase>("throwCase"); - - // Throwing in dtor - QTest::newRow("throw-in-dtor-move-right-no-overlap") - << GenericThrowingType::MoveRightNoOverlap << GenericThrowingType::ThrowInDtor; - QTest::newRow("throw-in-dtor-move-right-overlap") - << GenericThrowingType::MoveRightOverlap << GenericThrowingType::ThrowInDtor; - QTest::newRow("throw-in-dtor-move-left-no-overlap") - << GenericThrowingType::MoveLeftNoOverlap << GenericThrowingType::ThrowInDtor; - QTest::newRow("throw-in-dtor-move-left-overlap") - << GenericThrowingType::MoveLeftOverlap << GenericThrowingType::ThrowInDtor; - + QTest::addColumn<ThrowingType::MoveCase>("moveCase"); + QTest::addColumn<ThrowingType::ThrowCase>("throwCase"); + // Not throwing + QTest::newRow("no-throw-move-right-no-overlap") + << ThrowingType::MoveRightNoOverlap << ThrowingType::NoThrow; + QTest::newRow("no-throw-move-right-overlap") + << ThrowingType::MoveRightOverlap << ThrowingType::NoThrow; + QTest::newRow("no-throw-move-left-no-overlap") + << ThrowingType::MoveLeftNoOverlap << ThrowingType::NoThrow; + QTest::newRow("no-throw-move-left-overlap") + << ThrowingType::MoveLeftOverlap << ThrowingType::NoThrow; // Throwing in uninitialized region QTest::newRow("throw-in-uninit-region-move-right-no-overlap") - << GenericThrowingType::MoveRightNoOverlap - << GenericThrowingType::ThrowInUninitializedRegion; + << ThrowingType::MoveRightNoOverlap << ThrowingType::ThrowInUninitializedRegion; QTest::newRow("throw-in-uninit-region-move-right-overlap") - << GenericThrowingType::MoveRightOverlap << GenericThrowingType::ThrowInUninitializedRegion; + << ThrowingType::MoveRightOverlap << ThrowingType::ThrowInUninitializedRegion; QTest::newRow("throw-in-uninit-region-move-left-no-overlap") - << GenericThrowingType::MoveLeftNoOverlap - << GenericThrowingType::ThrowInUninitializedRegion; + << ThrowingType::MoveLeftNoOverlap << ThrowingType::ThrowInUninitializedRegion; QTest::newRow("throw-in-uninit-region-move-left-overlap") - << GenericThrowingType::MoveLeftOverlap << GenericThrowingType::ThrowInUninitializedRegion; - + << ThrowingType::MoveLeftOverlap << ThrowingType::ThrowInUninitializedRegion; // Throwing in overlap region QTest::newRow("throw-in-overlap-region-move-right-overlap") - << GenericThrowingType::MoveRightOverlap << GenericThrowingType::ThrowInOverlapRegion; + << ThrowingType::MoveRightOverlap << ThrowingType::ThrowInOverlapRegion; QTest::newRow("throw-in-overlap-region-move-left-overlap") - << GenericThrowingType::MoveLeftOverlap << GenericThrowingType::ThrowInOverlapRegion; + << ThrowingType::MoveLeftOverlap << ThrowingType::ThrowInOverlapRegion; } -void tst_QArrayData::moveNonPod() +void tst_QArrayData::relocateWithExceptions() { // Assume that non-throwing moves perform correctly. Otherwise, all previous // tests would've failed. Test only what happens when exceptions are thrown. + QFETCH(ThrowingType::MoveCase, moveCase); + QFETCH(ThrowingType::ThrowCase, throwCase); - QFETCH(GenericThrowingType::MoveCase, moveCase); - QFETCH(GenericThrowingType::ThrowCase, throwCase); - - struct WatcherScope + struct ThrowingTypeLeakChecker { - WatcherScope() { throwingTypeWatcher().watch = true; } - ~WatcherScope() + ThrowingType::MoveCase moveCase; + ThrowingType::ThrowCase throwCase; + size_t containerSize = 0; + + ThrowingTypeLeakChecker(ThrowingType::MoveCase mc, ThrowingType::ThrowCase tc) + : moveCase(mc), throwCase(tc) { - throwingTypeWatcher().watch = false; - throwingTypeWatcher().destroyedIds.clear(); } - }; - - const auto cast = [] (auto &dataPointer) { - return static_cast<PublicGenericMoveOps*>(std::addressof(dataPointer)); - }; - const auto setThrowingFlag = [throwCase] () { - switch (throwCase) { - case GenericThrowingType::ThrowInDtor: ThrowingType::throwOnceInDtor = 2; break; - case GenericThrowingType::ThrowInUninitializedRegion: ThrowingType::throwOnce = 2; break; - case GenericThrowingType::ThrowInOverlapRegion: ThrowingType::throwOnce = 3; break; - default: QFAIL("Unknown throwCase"); + void start(qsizetype size) + { + containerSize = size_t(size); + throwingTypeWatcher().watch = true; } - }; - const auto checkExceptionText = [throwCase] (const char *what) { - if (throwCase == GenericThrowingType::ThrowInDtor) { - QCOMPARE(std::string(what), ThrowingType::throwStringDtor); - } else { - QCOMPARE(std::string(what), ThrowingType::throwString); + ~ThrowingTypeLeakChecker() + { + const size_t destroyedElementsCount = throwingTypeWatcher().destroyedAddrs.size(); + const size_t destroyedElementsUniqueCount = + std::set<void *>(throwingTypeWatcher().destroyedAddrs.begin(), + throwingTypeWatcher().destroyedAddrs.end()) + .size(); + + // reset the global watcher first and only then verify things + throwingTypeWatcher().watch = false; + throwingTypeWatcher().destroyedAddrs.clear(); + + size_t deletedByRelocate = 0; + switch (throwCase) { + case ThrowingType::NoThrow: + // if no overlap, N elements from old range. otherwise, N - 1 + // elements from old range + if (moveCase == ThrowingType::MoveLeftNoOverlap + || moveCase == ThrowingType::MoveRightNoOverlap) { + deletedByRelocate = containerSize; + } else { + deletedByRelocate = containerSize - 1; + } + break; + case ThrowingType::ThrowInUninitializedRegion: + // 1 relocated element from uninitialized region + deletedByRelocate = 1u; + break; + case ThrowingType::ThrowInOverlapRegion: + // 2 relocated elements from uninitialized region + deletedByRelocate = 2u; + break; + default: + QFAIL("Unknown throwCase"); + } + + QCOMPARE(destroyedElementsCount, deletedByRelocate + containerSize); + QCOMPARE(destroyedElementsUniqueCount, destroyedElementsCount); } }; - const auto checkNoMemoryLeaks = [throwCase] (size_t extraDestroyedElements = 0) { - const size_t destroyedElementsCount = throwingTypeWatcher().destroyedIds.size(); + const auto setDeferredThrow = [throwCase]() { switch (throwCase) { - case GenericThrowingType::ThrowInDtor: - // 2 elements from uinitialized region + 2 elements from old range + extra if no overlap - QCOMPARE(destroyedElementsCount, 2u + 2u + extraDestroyedElements); - break; - case GenericThrowingType::ThrowInUninitializedRegion: - // always 1 element from uninitialized region - QCOMPARE(destroyedElementsCount, 1u); + case ThrowingType::NoThrow: + break; // do nothing + case ThrowingType::ThrowInUninitializedRegion: + ThrowingType::throwOnce = 2; break; - case GenericThrowingType::ThrowInOverlapRegion: - // always 2 elements from uninitialized region - QCOMPARE(destroyedElementsCount, 2u); + case ThrowingType::ThrowInOverlapRegion: + ThrowingType::throwOnce = 3; break; - default: QFAIL("Unknown throwCase"); + default: + QFAIL("Unknown throwCase"); } }; + const auto createDataPointer = [](qsizetype capacity, qsizetype initSize) { + QArrayDataPointer<ThrowingType> qadp(capacity); + qadp->appendInitialize(initSize); + int i = 0; + std::generate(qadp.begin(), qadp.end(), [&i]() { return ThrowingType(i++); }); + return qadp; + }; + switch (moveCase) { - case GenericThrowingType::MoveRightNoOverlap : { // moving right without overlap - auto storage = createDataPointer<GenericThrowingType>(20, 3); + case ThrowingType::MoveRightNoOverlap: { + ThrowingTypeLeakChecker watch(moveCase, throwCase); + auto storage = createDataPointer(20, 3); QVERIFY(storage.freeSpaceAtEnd() > 3); - WatcherScope scope; Q_UNUSED(scope); + watch.start(storage.size); try { - setThrowingFlag(); - cast(storage)->public_moveInGrowthDirection(QtPrivate::GrowsForwardTag{}, 4); - QFAIL("Unreachable line!"); + setDeferredThrow(); + storage->relocate(4); + if (throwCase != ThrowingType::NoThrow) + QFAIL("Unreachable line!"); } catch (const std::runtime_error &e) { - checkExceptionText(e.what()); + QCOMPARE(std::string(e.what()), ThrowingType::throwString); } - checkNoMemoryLeaks(1); break; } - case GenericThrowingType::MoveRightOverlap: { // moving right with overlap - auto storage = createDataPointer<GenericThrowingType>(20, 3); + case ThrowingType::MoveRightOverlap: { + ThrowingTypeLeakChecker watch(moveCase, throwCase); + auto storage = createDataPointer(20, 3); QVERIFY(storage.freeSpaceAtEnd() > 3); - WatcherScope scope; Q_UNUSED(scope); + watch.start(storage.size); try { - setThrowingFlag(); - cast(storage)->public_moveInGrowthDirection(QtPrivate::GrowsForwardTag{}, 2); - QFAIL("Unreachable line!"); + setDeferredThrow(); + storage->relocate(2); + if (throwCase != ThrowingType::NoThrow) + QFAIL("Unreachable line!"); } catch (const std::runtime_error &e) { - checkExceptionText(e.what()); + QCOMPARE(std::string(e.what()), ThrowingType::throwString); } - checkNoMemoryLeaks(); break; } - case GenericThrowingType::MoveLeftNoOverlap: { // moving left without overlap - auto storage = createDataPointer<GenericThrowingType>(20, 2); - storage->insert(storage.begin(), 1, GenericThrowingType(42)); + case ThrowingType::MoveLeftNoOverlap: { + ThrowingTypeLeakChecker watch(moveCase, throwCase); + auto storage = createDataPointer(20, 2); + storage->insert(0, 1, ThrowingType(42)); QVERIFY(storage.freeSpaceAtBegin() > 3); - WatcherScope scope; Q_UNUSED(scope); + watch.start(storage.size); try { - setThrowingFlag(); - cast(storage)->public_moveInGrowthDirection(QtPrivate::GrowsBackwardsTag{}, 4); - QFAIL("Unreachable line!"); + setDeferredThrow(); + storage->relocate(-4); + if (throwCase != ThrowingType::NoThrow) + QFAIL("Unreachable line!"); } catch (const std::runtime_error &e) { - checkExceptionText(e.what()); + QCOMPARE(std::string(e.what()), ThrowingType::throwString); } - checkNoMemoryLeaks(1); break; } - case GenericThrowingType::MoveLeftOverlap: { - auto storage = createDataPointer<GenericThrowingType>(20, 2); - storage->insert(storage.begin(), 1, GenericThrowingType(42)); + case ThrowingType::MoveLeftOverlap: { + ThrowingTypeLeakChecker watch(moveCase, throwCase); + auto storage = createDataPointer(20, 2); + storage->insert(0, 1, ThrowingType(42)); QVERIFY(storage.freeSpaceAtBegin() > 3); - WatcherScope scope; Q_UNUSED(scope); + watch.start(storage.size); try { - setThrowingFlag(); - cast(storage)->public_moveInGrowthDirection(QtPrivate::GrowsBackwardsTag{}, 2); - QFAIL("Unreachable line!"); + setDeferredThrow(); + storage->relocate(-2); + if (throwCase != ThrowingType::NoThrow) + QFAIL("Unreachable line!"); } catch (const std::runtime_error &e) { - checkExceptionText(e.what()); + QCOMPARE(std::string(e.what()), ThrowingType::throwString); } - checkNoMemoryLeaks(); break; } - default: QFAIL("Unknown moveCase"); + default: + QFAIL("Unknown ThrowingType::MoveCase"); }; } -#endif // QT_NO_EXCEPTIONS +#endif // QT_NO_EXCEPTIONS QTEST_APPLESS_MAIN(tst_QArrayData) #include "tst_qarraydata.moc" |