summaryrefslogtreecommitdiffstats
path: root/tests/auto/corelib/tools/qvector/tst_qvector.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'tests/auto/corelib/tools/qvector/tst_qvector.cpp')
-rw-r--r--tests/auto/corelib/tools/qvector/tst_qvector.cpp944
1 files changed, 944 insertions, 0 deletions
diff --git a/tests/auto/corelib/tools/qvector/tst_qvector.cpp b/tests/auto/corelib/tools/qvector/tst_qvector.cpp
new file mode 100644
index 0000000000..4cc2bc481a
--- /dev/null
+++ b/tests/auto/corelib/tools/qvector/tst_qvector.cpp
@@ -0,0 +1,944 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the test suite of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** GNU Lesser General Public License Usage
+** This file may be used under the terms of the GNU Lesser General Public
+** License version 2.1 as published by the Free Software Foundation and
+** appearing in the file LICENSE.LGPL included in the packaging of this
+** file. Please review the following information to ensure the GNU Lesser
+** General Public License version 2.1 requirements will be met:
+** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU General
+** Public License version 3.0 as published by the Free Software Foundation
+** and appearing in the file LICENSE.GPL included in the packaging of this
+** file. Please review the following information to ensure the GNU General
+** Public License version 3.0 requirements will be met:
+** http://www.gnu.org/copyleft/gpl.html.
+**
+** Other Usage
+** Alternatively, this file may be used in accordance with the terms and
+** conditions contained in a signed written agreement between you and Nokia.
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#include <QtTest/QtTest>
+#include <qvector.h>
+
+//TESTED_CLASS=
+//TESTED_FILES=corelib/tools/qregexp.h corelib/tools/qregexp.cpp
+
+class tst_QVector : public QObject
+{
+ Q_OBJECT
+
+public:
+ tst_QVector() {}
+ virtual ~tst_QVector() {}
+
+private slots:
+ void constructors() const;
+ void append() const;
+ void at() const;
+ void capacity() const;
+ void clear() const;
+ void constData() const;
+ void contains() const;
+ void count() const;
+ void data() const;
+ void empty() const;
+ void endsWith() const;
+ void fill() const;
+ void first() const;
+ void fromList() const;
+ void fromStdVector() const;
+ void indexOf() const;
+ void insert() const;
+ void isEmpty() const;
+ void last() const;
+ void lastIndexOf() const;
+ void mid() const;
+ void prepend() const;
+ void remove() const;
+ void size() const;
+ void startsWith() const;
+ void swap() const;
+ void toList() const;
+ void toStdVector() const;
+ void value() const;
+
+ void testOperators() const;
+
+ void outOfMemory();
+ void QTBUG6416_reserve();
+ void QTBUG11763_data();
+ void QTBUG11763();
+ void initializeList();
+};
+
+void tst_QVector::constructors() const
+{
+ // pre-reserve capacity
+ {
+ QVector<int> myvec(5);
+
+ QVERIFY(myvec.capacity() == 5);
+ }
+
+ // default-initialise items
+ {
+ QVector<int> myvec(5, 42);
+
+ QVERIFY(myvec.capacity() == 5);
+
+ // make sure all items are initialised ok
+ foreach (int meaningoflife, myvec) {
+ QCOMPARE(meaningoflife, 42);
+ }
+ }
+}
+
+void tst_QVector::append() const
+{
+ QVector<int> myvec;
+ myvec.append(42);
+ myvec.append(43);
+ myvec.append(44);
+
+ QVERIFY(myvec.size() == 3);
+ QCOMPARE(myvec, QVector<int>() << 42 << 43 << 44);
+}
+
+void tst_QVector::at() const
+{
+ QVector<QString> myvec;
+ myvec << "foo" << "bar" << "baz";
+
+ QVERIFY(myvec.size() == 3);
+ QCOMPARE(myvec.at(0), QLatin1String("foo"));
+ QCOMPARE(myvec.at(1), QLatin1String("bar"));
+ QCOMPARE(myvec.at(2), QLatin1String("baz"));
+
+ // append an item
+ myvec << "hello";
+ QVERIFY(myvec.size() == 4);
+ QCOMPARE(myvec.at(0), QLatin1String("foo"));
+ QCOMPARE(myvec.at(1), QLatin1String("bar"));
+ QCOMPARE(myvec.at(2), QLatin1String("baz"));
+ QCOMPARE(myvec.at(3), QLatin1String("hello"));
+
+ // remove an item
+ myvec.remove(1);
+ QVERIFY(myvec.size() == 3);
+ QCOMPARE(myvec.at(0), QLatin1String("foo"));
+ QCOMPARE(myvec.at(1), QLatin1String("baz"));
+ QCOMPARE(myvec.at(2), QLatin1String("hello"));
+}
+
+void tst_QVector::capacity() const
+{
+ QVector<QString> myvec;
+
+ // TODO: is this guaranteed? seems a safe assumption, but I suppose preallocation of a
+ // few items isn't an entirely unforseeable possibility.
+ QVERIFY(myvec.capacity() == 0);
+
+ // test it gets a size
+ myvec << "aaa" << "bbb" << "ccc";
+ QVERIFY(myvec.capacity() >= 3);
+
+ // make sure it grows ok
+ myvec << "aaa" << "bbb" << "ccc";
+ QVERIFY(myvec.capacity() >= 6);
+
+ // let's try squeeze a bit
+ myvec.remove(3);
+ myvec.remove(3);
+ myvec.remove(3);
+ // TODO: is this a safe assumption? presumably it won't release memory until shrink(), but can we asser that is true?
+ QVERIFY(myvec.capacity() >= 6);
+ myvec.squeeze();
+ QVERIFY(myvec.capacity() >= 3);
+
+ myvec.remove(0);
+ myvec.remove(0);
+ myvec.remove(0);
+ // TODO: as above note
+ QVERIFY(myvec.capacity() >= 3);
+ myvec.squeeze();
+ QVERIFY(myvec.capacity() == 0);
+}
+
+void tst_QVector::clear() const
+{
+ QVector<QString> myvec;
+ myvec << "aaa" << "bbb" << "ccc";
+
+ QVERIFY(myvec.size() == 3);
+ myvec.clear();
+ QVERIFY(myvec.size() == 0);
+ QVERIFY(myvec.capacity() == 0);
+}
+
+void tst_QVector::constData() const
+{
+ int arr[] = { 42, 43, 44 };
+ QVector<int> myvec;
+ myvec << 42 << 43 << 44;
+
+ QVERIFY(memcmp(myvec.constData(), reinterpret_cast<const int *>(&arr), sizeof(int) * 3) == 0);
+}
+
+void tst_QVector::contains() const
+{
+ QVector<QString> myvec;
+ myvec << "aaa" << "bbb" << "ccc";
+
+ QVERIFY(myvec.contains(QLatin1String("aaa")));
+ QVERIFY(myvec.contains(QLatin1String("bbb")));
+ QVERIFY(myvec.contains(QLatin1String("ccc")));
+ QVERIFY(!myvec.contains(QLatin1String("I don't exist")));
+
+ // add it and make sure it does :)
+ myvec.append(QLatin1String("I don't exist"));
+ QVERIFY(myvec.contains(QLatin1String("I don't exist")));
+}
+
+void tst_QVector::count() const
+{
+ // total size
+ {
+ // zero size
+ QVector<int> myvec;
+ QVERIFY(myvec.count() == 0);
+
+ // grow
+ myvec.append(42);
+ QVERIFY(myvec.count() == 1);
+ myvec.append(42);
+ QVERIFY(myvec.count() == 2);
+
+ // shrink
+ myvec.remove(0);
+ QVERIFY(myvec.count() == 1);
+ myvec.remove(0);
+ QVERIFY(myvec.count() == 0);
+ }
+
+ // count of items
+ {
+ QVector<QString> myvec;
+ myvec << "aaa" << "bbb" << "ccc";
+
+ // initial tests
+ QVERIFY(myvec.count(QLatin1String("aaa")) == 1);
+ QVERIFY(myvec.count(QLatin1String("pirates")) == 0);
+
+ // grow
+ myvec.append(QLatin1String("aaa"));
+ QVERIFY(myvec.count(QLatin1String("aaa")) == 2);
+
+ // shrink
+ myvec.remove(0);
+ QVERIFY(myvec.count(QLatin1String("aaa")) == 1);
+ }
+}
+
+void tst_QVector::data() const
+{
+ QVector<int> myvec;
+ myvec << 42 << 43 << 44;
+
+ // make sure it starts off ok
+ QCOMPARE(*(myvec.data() + 1), 43);
+
+ // alter it
+ *(myvec.data() + 1) = 69;
+
+ // check it altered
+ QCOMPARE(*(myvec.data() + 1), 69);
+
+ int arr[] = { 42, 69, 44 };
+ QVERIFY(memcmp(myvec.data(), reinterpret_cast<int *>(&arr), sizeof(int) * 3) == 0);
+}
+
+void tst_QVector::empty() const
+{
+ QVector<int> myvec;
+
+ // starts empty
+ QVERIFY(myvec.empty());
+
+ // not empty
+ myvec.append(1);
+ QVERIFY(!myvec.empty());
+
+ // empty again
+ myvec.remove(0);
+ QVERIFY(myvec.empty());
+}
+
+void tst_QVector::endsWith() const
+{
+ QVector<int> myvec;
+
+ // empty vector
+ QVERIFY(!myvec.endsWith(1));
+
+ // add the one, should work
+ myvec.append(1);
+ QVERIFY(myvec.endsWith(1));
+
+ // add something else, fails now
+ myvec.append(3);
+ QVERIFY(!myvec.endsWith(1));
+
+ // remove it again :)
+ myvec.remove(1);
+ QVERIFY(myvec.endsWith(1));
+}
+
+void tst_QVector::fill() const
+{
+ QVector<int> myvec;
+
+ // resize
+ myvec.resize(5);
+ myvec.fill(69);
+ QCOMPARE(myvec, QVector<int>() << 69 << 69 << 69 << 69 << 69);
+
+ // make sure it can resize itself too
+ myvec.fill(42, 10);
+ QCOMPARE(myvec, QVector<int>() << 42 << 42 << 42 << 42 << 42 << 42 << 42 << 42 << 42 << 42);
+}
+
+void tst_QVector::first() const
+{
+ QVector<int> myvec;
+ myvec << 69 << 42 << 3;
+
+ // test it starts ok
+ QCOMPARE(myvec.first(), 69);
+
+ // test removal changes
+ myvec.remove(0);
+ QCOMPARE(myvec.first(), 42);
+
+ // test prepend changes
+ myvec.prepend(23);
+ QCOMPARE(myvec.first(), 23);
+}
+
+void tst_QVector::fromList() const
+{
+ QList<QString> list;
+ list << "aaa" << "bbb" << "ninjas" << "pirates";
+
+ QVector<QString> myvec;
+ myvec = QVector<QString>::fromList(list);
+
+ // test it worked ok
+ QCOMPARE(myvec, QVector<QString>() << "aaa" << "bbb" << "ninjas" << "pirates");
+ QCOMPARE(list, QList<QString>() << "aaa" << "bbb" << "ninjas" << "pirates");
+}
+
+void tst_QVector::fromStdVector() const
+{
+ // stl = :(
+ std::vector<QString> svec;
+ svec.push_back(QLatin1String("aaa"));
+ svec.push_back(QLatin1String("bbb"));
+ svec.push_back(QLatin1String("ninjas"));
+ svec.push_back(QLatin1String("pirates"));
+ QVector<QString> myvec = QVector<QString>::fromStdVector(svec);
+
+ // test it converts ok
+ QCOMPARE(myvec, QVector<QString>() << "aaa" << "bbb" << "ninjas" << "pirates");
+}
+
+void tst_QVector::indexOf() const
+{
+ QVector<QString> myvec;
+ myvec << "A" << "B" << "C" << "B" << "A";
+
+ QVERIFY(myvec.indexOf("B") == 1);
+ QVERIFY(myvec.indexOf("B", 1) == 1);
+ QVERIFY(myvec.indexOf("B", 2) == 3);
+ QVERIFY(myvec.indexOf("X") == -1);
+ QVERIFY(myvec.indexOf("X", 2) == -1);
+
+ // add an X
+ myvec << "X";
+ QVERIFY(myvec.indexOf("X") == 5);
+ QVERIFY(myvec.indexOf("X", 5) == 5);
+ QVERIFY(myvec.indexOf("X", 6) == -1);
+
+ // remove first A
+ myvec.remove(0);
+ QVERIFY(myvec.indexOf("A") == 3);
+ QVERIFY(myvec.indexOf("A", 3) == 3);
+ QVERIFY(myvec.indexOf("A", 4) == -1);
+}
+
+void tst_QVector::insert() const
+{
+ QVector<QString> myvec;
+ myvec << "A" << "B" << "C";
+
+ // first position
+ QCOMPARE(myvec.at(0), QLatin1String("A"));
+ myvec.insert(0, QLatin1String("X"));
+ QCOMPARE(myvec.at(0), QLatin1String("X"));
+ QCOMPARE(myvec.at(1), QLatin1String("A"));
+
+ // middle
+ myvec.insert(1, QLatin1String("Z"));
+ QCOMPARE(myvec.at(0), QLatin1String("X"));
+ QCOMPARE(myvec.at(1), QLatin1String("Z"));
+ QCOMPARE(myvec.at(2), QLatin1String("A"));
+
+ // end
+ myvec.insert(5, QLatin1String("T"));
+ QCOMPARE(myvec.at(5), QLatin1String("T"));
+ QCOMPARE(myvec.at(4), QLatin1String("C"));
+
+ // insert a lot of garbage in the middle
+ myvec.insert(2, 2, QLatin1String("infinity"));
+ QCOMPARE(myvec, QVector<QString>() << "X" << "Z" << "infinity" << "infinity"
+ << "A" << "B" << "C" << "T");
+}
+
+void tst_QVector::isEmpty() const
+{
+ QVector<QString> myvec;
+
+ // starts ok
+ QVERIFY(myvec.isEmpty());
+
+ // not empty now
+ myvec.append(QLatin1String("hello there"));
+ QVERIFY(!myvec.isEmpty());
+
+ // empty again
+ myvec.remove(0);
+ QVERIFY(myvec.isEmpty());
+}
+
+void tst_QVector::last() const
+{
+ QVector<QString> myvec;
+ myvec << "A" << "B" << "C";
+
+ // test starts ok
+ QCOMPARE(myvec.last(), QLatin1String("C"));
+
+ // test it changes ok
+ myvec.append(QLatin1String("X"));
+ QCOMPARE(myvec.last(), QLatin1String("X"));
+
+ // and remove again
+ myvec.remove(3);
+ QCOMPARE(myvec.last(), QLatin1String("C"));
+}
+
+void tst_QVector::lastIndexOf() const
+{
+ QVector<QString> myvec;
+ myvec << "A" << "B" << "C" << "B" << "A";
+
+ QVERIFY(myvec.lastIndexOf("B") == 3);
+ QVERIFY(myvec.lastIndexOf("B", 2) == 1);
+ QVERIFY(myvec.lastIndexOf("X") == -1);
+ QVERIFY(myvec.lastIndexOf("X", 2) == -1);
+
+ // add an X
+ myvec << "X";
+ QVERIFY(myvec.lastIndexOf("X") == 5);
+ QVERIFY(myvec.lastIndexOf("X", 5) == 5);
+ QVERIFY(myvec.lastIndexOf("X", 3) == -1);
+
+ // remove first A
+ myvec.remove(0);
+ QVERIFY(myvec.lastIndexOf("A") == 3);
+ QVERIFY(myvec.lastIndexOf("A", 3) == 3);
+ QVERIFY(myvec.lastIndexOf("A", 2) == -1);
+}
+
+void tst_QVector::mid() const
+{
+ QVector<QString> list;
+ list << "foo" << "bar" << "baz" << "bak" << "buck" << "hello" << "kitty";
+
+ QCOMPARE(list.mid(3, 3), QVector<QString>() << "bak" << "buck" << "hello");
+ QCOMPARE(list.mid(4), QVector<QString>() << "buck" << "hello" << "kitty");
+}
+
+void tst_QVector::prepend() const
+{
+ QVector<QString> myvec;
+ myvec << "A" << "B" << "C";
+
+ // starts ok
+ QVERIFY(myvec.size() == 3);
+ QCOMPARE(myvec.at(0), QLatin1String("A"));
+
+ // add something
+ myvec.prepend(QLatin1String("X"));
+ QCOMPARE(myvec.at(0), QLatin1String("X"));
+ QCOMPARE(myvec.at(1), QLatin1String("A"));
+ QVERIFY(myvec.size() == 4);
+
+ // something else
+ myvec.prepend(QLatin1String("Z"));
+ QCOMPARE(myvec.at(0), QLatin1String("Z"));
+ QCOMPARE(myvec.at(1), QLatin1String("X"));
+ QCOMPARE(myvec.at(2), QLatin1String("A"));
+ QVERIFY(myvec.size() == 5);
+
+ // clear and append to an empty vector
+ myvec.clear();
+ QVERIFY(myvec.size() == 0);
+ myvec.prepend(QLatin1String("ninjas"));
+ QVERIFY(myvec.size() == 1);
+ QCOMPARE(myvec.at(0), QLatin1String("ninjas"));
+}
+
+void tst_QVector::remove() const
+{
+ QVector<QString> myvec;
+ myvec << "A" << "B" << "C";
+
+ // remove middle
+ myvec.remove(1);
+ QCOMPARE(myvec, QVector<QString>() << "A" << "C");
+
+ // remove rest
+ myvec.remove(0, 2);
+ QCOMPARE(myvec, QVector<QString>());
+}
+
+// ::reserve() is really hard to think of tests for, so not doing it.
+// ::resize() is tested in ::capacity().
+
+void tst_QVector::size() const
+{
+ // total size
+ {
+ // zero size
+ QVector<int> myvec;
+ QVERIFY(myvec.size() == 0);
+
+ // grow
+ myvec.append(42);
+ QVERIFY(myvec.size() == 1);
+ myvec.append(42);
+ QVERIFY(myvec.size() == 2);
+
+ // shrink
+ myvec.remove(0);
+ QVERIFY(myvec.size() == 1);
+ myvec.remove(0);
+ QVERIFY(myvec.size() == 0);
+ }
+}
+
+// ::squeeze() is tested in ::capacity().
+
+void tst_QVector::startsWith() const
+{
+ QVector<int> myvec;
+
+ // empty vector
+ QVERIFY(!myvec.startsWith(1));
+
+ // add the one, should work
+ myvec.prepend(1);
+ QVERIFY(myvec.startsWith(1));
+
+ // add something else, fails now
+ myvec.prepend(3);
+ QVERIFY(!myvec.startsWith(1));
+
+ // remove it again :)
+ myvec.remove(0);
+ QVERIFY(myvec.startsWith(1));
+}
+
+void tst_QVector::swap() const
+{
+ QVector<int> v1, v2;
+ v1 << 1 << 2 << 3;
+ v2 << 4 << 5 << 6;
+
+ v1.swap(v2);
+ QCOMPARE(v1,QVector<int>() << 4 << 5 << 6);
+ QCOMPARE(v2,QVector<int>() << 1 << 2 << 3);
+}
+
+void tst_QVector::toList() const
+{
+ QVector<QString> myvec;
+ myvec << "A" << "B" << "C";
+
+ // make sure it converts and doesn't modify the original vector
+ QCOMPARE(myvec.toList(), QList<QString>() << "A" << "B" << "C");
+ QCOMPARE(myvec, QVector<QString>() << "A" << "B" << "C");
+}
+
+void tst_QVector::toStdVector() const
+{
+ QVector<QString> myvec;
+ myvec << "A" << "B" << "C";
+
+ std::vector<QString> svec = myvec.toStdVector();
+ QCOMPARE(svec.at(0), QLatin1String("A"));
+ QCOMPARE(svec.at(1), QLatin1String("B"));
+ QCOMPARE(svec.at(2), QLatin1String("C"));
+
+ QCOMPARE(myvec, QVector<QString>() << "A" << "B" << "C");
+}
+
+void tst_QVector::value() const
+{
+ QVector<QString> myvec;
+ myvec << "A" << "B" << "C";
+
+ // valid calls
+ QCOMPARE(myvec.value(0), QLatin1String("A"));
+ QCOMPARE(myvec.value(1), QLatin1String("B"));
+ QCOMPARE(myvec.value(2), QLatin1String("C"));
+
+ // default calls
+ QCOMPARE(myvec.value(-1), QString());
+ QCOMPARE(myvec.value(3), QString());
+
+ // test calls with a provided default, valid calls
+ QCOMPARE(myvec.value(0, QLatin1String("default")), QLatin1String("A"));
+ QCOMPARE(myvec.value(1, QLatin1String("default")), QLatin1String("B"));
+ QCOMPARE(myvec.value(2, QLatin1String("default")), QLatin1String("C"));
+
+ // test calls with a provided default that will return the default
+ QCOMPARE(myvec.value(-1, QLatin1String("default")), QLatin1String("default"));
+ QCOMPARE(myvec.value(3, QLatin1String("default")), QLatin1String("default"));
+}
+
+void tst_QVector::testOperators() const
+{
+ QVector<QString> myvec;
+ myvec << "A" << "B" << "C";
+ QVector<QString> myvectwo;
+ myvectwo << "D" << "E" << "F";
+ QVector<QString> combined;
+ combined << "A" << "B" << "C" << "D" << "E" << "F";
+
+ // !=
+ QVERIFY(myvec != myvectwo);
+
+ // +
+ QCOMPARE(myvec + myvectwo, combined);
+ QCOMPARE(myvec, QVector<QString>() << "A" << "B" << "C");
+ QCOMPARE(myvectwo, QVector<QString>() << "D" << "E" << "F");
+
+ // +=
+ myvec += myvectwo;
+ QCOMPARE(myvec, combined);
+
+ // ==
+ QVERIFY(myvec == combined);
+
+ // []
+ QCOMPARE(myvec[0], QLatin1String("A"));
+ QCOMPARE(myvec[1], QLatin1String("B"));
+ QCOMPARE(myvec[2], QLatin1String("C"));
+ QCOMPARE(myvec[3], QLatin1String("D"));
+ QCOMPARE(myvec[4], QLatin1String("E"));
+ QCOMPARE(myvec[5], QLatin1String("F"));
+}
+
+
+int fooCtor;
+int fooDtor;
+
+struct Foo
+{
+ int *p;
+
+ Foo() { p = new int; ++fooCtor; }
+ Foo(const Foo &other) { Q_UNUSED(other); p = new int; ++fooCtor; }
+
+ void operator=(const Foo & /* other */) { }
+
+ ~Foo() { delete p; ++fooDtor; }
+};
+
+void tst_QVector::outOfMemory()
+{
+ fooCtor = 0;
+ fooDtor = 0;
+
+ const int N = 0x7fffffff / sizeof(Foo);
+
+ {
+ QVector<Foo> a;
+
+ QSKIP("This test crashes on many of our machines.", SkipSingle);
+ a.resize(N);
+ if (a.size() == N) {
+ QVERIFY(a.capacity() >= N);
+ QCOMPARE(fooCtor, N);
+ QCOMPARE(fooDtor, 0);
+
+ for (int i = 0; i < N; i += 35000)
+ a[i] = Foo();
+ } else {
+ // this is the case we're actually testing
+ QCOMPARE(a.size(), 0);
+ QCOMPARE(a.capacity(), 0);
+ QCOMPARE(fooCtor, 0);
+ QCOMPARE(fooDtor, 0);
+
+ a.resize(5);
+ QCOMPARE(a.size(), 5);
+ QVERIFY(a.capacity() >= 5);
+ QCOMPARE(fooCtor, 5);
+ QCOMPARE(fooDtor, 0);
+
+ const int Prealloc = a.capacity();
+ a.resize(Prealloc + 1);
+ QCOMPARE(a.size(), Prealloc + 1);
+ QVERIFY(a.capacity() >= Prealloc + 1);
+ QCOMPARE(fooCtor, Prealloc + 6);
+ QCOMPARE(fooDtor, 5);
+
+ a.resize(0x10000000);
+ QCOMPARE(a.size(), 0);
+ QCOMPARE(a.capacity(), 0);
+ QCOMPARE(fooCtor, Prealloc + 6);
+ QCOMPARE(fooDtor, Prealloc + 6);
+ }
+ }
+
+ fooCtor = 0;
+ fooDtor = 0;
+
+ {
+ QVector<Foo> a(N);
+ if (a.size() == N) {
+ QVERIFY(a.capacity() >= N);
+ QCOMPARE(fooCtor, N);
+ QCOMPARE(fooDtor, 0);
+
+ for (int i = 0; i < N; i += 35000)
+ a[i] = Foo();
+ } else {
+ // this is the case we're actually testing
+ QCOMPARE(a.size(), 0);
+ QCOMPARE(a.capacity(), 0);
+ QCOMPARE(fooCtor, 0);
+ QCOMPARE(fooDtor, 0);
+ }
+ }
+
+ Foo foo;
+
+ fooCtor = 0;
+ fooDtor = 0;
+
+ {
+ QVector<Foo> a(N, foo);
+ if (a.size() == N) {
+ QVERIFY(a.capacity() >= N);
+ QCOMPARE(fooCtor, N);
+ QCOMPARE(fooDtor, 0);
+
+ for (int i = 0; i < N; i += 35000)
+ a[i] = Foo();
+ } else {
+ // this is the case we're actually testing
+ QCOMPARE(a.size(), 0);
+ QCOMPARE(a.capacity(), 0);
+ QCOMPARE(fooCtor, 0);
+ QCOMPARE(fooDtor, 0);
+ }
+ }
+
+ fooCtor = 0;
+ fooDtor = 0;
+
+ {
+ QVector<Foo> a;
+ a.resize(10);
+ QCOMPARE(fooCtor, 10);
+ QCOMPARE(fooDtor, 0);
+
+ QVector<Foo> b(a);
+ QCOMPARE(fooCtor, 10);
+ QCOMPARE(fooDtor, 0);
+
+ a.resize(N);
+ if (a.size() == N) {
+ QCOMPARE(fooCtor, N + 10);
+ } else {
+ QCOMPARE(a.size(), 0);
+ QCOMPARE(a.capacity(), 0);
+ QCOMPARE(fooCtor, 10);
+ QCOMPARE(fooDtor, 0);
+
+ QCOMPARE(b.size(), 10);
+ QVERIFY(b.capacity() >= 10);
+ }
+ }
+
+ {
+ QVector<int> a;
+ a.resize(10);
+
+ QVector<int> b(a);
+
+ a.resize(N);
+ if (a.size() == N) {
+ for (int i = 0; i < N; i += 60000)
+ a[i] = i;
+ } else {
+ QCOMPARE(a.size(), 0);
+ QCOMPARE(a.capacity(), 0);
+
+ QCOMPARE(b.size(), 10);
+ QVERIFY(b.capacity() >= 10);
+ }
+
+ b.resize(N - 1);
+ if (b.size() == N - 1) {
+ for (int i = 0; i < N - 1; i += 60000)
+ b[i] = i;
+ } else {
+ QCOMPARE(b.size(), 0);
+ QCOMPARE(b.capacity(), 0);
+ }
+ }
+}
+
+void tst_QVector::QTBUG6416_reserve()
+{
+ fooCtor = 0;
+ fooDtor = 0;
+ {
+ QVector<Foo> a;
+ a.resize(2);
+ QVector<Foo> b(a);
+ b.reserve(1);
+ }
+ QCOMPARE(fooCtor, fooDtor);
+}
+
+void tst_QVector::QTBUG11763_data()
+{
+ QTest::addColumn<int>("capacity");
+ QTest::addColumn<int>("fill_size");
+ QTest::addColumn<int>("func_id");
+ QTest::addColumn<int>("result1");
+ QTest::addColumn<int>("result2");
+ QTest::addColumn<int>("result3");
+ QTest::addColumn<int>("result4");
+
+ int result1, result2, result3, result4;
+ int fill_size;
+ for (int i = 70; i <= 100; i += 10) {
+ fill_size = i - 20;
+ for (int j = 0; j <= 3; j++) {
+ if (j == 0) { // append
+ result1 = i;
+ result2 = i;
+ result3 = i - 19;
+ result4 = i - 20;
+ } else if (j == 1) { // insert(0)
+ result1 = i;
+ result2 = i;
+ result3 = i - 19;
+ result4 = i - 20;
+ } else if (j == 2) { // insert(20)
+ result1 = i;
+ result2 = i;
+ result3 = i - 19;
+ result4 = i - 20;
+ } else if (j == 3) { // insert(0, 10)
+ result1 = i;
+ result2 = i;
+ result3 = i - 10;
+ result4 = i - 20;
+ }
+ QTest::newRow(qPrintable(QString("QTBUG11763:%1").arg(i))) << i << fill_size << j << result1 << result2 << result3 << result4;
+ }
+ }
+}
+
+void tst_QVector::QTBUG11763()
+{
+ QFETCH(int, capacity);
+ QFETCH(int, fill_size);
+ QFETCH(int, func_id);
+ QFETCH(int, result1);
+ QFETCH(int, result2);
+ QFETCH(int, result3);
+ QFETCH(int, result4);
+
+ QVector<qreal> v1;
+ QVector<qreal> v2;
+
+ v1.reserve(capacity);
+ v1.resize(0);
+ v1.fill(qreal(1.0), fill_size);
+
+ v2 = v1;
+
+ // no need to test begin() and end(), there is a detach() in them
+ if (func_id == 0) {
+ v1.append(qreal(1.0)); //push_back is same as append
+ } else if (func_id == 1) {
+ v1.insert(0, qreal(1.0)); //push_front is same as prepend, insert(0)
+ } else if (func_id == 2) {
+ v1.insert(20, qreal(1.0));
+ } else if (func_id == 3) {
+ v1.insert(0, 10, qreal(1.0));
+ }
+
+ QCOMPARE(v1.capacity(), result1);
+ QCOMPARE(v2.capacity(), result2);
+ QCOMPARE(v1.size(), result3);
+ QCOMPARE(v2.size(), result4);
+}
+
+void tst_QVector::initializeList()
+{
+#ifdef Q_COMPILER_INITIALIZER_LISTS
+ QVector<int> v1{2,3,4};
+ QCOMPARE(v1, QVector<int>() << 2 << 3 << 4);
+ QCOMPARE(v1, (QVector<int>{2,3,4}));
+
+ QVector<QVector<int>> v2{ v1, {1}, QVector<int>(), {2,3,4} };
+ QVector<QVector<int>> v3;
+ v3 << v1 << (QVector<int>() << 1) << QVector<int>() << v1;
+ QCOMPARE(v3, v2);
+#endif
+}
+
+QTEST_APPLESS_MAIN(tst_QVector)
+#include "tst_qvector.moc"
generated by cgit v1.2.3 (git 2.25.1) at 2024-04-16 22:23:54 +0000