#include <QtCore/qiterator.h>
#include <QtCore/qlist.h>
#include <QtCore/qrefcount.h>
+#include <QtCore/qarraydata.h>
#include <iterator>
#include <vector>
QT_BEGIN_NAMESPACE
-
-struct Q_CORE_EXPORT QVectorData
-{
- QtPrivate::RefCount ref;
- int size;
- uint alloc : 31;
- uint capacityReserved : 1;
-
- qptrdiff offset;
-
- void* data() { return reinterpret_cast<char *>(this) + this->offset; }
-
- static const QVectorData shared_null;
- static QVectorData *allocate(int size, int alignment);
- static QVectorData *reallocate(QVectorData *old, int newsize, int oldsize, int alignment);
- static void free(QVectorData *data, int alignment);
- static int grow(int sizeOfHeader, int size, int sizeOfT);
-};
-
-template <typename T>
-struct QVectorTypedData : QVectorData
-{
- T* begin() { return reinterpret_cast<T *>(this->data()); }
- T* end() { return begin() + this->size; }
-
- static QVectorTypedData *sharedNull() { return static_cast<QVectorTypedData *>(const_cast<QVectorData *>(&QVectorData::shared_null)); }
-};
-
class QRegion;
template <typename T>
class QVector
{
- typedef QVectorTypedData<T> Data;
+ typedef QTypedArrayData<T> Data;
Data *d;
public:
inline QVector() : d(Data::sharedNull()) { }
explicit QVector(int size);
QVector(int size, const T &t);
- inline QVector(const QVector<T> &v)
- {
- if (v.d->ref.ref()) {
- d = v.d;
- } else {
- d = Data::sharedNull();
- realloc(0, int(v.d->alloc));
- qCopy(v.d->begin(), v.d->end(), d->begin());
- d->size = v.d->size;
- d->capacityReserved = v.d->capacityReserved;
- }
- }
-
+ inline QVector(const QVector<T> &v);
inline ~QVector() { if (!d->ref.deref()) free(d); }
QVector<T> &operator=(const QVector<T> &v);
#ifdef Q_COMPILER_RVALUE_REFS
inline int capacity() const { return int(d->alloc); }
void reserve(int size);
- inline void squeeze() { realloc(d->size, d->size); d->capacityReserved = 0; }
+ inline void squeeze()
+ {
+ realloc(d->size, d->size);
+ if (d->capacityReserved) {
+ // capacity reserved in a read only memory would be useless
+ // this checks avoid writing to such memory.
+ d->capacityReserved = 0;
+ }
+ }
- inline void detach() { if (!isDetached()) detach_helper(); }
+ inline void detach();
inline bool isDetached() const { return !d->ref.isShared(); }
inline void setSharable(bool sharable)
{
return;
if (!sharable)
detach();
- if (d != Data::sharedNull())
+
+ if (d == Data::unsharableEmpty()) {
+ if (sharable)
+ d = Data::sharedNull();
+ } else {
d->ref.setSharable(sharable);
+ }
+ Q_ASSERT(d->ref.isSharable() == sharable);
}
inline bool isSharedWith(const QVector<T> &other) const { return d == other.d; }
private:
friend class QRegion; // Optimization for QRegion::rects()
- void detach_helper();
- Data *malloc(int alloc);
- void realloc(int size, int alloc);
+ void realloc(const int size, const int alloc, QArrayData::AllocationOptions options = QArrayData::Default);
void free(Data *d);
+ void defaultConstruct(T *from, T *to);
+ void copyConstruct(T *srcFrom, T *srcTo, T *dstFrom);
+ void destruct(T *from, T *to);
- class AlignmentDummy { QVectorData header; T array[1]; };
+ class AlignmentDummy { Data header; T array[1]; };
+};
- static Q_DECL_CONSTEXPR int offsetOfTypedData()
- {
- // (non-POD)-safe offsetof(AlignmentDummy, array)
- return (sizeof(QVectorData) + (alignOfTypedData() - 1)) & ~(alignOfTypedData() - 1);
+template <typename T>
+void QVector<T>::defaultConstruct(T *from, T *to)
+{
+ if (QTypeInfo<T>::isComplex) {
+ while (from != to) {
+ new (from++) T();
+ }
+ } else {
+ ::memset(from, 0, (to - from) * sizeof(T));
}
- static Q_DECL_CONSTEXPR int alignOfTypedData()
- {
- return Q_ALIGNOF(AlignmentDummy);
+}
+
+template <typename T>
+void QVector<T>::copyConstruct(T *srcFrom, T *srcTo, T *dstFrom)
+{
+ if (QTypeInfo<T>::isComplex) {
+ while (srcFrom != srcTo)
+ new (dstFrom++) T(*srcFrom++);
+ } else {
+ ::memcpy(dstFrom, srcFrom, (srcTo - srcFrom) * sizeof(T));
}
-};
+}
+
+template <typename T>
+void QVector<T>::destruct(T *from, T *to)
+{
+ if (QTypeInfo<T>::isComplex) {
+ while (from != to) {
+ from++->~T();
+ }
+ }
+}
+
+template <typename T>
+inline QVector<T>::QVector(const QVector<T> &v)
+{
+ if (v.d->ref.ref()) {
+ d = v.d;
+ } else {
+ if (v.d->capacityReserved) {
+ d = Data::allocate(v.d->alloc);
+ d->capacityReserved = true;
+ } else {
+ d = Data::allocate(v.d->size);
+ }
+ if (d->alloc) {
+ copyConstruct(v.d->begin(), v.d->end(), d->begin());
+ d->size = v.d->size;
+ }
+ }
+}
template <typename T>
-void QVector<T>::detach_helper()
-{ realloc(d->size, int(d->alloc)); }
+void QVector<T>::detach()
+{
+ if (!isDetached()) {
+ if (d->alloc)
+ realloc(d->size, int(d->alloc));
+ else
+ d = Data::unsharableEmpty();
+ }
+ Q_ASSERT(isDetached());
+}
+
template <typename T>
void QVector<T>::reserve(int asize)
-{ if (asize > int(d->alloc)) realloc(d->size, asize); if (isDetached()) d->capacityReserved = 1; }
+{
+ if (asize > int(d->alloc))
+ realloc(d->size, asize);
+ if (isDetached())
+ d->capacityReserved = 1;
+ Q_ASSERT(capacity() >= asize);
+}
+
template <typename T>
void QVector<T>::resize(int asize)
-{ realloc(asize, (asize > int(d->alloc) || (!d->capacityReserved && asize < d->size && asize < int(d->alloc >> 1))) ?
- QVectorData::grow(offsetOfTypedData(), asize, sizeof(T))
- : int(d->alloc)); }
+{
+ int newAlloc;
+ const int oldAlloc = int(d->alloc);
+ QArrayData::AllocationOptions opt;
+
+ if (asize > oldAlloc) { // there is not enough space
+ newAlloc = asize;
+ opt = QArrayData::Grow;
+ } else if (!d->capacityReserved && asize < d->size && asize < (oldAlloc >> 1)) { // we want to shrink
+ newAlloc = asize;
+ opt = QArrayData::Grow;
+ } else {
+ newAlloc = oldAlloc;
+ }
+ realloc(asize, newAlloc, opt);
+}
template <typename T>
inline void QVector<T>::clear()
{ *this = QVector<T>(); }
}
template <typename T>
-inline typename QVector<T>::Data *QVector<T>::malloc(int aalloc)
-{
- QVectorData *vectordata = QVectorData::allocate(offsetOfTypedData() + aalloc * sizeof(T), alignOfTypedData());
- Q_CHECK_PTR(vectordata);
- return static_cast<Data *>(vectordata);
-}
-
-template <typename T>
QVector<T>::QVector(int asize)
{
- d = malloc(asize);
- d->ref.initializeOwned();
- d->size = asize;
- d->alloc = uint(d->size);
- d->capacityReserved = false;
- d->offset = offsetOfTypedData();
- if (QTypeInfo<T>::isComplex) {
- T* b = d->begin();
- T* i = d->end();
- while (i != b)
- new (--i) T;
+ if (Q_LIKELY(asize)) {
+ d = Data::allocate(asize);
+ d->size = asize;
+ defaultConstruct(d->begin(), d->end());
} else {
- memset(d->begin(), 0, asize * sizeof(T));
+ d = Data::sharedNull();
}
}
template <typename T>
QVector<T>::QVector(int asize, const T &t)
{
- d = malloc(asize);
- d->ref.initializeOwned();
- d->size = asize;
- d->alloc = uint(d->size);
- d->capacityReserved = false;
- d->offset = offsetOfTypedData();
- T* i = d->end();
- while (i != d->begin())
- new (--i) T(t);
+ if (asize) {
+ d = Data::allocate(asize);
+ d->size = asize;
+ T* i = d->end();
+ while (i != d->begin())
+ new (--i) T(t);
+ } else {
+ d = Data::sharedNull();
+ }
}
#ifdef Q_COMPILER_INITIALIZER_LISTS
QVector<T>::QVector(std::initializer_list<T> args)
{
d = malloc(int(args.size()));
- d->ref.initializeOwned();
+ // std::initializer_list<T>::iterator is guaranteed to be
+ // const T* ([support.initlist]/1), so can be memcpy'ed away from by copyConstruct
+ copyConstruct(args.begin(), args.end(), d->begin());
d->size = int(args.size());
- d->alloc = uint(d->size);
- d->capacityReserved = false;
- d->offset = offsetOfTypedData();
- if (QTypeInfo<T>::isComplex) {
- T* b = d->begin();
- T* i = d->end();
- const T* s = args.end();
- while (i != b)
- new(--i) T(*--s);
- } else {
- // std::initializer_list<T>::iterator is guaranteed to be
- // const T* ([support.initlist]/1), so can be memcpy'ed away from:
- ::memcpy(d->begin(), args.begin(), args.size() * sizeof(T));
- }
}
#endif
template <typename T>
void QVector<T>::free(Data *x)
{
- if (QTypeInfo<T>::isComplex) {
- T* b = x->begin();
- T* i = b + x->size;
- while (i-- != b)
- i->~T();
- }
- Data::free(x, alignOfTypedData());
+ destruct(x->begin(), x->end());
+ Data::deallocate(x);
}
template <typename T>
-void QVector<T>::realloc(int asize, int aalloc)
+void QVector<T>::realloc(const int asize, const int aalloc, QArrayData::AllocationOptions options)
{
- Q_ASSERT(asize <= aalloc);
- T *pOld;
- T *pNew;
+ Q_ASSERT(asize >= 0 && asize <= aalloc);
Data *x = d;
- if (QTypeInfo<T>::isComplex && asize < d->size && isDetached()) {
- // call the destructor on all objects that need to be
- // destroyed when shrinking
- pOld = d->begin() + d->size;
- pNew = d->begin() + asize;
- while (asize < d->size) {
- (--pOld)->~T();
- d->size--;
- }
- }
-
- if (aalloc != int(d->alloc) || !isDetached()) {
- // (re)allocate memory
- if (QTypeInfo<T>::isStatic) {
- x = malloc(aalloc);
- Q_CHECK_PTR(x);
- x->size = 0;
- } else if (!isDetached()) {
- x = malloc(aalloc);
- Q_CHECK_PTR(x);
- if (QTypeInfo<T>::isComplex) {
- x->size = 0;
- } else {
- ::memcpy(x, d, offsetOfTypedData() + qMin(uint(aalloc), d->alloc) * sizeof(T));
- x->size = d->size;
+ const bool isShared = d->ref.isShared();
+#ifndef QT_NO_DEBUG
+ bool moved = false;
+ int oldSize = d->size;
+#endif
+ if (aalloc != 0) {
+ if (aalloc != int(d->alloc) || isShared) {
+ QT_TRY {
+ // allocate memory
+ x = Data::allocate(aalloc, options);
+ Q_CHECK_PTR(x);
+ // aalloc is bigger then 0 so it is not [un]sharedEmpty
+ Q_ASSERT(x->ref.isSharable() || options.testFlag(QArrayData::Unsharable));
+ Q_ASSERT(!x->ref.isStatic());
+ x->size = asize;
+
+ T *srcBegin = d->begin();
+ T *srcEnd = asize > d->size ? d->end() : d->begin() + asize;
+ T *dst = x->begin();
+
+ if (QTypeInfo<T>::isStatic || (isShared && QTypeInfo<T>::isComplex)) {
+ // we can not move the data, we need to copy construct it
+ while (srcBegin != srcEnd) {
+ new (dst++) T(*srcBegin++);
+ }
+ } else {
+ ::memcpy(dst, srcBegin, (srcEnd - srcBegin) * sizeof(T));
+ dst += srcEnd - srcBegin;
+
+ // destruct unused / not moved data
+ if (asize < d->size)
+ destruct(d->begin() + asize, d->end());
+#ifndef QT_NO_DEBUG
+ moved = true;
+#endif
+ }
+
+ if (asize > d->size) {
+ // construct all new objects when growing
+ QT_TRY {
+ defaultConstruct(dst, x->end());
+ } QT_CATCH (...) {
+ // destruct already copied objects
+ destruct(x->begin(), dst);
+ QT_RETHROW;
+ }
+ }
+ } QT_CATCH (...) {
+ Data::deallocate(x);
+ QT_RETHROW;
}
+ x->capacityReserved = d->capacityReserved;
} else {
- QT_TRY {
- QVectorData *mem = QVectorData::reallocate(d, offsetOfTypedData() + aalloc * sizeof(T),
- offsetOfTypedData() + d->alloc * sizeof(T), alignOfTypedData());
- Q_CHECK_PTR(mem);
- x = d = static_cast<Data *>(mem);
- x->size = d->size;
- } QT_CATCH (const std::bad_alloc &) {
- if (aalloc > int(d->alloc)) // ignore the error in case we are just shrinking.
- QT_RETHROW;
+ Q_ASSERT(d->alloc == aalloc); // resize, without changing allocation size
+ Q_ASSERT(isDetached()); // can be done only on detached d
+ Q_ASSERT(x == d); // in this case we do not need to allocate anything
+ if (asize <= d->size) {
+ destruct(x->begin() + asize, x->end()); // from future end to current end
+ } else {
+ defaultConstruct(x->end(), x->begin() + asize); // from current end to future end
}
+ x->size = asize;
}
- x->ref.initializeOwned();
- x->alloc = uint(aalloc);
- x->capacityReserved = d->capacityReserved;
- x->offset = offsetOfTypedData();
+ } else {
+ x = Data::sharedNull();
}
-
- if (QTypeInfo<T>::isComplex) {
- QT_TRY {
- pOld = d->begin() + x->size;
- pNew = x->begin() + x->size;
- // copy objects from the old array into the new array
- const int toMove = qMin(asize, d->size);
- while (x->size < toMove) {
- new (pNew++) T(*pOld++);
- x->size++;
- }
- // construct all new objects when growing
- while (x->size < asize) {
- new (pNew++) T;
- x->size++;
+ if (d != x) {
+ if (!d->ref.deref()) {
+ Q_ASSERT(!isShared);
+ Q_ASSERT(d->size == oldSize);
+ if (QTypeInfo<T>::isStatic || !aalloc) {
+ // data was copy constructed, we need to call destructors
+ // or if !alloc we did nothing to the old 'd'.
+ Q_ASSERT(!moved);
+ free(d);
+ } else {
+ Data::deallocate(d);
}
- } QT_CATCH (...) {
- free(x);
- QT_RETHROW;
}
-
- } else if (asize > x->size) {
- // initialize newly allocated memory to 0
- memset(x->end(), 0, (asize - x->size) * sizeof(T));
- }
- x->size = asize;
-
- if (d != x) {
- if (!d->ref.deref())
- free(d);
d = x;
}
+
+ Q_ASSERT(d->data());
+ Q_ASSERT(d->size <= d->alloc);
+ Q_ASSERT(d != Data::unsharableEmpty());
+ Q_ASSERT(aalloc ? d != Data::sharedNull() : d == Data::sharedNull());
+ Q_ASSERT(d->alloc >= aalloc);
+ Q_ASSERT(d->size == asize);
}
template<typename T>
template <typename T>
void QVector<T>::append(const T &t)
{
- if (!isDetached() || d->size + 1 > int(d->alloc)) {
- const T copy(t);
- realloc(d->size, (d->size + 1 > int(d->alloc)) ?
- QVectorData::grow(offsetOfTypedData(), d->size + 1, sizeof(T))
- : int(d->alloc));
- if (QTypeInfo<T>::isComplex)
- new (d->end()) T(copy);
- else
- *d->end() = copy;
- } else {
- if (QTypeInfo<T>::isComplex)
- new (d->end()) T(t);
- else
- *d->end() = t;
+ const T copy(t);
+ const bool isTooSmall = uint(d->size + 1) > d->alloc;
+ if (!isDetached() || isTooSmall) {
+ QArrayData::AllocationOptions opt(isTooSmall ? QArrayData::Grow : QArrayData::Default);
+ realloc(d->size, isTooSmall ? d->size + 1 : d->alloc, opt);
}
+ if (QTypeInfo<T>::isComplex)
+ new (d->end()) T(copy);
+ else
+ *d->end() = copy;
++d->size;
}
if (n != 0) {
const T copy(t);
if (!isDetached() || d->size + n > int(d->alloc))
- realloc(d->size, QVectorData::grow(offsetOfTypedData(), d->size + n, sizeof(T)));
+ realloc(d->size, d->size + n, QArrayData::Grow);
if (QTypeInfo<T>::isStatic) {
T *b = d->end();
T *i = d->end() + n;
template <typename T>
typename QVector<T>::iterator QVector<T>::erase(iterator abegin, iterator aend)
{
- int f = int(abegin - d->begin());
- int l = int(aend - d->begin());
- int n = l - f;
- detach();
- if (QTypeInfo<T>::isComplex) {
- qCopy(d->begin()+l, d->end(), d->begin()+f);
- T *i = d->end();
- T* b = d->end()-n;
- while (i != b) {
- --i;
- i->~T();
+ abegin = qMax(abegin, d->begin());
+ aend = qMin(aend, d->end());
+
+ Q_ASSERT(abegin <= aend);
+
+ const int itemsToErase = aend - abegin;
+ const int itemsUntouched = abegin - d->begin();
+
+ // FIXME we could do a proper realloc, which copy constructs only needed data.
+ // FIXME we ara about to delete data maybe it is good time to shrink?
+ if (d->alloc) {
+ detach();
+ if (QTypeInfo<T>::isStatic) {
+ iterator moveBegin = abegin + itemsToErase;
+ iterator moveEnd = d->end();
+ while (moveBegin != moveEnd) {
+ if (QTypeInfo<T>::isComplex)
+ abegin->~T();
+ new (abegin++) T(*moveBegin++);
+ }
+ if (abegin < d->end()) {
+ // destroy rest of instances
+ destruct(abegin, d->end());
+ }
+ } else {
+ destruct(abegin, aend);
+ memmove(abegin, aend, (d->size - itemsToErase - itemsUntouched) * sizeof(T));
}
- } else {
- memmove(d->begin() + f, d->begin() + l, (d->size-l)*sizeof(T));
+ d->size -= itemsToErase;
}
- d->size -= n;
- return d->begin() + f;
+ return d->begin() + itemsUntouched;
}
template <typename T>
int newSize = d->size + l.d->size;
realloc(d->size, newSize);
- T *w = d->begin() + newSize;
- T *i = l.d->end();
- T *b = l.d->begin();
- while (i != b) {
- if (QTypeInfo<T>::isComplex)
- new (--w) T(*--i);
- else
- *--w = *--i;
+ if (d->alloc) {
+ T *w = d->begin() + newSize;
+ T *i = l.d->end();
+ T *b = l.d->begin();
+ while (i != b) {
+ if (QTypeInfo<T>::isComplex)
+ new (--w) T(*--i);
+ else
+ *--w = *--i;
+ }
+ d->size = newSize;
}
- d->size = newSize;
return *this;
}
#include <QtTest/QtTest>
#include <qvector.h>
+struct Movable {
+ Movable(char input = 'j')
+ : i(input)
+ , state(Constructed)
+ {
+ ++counter;
+ }
+ Movable(const Movable &other)
+ : i(other.i)
+ , state(Constructed)
+ {
+ check(other.state, Constructed);
+ ++counter;
+ }
+
+ ~Movable()
+ {
+ check(state, Constructed);
+ i = 0;
+ --counter;
+ state = Destructed;
+ }
+
+ bool operator ==(const Movable &other) const
+ {
+ check(state, Constructed);
+ check(other.state, Constructed);
+ return i == other.i;
+ }
+
+ Movable &operator=(const Movable &other)
+ {
+ check(state, Constructed);
+ check(other.state, Constructed);
+ i = other.i;
+ return *this;
+ }
+ char i;
+ static int counter;
+private:
+ enum State { Constructed = 106, Destructed = 110 };
+ State state;
+
+ static void check(const State state1, const State state2)
+ {
+ QCOMPARE(state1, state2);
+ }
+};
+
+int Movable::counter = 0;
+QT_BEGIN_NAMESPACE
+Q_DECLARE_TYPEINFO(Movable, Q_MOVABLE_TYPE);
+QT_END_NAMESPACE
+Q_DECLARE_METATYPE(Movable);
+
+struct Custom {
+ Custom(char input = 'j')
+ : i(input)
+ , that(this)
+ , state(Constructed)
+ {
+ ++counter;
+ }
+ Custom(const Custom &other)
+ : that(this)
+ , state(Constructed)
+ {
+ check(&other);
+ ++counter;
+ this->i = other.i;
+ }
+ ~Custom()
+ {
+ check(this);
+ i = 0;
+ --counter;
+ state = Destructed;
+ }
+
+ bool operator ==(const Custom &other) const
+ {
+ check(&other);
+ check(this);
+ return i == other.i;
+ }
+
+ Custom &operator=(const Custom &other)
+ {
+ check(&other);
+ check(this);
+ i = other.i;
+ return *this;
+ }
+ static int counter;
+
+ char i; // used to identify orgin of an instance
+private:
+ Custom *that; // used to check if an instance was moved
+
+ enum State { Constructed = 106, Destructed = 110 };
+ State state;
+
+ static void check(const Custom *c)
+ {
+ // check if c object has been moved
+ QCOMPARE(c, c->that);
+ QCOMPARE(c->state, Constructed);
+ }
+};
+int Custom::counter = 0;
+
+Q_DECLARE_METATYPE(Custom);
+
+// tests depends on the fact that:
+Q_STATIC_ASSERT(!QTypeInfo<int>::isStatic);
+Q_STATIC_ASSERT(!QTypeInfo<int>::isComplex);
+Q_STATIC_ASSERT(!QTypeInfo<Movable>::isStatic);
+Q_STATIC_ASSERT(QTypeInfo<Movable>::isComplex);
+Q_STATIC_ASSERT(QTypeInfo<Custom>::isStatic);
+Q_STATIC_ASSERT(QTypeInfo<Custom>::isComplex);
+
+
class tst_QVector : public QObject
{
Q_OBJECT
private slots:
- void constructors() const;
- void append() const;
+ void constructors_empty() const;
+ void constructors_emptyReserveZero() const;
+ void constructors_emptyReserve() const;
+ void constructors_reserveAndInitialize() const;
+ void copyConstructorInt() const;
+ void copyConstructorMovable() const;
+ void copyConstructorCustom() const;
+ void addInt() const;
+ void addMovable() const;
+ void addCustom() const;
+ void appendInt() const;
+ void appendMovable() const;
+ void appendCustom() const;
void at() const;
- void capacity() const;
- void clear() const;
+ void capacityInt() const;
+ void capacityMovable() const;
+ void capacityCustom() const;
+ void clearInt() const;
+ void clearMovable() const;
+ void clearCustom() const;
void constData() const;
void contains() const;
- void count() const;
+ void countInt() const;
+ void countMovable() const;
+ void countCustom() const;
void data() const;
- void empty() const;
+ void emptyInt() const;
+ void emptyMovable() const;
+ void emptyCustom() const;
void endsWith() const;
- void fill() const;
+ void eraseEmptyInt() const;
+ void eraseEmptyMovable() const;
+ void eraseEmptyCustom() const;
+ void eraseEmptyReservedInt() const;
+ void eraseEmptyReservedMovable() const;
+ void eraseEmptyReservedCustom() const;
+ void eraseInt() const;
+ void eraseMovable() const;
+ void eraseCustom() const;
+ void eraseReservedInt() const;
+ void eraseReservedMovable() const;
+ void eraseReservedCustom() const;
+ void fillInt() const;
+ void fillMovable() const;
+ void fillCustom() const;
void first() const;
- void fromList() const;
+ void fromListInt() const;
+ void fromListMovable() const;
+ void fromListCustom() const;
void fromStdVector() const;
void indexOf() const;
void insert() const;
void last() const;
void lastIndexOf() const;
void mid() const;
- void prepend() const;
- void remove() const;
- void size() const;
+ void prependInt() const;
+ void prependMovable() const;
+ void prependCustom() const;
+ void removeInt() const;
+ void removeMovable() const;
+ void removeCustom() const;
+ void resizePOD_data() const;
+ void resizePOD() const;
+ void resizeComplexMovable_data() const;
+ void resizeComplexMovable() const;
+ void resizeComplex_data() const;
+ void resizeComplex() const;
+ void resizeCtorAndDtor() const;
+ void sizeInt() const;
+ void sizeMovable() const;
+ void sizeCustom() const;
void startsWith() const;
- void swap() const;
+ void swapInt() const;
+ void swapMovable() const;
+ void swapCustom() const;
void toList() const;
void toStdVector() const;
void value() const;
void reserve();
void reallocAfterCopy_data();
void reallocAfterCopy();
- void initializeList();
+ void initializeListInt();
+ void initializeListMovable();
+ void initializeListCustom();
void const_shared_null();
- void setSharable_data();
- void setSharable();
+ void setSharableInt_data();
+ void setSharableInt();
+ void setSharableMovable_data();
+ void setSharableMovable();
+ void setSharableCustom_data();
+ void setSharableCustom();
+
+ void detachInt() const;
+ void detachMovable() const;
+ void detachCustom() const;
+private:
+ template<typename T> void copyConstructor() const;
+ template<typename T> void add() const;
+ template<typename T> void append() const;
+ template<typename T> void capacity() const;
+ template<typename T> void clear() const;
+ template<typename T> void count() const;
+ template<typename T> void empty() const;
+ template<typename T> void eraseEmpty() const;
+ template<typename T> void eraseEmptyReserved() const;
+ template<typename T> void erase() const;
+ template<typename T> void eraseReserved() const;
+ template<typename T> void fill() const;
+ template<typename T> void fromList() const;
+ template<typename T> void prepend() const;
+ template<typename T> void remove() const;
+ template<typename T> void size() const;
+ template<typename T> void swap() const;
+ template<typename T> void initializeList();
+ template<typename T> void setSharable_data() const;
+ template<typename T> void setSharable() const;
+ template<typename T> void detach() const;
};
-void tst_QVector::constructors() const
+template<typename T> struct SimpleValue
{
- // pre-reserve capacity
+ static T at(int index)
{
- QVector<int> myvec(5);
-
- QVERIFY(myvec.capacity() == 5);
+ return Values[index % MaxIndex];
}
+ static const uint MaxIndex = 6;
+ static const T Values[MaxIndex];
+};
+template<>
+const int SimpleValue<int>::Values[] = { 110, 105, 101, 114, 111, 98 };
+template<>
+const Movable SimpleValue<Movable>::Values[] = { 110, 105, 101, 114, 111, 98 };
+template<>
+const Custom SimpleValue<Custom>::Values[] = { 110, 105, 101, 114, 111, 98 };
+
+void tst_QVector::constructors_empty() const
+{
+ QVector<int> emptyInt;
+ QVector<Movable> emptyMovable;
+ QVector<Custom> emptyCustom;
+}
+
+void tst_QVector::constructors_emptyReserveZero() const
+{
+ QVector<int> emptyInt(0);
+ QVector<Movable> emptyMovable(0);
+ QVector<Custom> emptyCustom(0);
+}
+
+void tst_QVector::constructors_emptyReserve() const
+{
+ // pre-reserve capacity
+ QVector<int> myInt(5);
+ QVERIFY(myInt.capacity() == 5);
+ QVector<Movable> myMovable(5);
+ QVERIFY(myMovable.capacity() == 5);
+ QVector<Custom> myCustom(4);
+ QVERIFY(myCustom.capacity() == 4);
+}
+
+void tst_QVector::constructors_reserveAndInitialize() const
+{
// default-initialise items
+
+ QVector<int> myInt(5, 42);
+ QVERIFY(myInt.capacity() == 5);
+ foreach (int meaningoflife, myInt) {
+ QCOMPARE(meaningoflife, 42);
+ }
+
+ QVector<QString> myString(5, QString::fromLatin1("c++"));
+ QVERIFY(myString.capacity() == 5);
+ // make sure all items are initialised ok
+ foreach (QString meaningoflife, myString) {
+ QCOMPARE(meaningoflife, QString::fromLatin1("c++"));
+ }
+
+ QVector<Custom> myCustom(5, Custom('n'));
+ QVERIFY(myCustom.capacity() == 5);
+ // make sure all items are initialised ok
+ foreach (Custom meaningoflife, myCustom) {
+ QCOMPARE(meaningoflife.i, 'n');
+ }
+}
+
+template<typename T>
+void tst_QVector::copyConstructor() const
+{
+ T value1(SimpleValue<T>::at(0));
+ T value2(SimpleValue<T>::at(1));
+ T value3(SimpleValue<T>::at(2));
+ T value4(SimpleValue<T>::at(3));
{
- QVector<int> myvec(5, 42);
+ QVector<T> v1;
+ QVector<T> v2(v1);
+ QCOMPARE(v1, v2);
+ }
+ {
+ QVector<T> v1;
+ v1.setSharable(false);
+ QVector<T> v2(v1);
+ QVERIFY(!v1.isSharedWith(v2));
+ QCOMPARE(v1, v2);
+ }
+ {
+ QVector<T> v1;
+ v1 << value1 << value2 << value3 << value4;
+ QVector<T> v2(v1);
+ QCOMPARE(v1, v2);
+ }
+ {
+ QVector<T> v1;
+ v1 << value1 << value2 << value3 << value4;
+ v1.setSharable(false);
+ QVector<T> v2(v1);
+ QVERIFY(!v1.isSharedWith(v2));
+ QCOMPARE(v1, v2);
+ }
+}
- QVERIFY(myvec.capacity() == 5);
+void tst_QVector::copyConstructorInt() const
+{
+ copyConstructor<int>();
+}
- // make sure all items are initialised ok
- foreach (int meaningoflife, myvec) {
- QCOMPARE(meaningoflife, 42);
- }
+void tst_QVector::copyConstructorMovable() const
+{
+ const int instancesCount = Movable::counter;
+ copyConstructor<Movable>();
+ QCOMPARE(instancesCount, Movable::counter);
+}
+
+void tst_QVector::copyConstructorCustom() const
+{
+ const int instancesCount = Custom::counter;
+ copyConstructor<Custom>();
+ QCOMPARE(instancesCount, Custom::counter);
+}
+
+template<typename T>
+void tst_QVector::add() const
+{
+ {
+ QVector<T> empty1;
+ QVector<T> empty2;
+ QVERIFY((empty1 + empty2).isEmpty());
+ empty1 += empty2;
+ QVERIFY(empty1.isEmpty());
+ QVERIFY(empty2.isEmpty());
}
+ {
+ QVector<T> v(12);
+ QVector<T> empty;
+ QCOMPARE((v + empty), v);
+ v += empty;
+ QVERIFY(!v.isEmpty());
+ QCOMPARE(v.size(), 12);
+ QVERIFY(empty.isEmpty());
+ }
+ {
+ QVector<T> v1(12);
+ QVector<T> v2;
+ v2 += v1;
+ QVERIFY(!v1.isEmpty());
+ QCOMPARE(v1.size(), 12);
+ QVERIFY(!v2.isEmpty());
+ QCOMPARE(v2.size(), 12);
+ }
+}
+
+void tst_QVector::addInt() const
+{
+ add<int>();
+}
+
+void tst_QVector::addMovable() const
+{
+ const int instancesCount = Movable::counter;
+ add<Movable>();
+ QCOMPARE(instancesCount, Movable::counter);
}
+void tst_QVector::addCustom() const
+{
+ const int instancesCount = Custom::counter;
+ add<Custom>();
+ QCOMPARE(instancesCount, Custom::counter);
+}
+
+template<typename T>
void tst_QVector::append() const
{
- QVector<int> myvec;
- myvec.append(42);
- myvec.append(43);
- myvec.append(44);
+ {
+ QVector<T> myvec;
+ myvec.append(SimpleValue<T>::at(0));
+ QVERIFY(myvec.size() == 1);
+ myvec.append(SimpleValue<T>::at(1));
+ QVERIFY(myvec.size() == 2);
+ myvec.append(SimpleValue<T>::at(2));
+ QVERIFY(myvec.size() == 3);
- QVERIFY(myvec.size() == 3);
- QCOMPARE(myvec, QVector<int>() << 42 << 43 << 44);
+ QCOMPARE(myvec, QVector<T>() << SimpleValue<T>::at(0)
+ << SimpleValue<T>::at(1)
+ << SimpleValue<T>::at(2));
+ }
+ {
+ QVector<T> v(2);
+ v.append(SimpleValue<T>::at(0));
+ QVERIFY(v.size() == 3);
+ QCOMPARE(v.at(v.size() - 1), SimpleValue<T>::at(0));
+ }
+ {
+ QVector<T> v(2);
+ v.reserve(12);
+ v.append(SimpleValue<T>::at(0));
+ QVERIFY(v.size() == 3);
+ QCOMPARE(v.at(v.size() - 1), SimpleValue<T>::at(0));
+ }
+ {
+ QVector<T> v(2);
+ v.reserve(12);
+ v.setSharable(false);
+ v.append(SimpleValue<T>::at(0));
+ QVERIFY(v.size() == 3);
+ QCOMPARE(v.last(), SimpleValue<T>::at(0));
+ }
+}
+
+void tst_QVector::appendInt() const
+{
+ append<int>();
+}
+
+void tst_QVector::appendMovable() const
+{
+ const int instancesCount = Movable::counter;
+ append<Movable>();
+ QCOMPARE(instancesCount, Movable::counter);
+}
+
+void tst_QVector::appendCustom() const
+{
+ const int instancesCount = Custom::counter;
+ append<Custom>();
+ QCOMPARE(instancesCount, Custom::counter);
}
void tst_QVector::at() const
QCOMPARE(myvec.at(2), QLatin1String("hello"));
}
+template<typename T>
void tst_QVector::capacity() const
{
- QVector<QString> myvec;
+ QVector<T> 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";
+ myvec << SimpleValue<T>::at(0) << SimpleValue<T>::at(1) << SimpleValue<T>::at(2);
QVERIFY(myvec.capacity() >= 3);
// make sure it grows ok
- myvec << "aaa" << "bbb" << "ccc";
+ myvec << SimpleValue<T>::at(0) << SimpleValue<T>::at(1) << SimpleValue<T>::at(2);
QVERIFY(myvec.capacity() >= 6);
// let's try squeeze a bit
QVERIFY(myvec.capacity() == 0);
}
+void tst_QVector::capacityInt() const
+{
+ capacity<int>();
+}
+
+void tst_QVector::capacityMovable() const
+{
+ const int instancesCount = Movable::counter;
+ capacity<Movable>();
+ QCOMPARE(instancesCount, Movable::counter);
+}
+
+void tst_QVector::capacityCustom() const
+{
+ const int instancesCount = Custom::counter;
+ capacity<Custom>();
+ QCOMPARE(instancesCount, Custom::counter);
+}
+
+template<typename T>
void tst_QVector::clear() const
{
- QVector<QString> myvec;
- myvec << "aaa" << "bbb" << "ccc";
+ QVector<T> myvec;
+ myvec << SimpleValue<T>::at(0) << SimpleValue<T>::at(1) << SimpleValue<T>::at(2);
QVERIFY(myvec.size() == 3);
myvec.clear();
QVERIFY(myvec.capacity() == 0);
}
+void tst_QVector::clearInt() const
+{
+ clear<int>();
+}
+
+void tst_QVector::clearMovable() const
+{
+ const int instancesCount = Movable::counter;
+ clear<Movable>();
+ QCOMPARE(instancesCount, Movable::counter);
+}
+
+void tst_QVector::clearCustom() const
+{
+ const int instancesCount = Custom::counter;
+ clear<Custom>();
+ QCOMPARE(instancesCount, Custom::counter);
+}
+
void tst_QVector::constData() const
{
int arr[] = { 42, 43, 44 };
QVERIFY(myvec.contains(QLatin1String("I don't exist")));
}
+template<typename T>
void tst_QVector::count() const
{
// total size
{
// zero size
- QVector<int> myvec;
+ QVector<T> myvec;
QVERIFY(myvec.count() == 0);
// grow
- myvec.append(42);
+ myvec.append(SimpleValue<T>::at(0));
QVERIFY(myvec.count() == 1);
- myvec.append(42);
+ myvec.append(SimpleValue<T>::at(1));
QVERIFY(myvec.count() == 2);
// shrink
// count of items
{
- QVector<QString> myvec;
- myvec << "aaa" << "bbb" << "ccc";
+ QVector<T> myvec;
+ myvec << SimpleValue<T>::at(0) << SimpleValue<T>::at(1) << SimpleValue<T>::at(2);
// initial tests
- QVERIFY(myvec.count(QLatin1String("aaa")) == 1);
- QVERIFY(myvec.count(QLatin1String("pirates")) == 0);
+ QVERIFY(myvec.count(SimpleValue<T>::at(0)) == 1);
+ QVERIFY(myvec.count(SimpleValue<T>::at(3)) == 0);
// grow
- myvec.append(QLatin1String("aaa"));
- QVERIFY(myvec.count(QLatin1String("aaa")) == 2);
+ myvec.append(SimpleValue<T>::at(0));
+ QVERIFY(myvec.count(SimpleValue<T>::at(0)) == 2);
// shrink
myvec.remove(0);
- QVERIFY(myvec.count(QLatin1String("aaa")) == 1);
+ QVERIFY(myvec.count(SimpleValue<T>::at(0)) == 1);
}
}
+void tst_QVector::countInt() const
+{
+ count<int>();
+}
+
+void tst_QVector::countMovable() const
+{
+ const int instancesCount = Movable::counter;
+ count<Movable>();
+ QCOMPARE(instancesCount, Movable::counter);
+}
+
+void tst_QVector::countCustom() const
+{
+ const int instancesCount = Custom::counter;
+ count<Custom>();
+ QCOMPARE(instancesCount, Custom::counter);
+}
+
void tst_QVector::data() const
{
QVector<int> myvec;
QVERIFY(memcmp(myvec.data(), reinterpret_cast<int *>(&arr), sizeof(int) * 3) == 0);
}
+template<typename T>
void tst_QVector::empty() const
{
- QVector<int> myvec;
+ QVector<T> myvec;
// starts empty
QVERIFY(myvec.empty());
// not empty
- myvec.append(1);
+ myvec.append(SimpleValue<T>::at(2));
QVERIFY(!myvec.empty());
// empty again
QVERIFY(myvec.empty());
}
+void tst_QVector::emptyInt() const
+{
+ empty<int>();
+}
+
+void tst_QVector::emptyMovable() const
+{
+ const int instancesCount = Movable::counter;
+ empty<Movable>();
+ QCOMPARE(instancesCount, Movable::counter);
+}
+
+void tst_QVector::emptyCustom() const
+{
+ const int instancesCount = Custom::counter;
+ empty<Custom>();
+ QCOMPARE(instancesCount, Custom::counter);
+}
+
void tst_QVector::endsWith() const
{
QVector<int> myvec;
QVERIFY(myvec.endsWith(1));
}
+template<typename T>
+void tst_QVector::eraseEmpty() const
+{
+ {
+ QVector<T> v;
+ v.erase(v.begin());
+ QCOMPARE(v.size(), 0);
+ v.erase(v.begin(), v.end());
+ QCOMPARE(v.size(), 0);
+ }
+ {
+ QVector<T> v;
+ v.setSharable(false);
+ v.erase(v.begin());
+ QCOMPARE(v.size(), 0);
+ v.erase(v.begin(), v.end());
+ QCOMPARE(v.size(), 0);
+ }
+}
+
+void tst_QVector::eraseEmptyInt() const
+{
+ eraseEmpty<int>();
+}
+
+void tst_QVector::eraseEmptyMovable() const
+{
+ const int instancesCount = Movable::counter;
+ eraseEmpty<Movable>();
+ QCOMPARE(instancesCount, Movable::counter);
+}
+
+void tst_QVector::eraseEmptyCustom() const
+{
+ const int instancesCount = Custom::counter;
+ eraseEmpty<Custom>();
+ QCOMPARE(instancesCount, Custom::counter);
+}
+
+template<typename T>
+void tst_QVector::eraseEmptyReserved() const
+{
+ {
+ QVector<T> v;
+ v.reserve(10);
+ v.erase(v.begin());
+ QCOMPARE(v.size(), 0);
+ v.erase(v.begin(), v.end());
+ QCOMPARE(v.size(), 0);
+ }
+ {
+ QVector<T> v;
+ v.reserve(10);
+ v.setSharable(false);
+ v.erase(v.begin());
+ QCOMPARE(v.size(), 0);
+ v.erase(v.begin(), v.end());
+ QCOMPARE(v.size(), 0);
+ }
+}
+
+void tst_QVector::eraseEmptyReservedInt() const
+{
+ eraseEmptyReserved<int>();
+}
+
+void tst_QVector::eraseEmptyReservedMovable() const
+{
+ const int instancesCount = Movable::counter;
+ eraseEmptyReserved<Movable>();
+ QCOMPARE(instancesCount, Movable::counter);
+}
+
+void tst_QVector::eraseEmptyReservedCustom() const
+{
+ const int instancesCount = Custom::counter;
+ eraseEmptyReserved<Custom>();
+ QCOMPARE(instancesCount, Custom::counter);
+}
+
+template<typename T>
+void tst_QVector::erase() const
+{
+ {
+ QVector<T> v(12);
+ v.erase(v.begin());
+ QCOMPARE(v.size(), 11);
+ v.erase(v.begin(), v.end());
+ QCOMPARE(v.size(), 0);
+ }
+ {
+ QVector<T> v(12);
+ v.erase(v.begin() + 1);
+ QCOMPARE(v.size(), 11);
+ v.erase(v.begin() + 1, v.end());
+ QCOMPARE(v.size(), 1);
+ }
+ {
+ QVector<T> v(12);
+ v.erase(v.begin(), v.end() - 1);
+ QCOMPARE(v.size(), 1);
+ }
+ {
+ QVector<T> v(12);
+ v.erase(v.begin() + 5);
+ QCOMPARE(v.size(), 11);
+ v.erase(v.begin() + 1, v.end() - 1);
+ QCOMPARE(v.size(), 2);
+ }
+ {
+ QVector<T> v(10);
+ v.setSharable(false);
+ v.erase(v.begin() + 3);
+ QCOMPARE(v.size(), 9);
+ v.erase(v.begin(), v.end() - 1);
+ QCOMPARE(v.size(), 1);
+ }
+}
+
+void tst_QVector::eraseInt() const
+{
+ erase<int>();
+}
+
+void tst_QVector::eraseMovable() const
+{
+ const int instancesCount = Movable::counter;
+ erase<Movable>();
+ QCOMPARE(instancesCount, Movable::counter);
+}
+
+void tst_QVector::eraseCustom() const
+{
+ const int instancesCount = Custom::counter;
+ erase<Custom>();
+ QCOMPARE(instancesCount, Custom::counter);
+}
+
+template<typename T> void tst_QVector::eraseReserved() const
+{
+ {
+ QVector<T> v(12);
+ v.reserve(16);
+ v.erase(v.begin());
+ QCOMPARE(v.size(), 11);
+ v.erase(v.begin(), v.end());
+ QCOMPARE(v.size(), 0);
+ }
+ {
+ QVector<T> v(12);
+ v.reserve(16);
+ v.erase(v.begin() + 1);
+ QCOMPARE(v.size(), 11);
+ v.erase(v.begin() + 1, v.end());
+ QCOMPARE(v.size(), 1);
+ }
+ {
+ QVector<T> v(12);
+ v.reserve(16);
+ v.erase(v.begin(), v.end() - 1);
+ QCOMPARE(v.size(), 1);
+ }
+ {
+ QVector<T> v(12);
+ v.reserve(16);
+ v.erase(v.begin() + 5);
+ QCOMPARE(v.size(), 11);
+ v.erase(v.begin() + 1, v.end() - 1);
+ QCOMPARE(v.size(), 2);
+ }
+ {
+ QVector<T> v(10);
+ v.reserve(16);
+ v.setSharable(false);
+ v.erase(v.begin() + 3);
+ QCOMPARE(v.size(), 9);
+ v.erase(v.begin(), v.end() - 1);
+ QCOMPARE(v.size(), 1);
+ }
+}
+
+void tst_QVector::eraseReservedInt() const
+{
+ eraseReserved<int>();
+}
+
+void tst_QVector::eraseReservedMovable() const
+{
+ const int instancesCount = Movable::counter;
+ eraseReserved<Movable>();
+ QCOMPARE(instancesCount, Movable::counter);
+}
+
+void tst_QVector::eraseReservedCustom() const
+{
+ const int instancesCount = Custom::counter;
+ eraseReserved<Custom>();
+ QCOMPARE(instancesCount, Custom::counter);
+}
+
+template<typename T>
void tst_QVector::fill() const
{
- QVector<int> myvec;
+ QVector<T> myvec;
// resize
myvec.resize(5);
- myvec.fill(69);
- QCOMPARE(myvec, QVector<int>() << 69 << 69 << 69 << 69 << 69);
+ myvec.fill(SimpleValue<T>::at(1));
+ QCOMPARE(myvec, QVector<T>() << SimpleValue<T>::at(1) << SimpleValue<T>::at(1)
+ << SimpleValue<T>::at(1) << SimpleValue<T>::at(1)
+ << SimpleValue<T>::at(1));
// 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);
+ myvec.fill(SimpleValue<T>::at(2), 10);
+ QCOMPARE(myvec, QVector<T>() << SimpleValue<T>::at(2) << SimpleValue<T>::at(2)
+ << SimpleValue<T>::at(2) << SimpleValue<T>::at(2)
+ << SimpleValue<T>::at(2) << SimpleValue<T>::at(2)
+ << SimpleValue<T>::at(2) << SimpleValue<T>::at(2)
+ << SimpleValue<T>::at(2) << SimpleValue<T>::at(2));
+}
+
+void tst_QVector::fillInt() const
+{
+ fill<int>();
+}
+
+void tst_QVector::fillMovable() const
+{
+ const int instancesCount = Movable::counter;
+ fill<Movable>();
+ QCOMPARE(instancesCount, Movable::counter);
+}
+
+void tst_QVector::fillCustom() const
+{
+ const int instancesCount = Custom::counter;
+ fill<Custom>();
+ QCOMPARE(instancesCount, Custom::counter);
}
void tst_QVector::first() const
QCOMPARE(myvec.first(), 23);
}
+template<typename T>
void tst_QVector::fromList() const
{
- QList<QString> list;
- list << "aaa" << "bbb" << "ninjas" << "pirates";
+ QList<T> list;
+ list << SimpleValue<T>::at(0) << SimpleValue<T>::at(1) << SimpleValue<T>::at(2) << SimpleValue<T>::at(3);
- QVector<QString> myvec;
- myvec = QVector<QString>::fromList(list);
+ QVector<T> myvec;
+ myvec = QVector<T>::fromList(list);
// test it worked ok
- QCOMPARE(myvec, QVector<QString>() << "aaa" << "bbb" << "ninjas" << "pirates");
- QCOMPARE(list, QList<QString>() << "aaa" << "bbb" << "ninjas" << "pirates");
+ QCOMPARE(myvec, QVector<T>() << SimpleValue<T>::at(0) << SimpleValue<T>::at(1) << SimpleValue<T>::at(2) << SimpleValue<T>::at(3));
+ QCOMPARE(list, QList<T>() << SimpleValue<T>::at(0) << SimpleValue<T>::at(1) << SimpleValue<T>::at(2) << SimpleValue<T>::at(3));
+}
+
+void tst_QVector::fromListInt() const
+{
+ fromList<int>();
+}
+
+void tst_QVector::fromListMovable() const
+{
+ const int instancesCount = Movable::counter;
+ fromList<Movable>();
+ QCOMPARE(instancesCount, Movable::counter);
+}
+
+void tst_QVector::fromListCustom() const
+{
+ const int instancesCount = Custom::counter;
+ fromList<Custom>();
+ QCOMPARE(instancesCount, Custom::counter);
}
void tst_QVector::fromStdVector() const
QCOMPARE(list.mid(4), QVector<QString>() << "buck" << "hello" << "kitty");
}
+template<typename T>
void tst_QVector::prepend() const
{
- QVector<QString> myvec;
- myvec << "A" << "B" << "C";
+ QVector<T> myvec;
+ T val1 = SimpleValue<T>::at(0);
+ T val2 = SimpleValue<T>::at(1);
+ T val3 = SimpleValue<T>::at(2);
+ T val4 = SimpleValue<T>::at(3);
+ T val5 = SimpleValue<T>::at(4);
+ myvec << val1 << val2 << val3;
// starts ok
QVERIFY(myvec.size() == 3);
- QCOMPARE(myvec.at(0), QLatin1String("A"));
+ QCOMPARE(myvec.at(0), val1);
// add something
- myvec.prepend(QLatin1String("X"));
- QCOMPARE(myvec.at(0), QLatin1String("X"));
- QCOMPARE(myvec.at(1), QLatin1String("A"));
+ myvec.prepend(val4);
+ QCOMPARE(myvec.at(0), val4);
+ QCOMPARE(myvec.at(1), val1);
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"));
+ myvec.prepend(val5);
+ QCOMPARE(myvec.at(0), val5);
+ QCOMPARE(myvec.at(1), val4);
+ QCOMPARE(myvec.at(2), val1);
QVERIFY(myvec.size() == 5);
- // clear and append to an empty vector
+ // clear and prepend to an empty vector
myvec.clear();
QVERIFY(myvec.size() == 0);
- myvec.prepend(QLatin1String("ninjas"));
+ myvec.prepend(val5);
QVERIFY(myvec.size() == 1);
- QCOMPARE(myvec.at(0), QLatin1String("ninjas"));
+ QCOMPARE(myvec.at(0), val5);
}
-void tst_QVector::remove() const
+void tst_QVector::prependInt() const
{
- QVector<QString> myvec;
- myvec << "A" << "B" << "C";
+ prepend<int>();
+}
+
+void tst_QVector::prependMovable() const
+{
+ const int instancesCount = Movable::counter;
+ prepend<Movable>();
+ QCOMPARE(instancesCount, Movable::counter);
+}
+
+void tst_QVector::prependCustom() const
+{
+ const int instancesCount = Custom::counter;
+ prepend<Custom>();
+ QCOMPARE(instancesCount, Custom::counter);
+}
+template<typename T>
+void tst_QVector::remove() const
+{
+ QVector<T> myvec;
+ T val1 = SimpleValue<T>::at(1);
+ T val2 = SimpleValue<T>::at(2);
+ T val3 = SimpleValue<T>::at(3);
+ myvec << val1 << val2 << val3;
// remove middle
myvec.remove(1);
- QCOMPARE(myvec, QVector<QString>() << "A" << "C");
+ QCOMPARE(myvec, QVector<T>() << val1 << val3);
// remove rest
myvec.remove(0, 2);
- QCOMPARE(myvec, QVector<QString>());
+ QCOMPARE(myvec, QVector<T>());
}
-// ::reserve() is really hard to think of tests for, so not doing it.
-// ::resize() is tested in ::capacity().
+void tst_QVector::removeInt() const
+{
+ remove<int>();
+}
-void tst_QVector::size() const
+void tst_QVector::removeMovable() const
{
- // total size
+ const int instancesCount = Movable::counter;
+ remove<Movable>();
+ QCOMPARE(instancesCount, Movable::counter);
+}
+
+void tst_QVector::removeCustom() const
+{
+ const int instancesCount = Custom::counter;
+ remove<Custom>();
+ QCOMPARE(instancesCount, Custom::counter);
+}
+
+void tst_QVector::resizePOD_data() const
+{
+ QTest::addColumn<QVector<int> >("vector");
+ QTest::addColumn<int>("size");
+
+ QVERIFY(!QTypeInfo<int>::isComplex);
+ QVERIFY(!QTypeInfo<int>::isStatic);
+
+ QVector<int> null;
+ QVector<int> empty(0, 5);
+ QVector<int> emptyReserved;
+ QVector<int> nonEmpty;
+ QVector<int> nonEmptyReserved;
+
+ emptyReserved.reserve(10);
+ nonEmptyReserved.reserve(15);
+ nonEmpty << 0 << 1 << 2 << 3 << 4;
+ nonEmptyReserved << 0 << 1 << 2 << 3 << 4 << 5 << 6;
+ QVERIFY(emptyReserved.capacity() >= 10);
+ QVERIFY(nonEmptyReserved.capacity() >= 15);
+
+ QVector<int> nullNotShared;
+ QVector<int> emptyNotShared(0, 5);
+ QVector<int> emptyReservedNotShared;
+ QVector<int> nonEmptyNotShared;
+ QVector<int> nonEmptyReservedNotShared;
+
+ emptyReservedNotShared.reserve(10);
+ nonEmptyReservedNotShared.reserve(15);
+ nonEmptyNotShared << 0 << 1 << 2 << 3 << 4;
+ nonEmptyReservedNotShared << 0 << 1 << 2 << 3 << 4 << 5 << 6;
+ QVERIFY(emptyReservedNotShared.capacity() >= 10);
+ QVERIFY(nonEmptyReservedNotShared.capacity() >= 15);
+
+ emptyNotShared.setSharable(false);
+ emptyReservedNotShared.setSharable(false);
+ nonEmptyNotShared.setSharable(false);
+ nonEmptyReservedNotShared.setSharable(false);
+
+ QTest::newRow("null") << null << 10;
+ QTest::newRow("empty") << empty << 10;
+ QTest::newRow("emptyReserved") << emptyReserved << 10;
+ QTest::newRow("nonEmpty") << nonEmpty << 10;
+ QTest::newRow("nonEmptyReserved") << nonEmptyReserved << 10;
+ QTest::newRow("nullNotShared") << nullNotShared << 10;
+ QTest::newRow("emptyNotShared") << emptyNotShared << 10;
+ QTest::newRow("emptyReservedNotShared") << emptyReservedNotShared << 10;
+ QTest::newRow("nonEmptyNotShared") << nonEmptyNotShared << 10;
+ QTest::newRow("nonEmptyReservedNotShared") << nonEmptyReservedNotShared << 10;
+}
+
+void tst_QVector::resizePOD() const
+{
+ QFETCH(QVector<int>, vector);
+ QFETCH(int, size);
+
+ const int oldSize = vector.size();
+
+ vector.resize(size);
+ QCOMPARE(vector.size(), size);
+ QVERIFY(vector.capacity() >= size);
+ for (int i = oldSize; i < size; ++i)
+ QVERIFY(vector[i] == 0); // check initialization
+
+ const int capacity = vector.capacity();
+
+ vector.resize(0);
+ QCOMPARE(vector.size(), 0);
+ QVERIFY(vector.capacity() <= capacity);
+}
+
+void tst_QVector::resizeComplexMovable_data() const
+{
+ QTest::addColumn<QVector<Movable> >("vector");
+ QTest::addColumn<int>("size");
+
+ QVERIFY(QTypeInfo<Movable>::isComplex);
+ QVERIFY(!QTypeInfo<Movable>::isStatic);
+
+ QVector<Movable> null;
+ QVector<Movable> empty(0, 'Q');
+ QVector<Movable> emptyReserved;
+ QVector<Movable> nonEmpty;
+ QVector<Movable> nonEmptyReserved;
+
+ emptyReserved.reserve(10);
+ nonEmptyReserved.reserve(15);
+ nonEmpty << '0' << '1' << '2' << '3' << '4';
+ nonEmptyReserved << '0' << '1' << '2' << '3' << '4' << '5' << '6';
+ QVERIFY(emptyReserved.capacity() >= 10);
+ QVERIFY(nonEmptyReserved.capacity() >= 15);
+
+ QVector<Movable> nullNotShared;
+ QVector<Movable> emptyNotShared(0, 'Q');
+ QVector<Movable> emptyReservedNotShared;
+ QVector<Movable> nonEmptyNotShared;
+ QVector<Movable> nonEmptyReservedNotShared;
+
+ emptyReservedNotShared.reserve(10);
+ nonEmptyReservedNotShared.reserve(15);
+ nonEmptyNotShared << '0' << '1' << '2' << '3' << '4';
+ nonEmptyReservedNotShared << '0' << '1' << '2' << '3' << '4' << '5' << '6';
+ QVERIFY(emptyReservedNotShared.capacity() >= 10);
+ QVERIFY(nonEmptyReservedNotShared.capacity() >= 15);
+
+ emptyNotShared.setSharable(false);
+ emptyReservedNotShared.setSharable(false);
+ nonEmptyNotShared.setSharable(false);
+ nonEmptyReservedNotShared.setSharable(false);
+
+ QTest::newRow("null") << null << 10;
+ QTest::newRow("empty") << empty << 10;
+ QTest::newRow("emptyReserved") << emptyReserved << 10;
+ QTest::newRow("nonEmpty") << nonEmpty << 10;
+ QTest::newRow("nonEmptyReserved") << nonEmptyReserved << 10;
+ QTest::newRow("nullNotShared") << nullNotShared << 10;
+ QTest::newRow("emptyNotShared") << emptyNotShared << 10;
+ QTest::newRow("emptyReservedNotShared") << emptyReservedNotShared << 10;
+ QTest::newRow("nonEmptyNotShared") << nonEmptyNotShared << 10;
+ QTest::newRow("nonEmptyReservedNotShared") << nonEmptyReservedNotShared << 10;
+}
+
+void tst_QVector::resizeComplexMovable() const
+{
+ const int items = Movable::counter;
{
- // zero size
- QVector<int> myvec;
- QVERIFY(myvec.size() == 0);
+ QFETCH(QVector<Movable>, vector);
+ QFETCH(int, size);
- // grow
- myvec.append(42);
- QVERIFY(myvec.size() == 1);
- myvec.append(42);
- QVERIFY(myvec.size() == 2);
+ const int oldSize = vector.size();
- // shrink
- myvec.remove(0);
- QVERIFY(myvec.size() == 1);
- myvec.remove(0);
- QVERIFY(myvec.size() == 0);
+ vector.resize(size);
+ QCOMPARE(vector.size(), size);
+ QVERIFY(vector.capacity() >= size);
+ for (int i = oldSize; i < size; ++i)
+ QVERIFY(vector[i] == 'j'); // check initialization
+
+ const int capacity = vector.capacity();
+
+ vector.resize(0);
+ QCOMPARE(vector.size(), 0);
+ QVERIFY(vector.capacity() <= capacity);
+ }
+ QCOMPARE(items, Movable::counter);
+}
+
+void tst_QVector::resizeComplex_data() const
+{
+ QTest::addColumn<QVector<Custom> >("vector");
+ QTest::addColumn<int>("size");
+
+ QVERIFY(QTypeInfo<Custom>::isComplex);
+ QVERIFY(QTypeInfo<Custom>::isStatic);
+
+ QVector<Custom> null;
+ QVector<Custom> empty(0, '0');
+ QVector<Custom> emptyReserved;
+ QVector<Custom> nonEmpty;
+ QVector<Custom> nonEmptyReserved;
+
+ emptyReserved.reserve(10);
+ nonEmptyReserved.reserve(15);
+ nonEmpty << '0' << '1' << '2' << '3' << '4';
+ nonEmptyReserved << '0' << '1' << '2' << '3' << '4' << '5' << '6';
+ QVERIFY(emptyReserved.capacity() >= 10);
+ QVERIFY(nonEmptyReserved.capacity() >= 15);
+
+ QVector<Custom> nullNotShared;
+ QVector<Custom> emptyNotShared(0, '0');
+ QVector<Custom> emptyReservedNotShared;
+ QVector<Custom> nonEmptyNotShared;
+ QVector<Custom> nonEmptyReservedNotShared;
+
+ emptyReservedNotShared.reserve(10);
+ nonEmptyReservedNotShared.reserve(15);
+ nonEmptyNotShared << '0' << '1' << '2' << '3' << '4';
+ nonEmptyReservedNotShared << '0' << '1' << '2' << '3' << '4' << '5' << '6';
+ QVERIFY(emptyReservedNotShared.capacity() >= 10);
+ QVERIFY(nonEmptyReservedNotShared.capacity() >= 15);
+
+ emptyNotShared.setSharable(false);
+ emptyReservedNotShared.setSharable(false);
+ nonEmptyNotShared.setSharable(false);
+ nonEmptyReservedNotShared.setSharable(false);
+
+ QTest::newRow("null") << null << 10;
+ QTest::newRow("empty") << empty << 10;
+ QTest::newRow("emptyReserved") << emptyReserved << 10;
+ QTest::newRow("nonEmpty") << nonEmpty << 10;
+ QTest::newRow("nonEmptyReserved") << nonEmptyReserved << 10;
+ QTest::newRow("nullNotShared") << nullNotShared << 10;
+ QTest::newRow("emptyNotShared") << emptyNotShared << 10;
+ QTest::newRow("emptyReservedNotShared") << emptyReservedNotShared << 10;
+ QTest::newRow("nonEmptyNotShared") << nonEmptyNotShared << 10;
+ QTest::newRow("nonEmptyReservedNotShared") << nonEmptyReservedNotShared << 10;
+}
+
+void tst_QVector::resizeComplex() const
+{
+ const int items = Custom::counter;
+ {
+ QFETCH(QVector<Custom>, vector);
+ QFETCH(int, size);
+
+ int oldSize = vector.size();
+ vector.resize(size);
+ QCOMPARE(vector.size(), size);
+ QVERIFY(vector.capacity() >= size);
+ for (int i = oldSize; i < size; ++i)
+ QVERIFY(vector[i].i == 'j'); // check default initialization
+
+ const int capacity = vector.capacity();
+
+ vector.resize(0);
+ QCOMPARE(vector.size(), 0);
+ QVERIFY(vector.isEmpty());
+ QVERIFY(vector.capacity() <= capacity);
}
+ QCOMPARE(Custom::counter, items);
+}
+
+void tst_QVector::resizeCtorAndDtor() const
+{
+ const int items = Custom::counter;
+ {
+ QVector<Custom> null;
+ QVector<Custom> empty(0, '0');
+ QVector<Custom> emptyReserved;
+ QVector<Custom> nonEmpty;
+ QVector<Custom> nonEmptyReserved;
+
+ emptyReserved.reserve(10);
+ nonEmptyReserved.reserve(15);
+ nonEmpty << '0' << '1' << '2' << '3' << '4';
+ nonEmptyReserved << '0' << '1' << '2' << '3' << '4' << '5' << '6';
+ QVERIFY(emptyReserved.capacity() >= 10);
+ QVERIFY(nonEmptyReserved.capacity() >= 15);
+
+ // start playing with vectors
+ null.resize(21);
+ nonEmpty.resize(2);
+ emptyReserved.resize(0);
+ nonEmpty.resize(0);
+ nonEmptyReserved.resize(2);
+ }
+ QCOMPARE(Custom::counter, items);
+}
+
+template<typename T>
+void tst_QVector::size() const
+{
+ // zero size
+ QVector<T> myvec;
+ QVERIFY(myvec.size() == 0);
+
+ // grow
+ myvec.append(SimpleValue<T>::at(0));
+ QVERIFY(myvec.size() == 1);
+ myvec.append(SimpleValue<T>::at(1));
+ QVERIFY(myvec.size() == 2);
+
+ // shrink
+ myvec.remove(0);
+ QVERIFY(myvec.size() == 1);
+ myvec.remove(0);
+ QVERIFY(myvec.size() == 0);
+}
+
+void tst_QVector::sizeInt() const
+{
+ size<int>();
+}
+
+void tst_QVector::sizeMovable() const
+{
+ const int instancesCount = Movable::counter;
+ size<Movable>();
+ QCOMPARE(instancesCount, Movable::counter);
+}
+
+void tst_QVector::sizeCustom() const
+{
+ const int instancesCount = Custom::counter;
+ size<Custom>();
+ QCOMPARE(instancesCount, Custom::counter);
}
// ::squeeze() is tested in ::capacity().
QVERIFY(myvec.startsWith(1));
}
+template<typename T>
void tst_QVector::swap() const
{
- QVector<int> v1, v2;
- v1 << 1 << 2 << 3;
- v2 << 4 << 5 << 6;
+ QVector<T> v1, v2;
+ T val1 = SimpleValue<T>::at(0);
+ T val2 = SimpleValue<T>::at(1);
+ T val3 = SimpleValue<T>::at(2);
+ T val4 = SimpleValue<T>::at(3);
+ T val5 = SimpleValue<T>::at(4);
+ T val6 = SimpleValue<T>::at(5);
+ v1 << val1 << val2 << val3;
+ v2 << val4 << val5 << val6;
v1.swap(v2);
- QCOMPARE(v1,QVector<int>() << 4 << 5 << 6);
- QCOMPARE(v2,QVector<int>() << 1 << 2 << 3);
+ QCOMPARE(v1,QVector<T>() << val4 << val5 << val6);
+ QCOMPARE(v2,QVector<T>() << val1 << val2 << val3);
+}
+
+void tst_QVector::swapInt() const
+{
+ swap<int>();
+}
+
+void tst_QVector::swapMovable() const
+{
+ const int instancesCount = Movable::counter;
+ swap<Movable>();
+ QCOMPARE(instancesCount, Movable::counter);
+}
+
+void tst_QVector::swapCustom() const
+{
+ const int instancesCount = Custom::counter;
+ swap<Custom>();
+ QCOMPARE(instancesCount, Custom::counter);
}
void tst_QVector::toList() const
QCOMPARE(v2.size(), result4);
}
+template<typename T>
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;
+ T val1(SimpleValue<T>::at(1));
+ T val2(SimpleValue<T>::at(2));
+ T val3(SimpleValue<T>::at(3));
+ T val4(SimpleValue<T>::at(4));
+
+ QVector<T> v1 {val1, val2, val3};
+ QCOMPARE(v1, QVector<T>() << val1 << val2 << val3);
+ QCOMPARE(v1, (QVector<T> {val1, val2, val3}));
+
+ QVector<QVector<T>> v2{ v1, {val4}, QVector<T>(), {val1, val2, val3} };
+ QVector<QVector<T>> v3;
+ v3 << v1 << (QVector<T>() << val4) << QVector<T>() << v1;
QCOMPARE(v3, v2);
#endif
}
+void tst_QVector::initializeListInt()
+{
+ initializeList<int>();
+}
+
+void tst_QVector::initializeListMovable()
+{
+ const int instancesCount = Movable::counter;
+ initializeList<Movable>();
+ QCOMPARE(instancesCount, Movable::counter);
+}
+
+void tst_QVector::initializeListCustom()
+{
+ const int instancesCount = Custom::counter;
+ initializeList<Custom>();
+ QCOMPARE(instancesCount, Custom::counter);
+}
+
void tst_QVector::const_shared_null()
{
QVector<int> v1;
Q_DECLARE_METATYPE(QVector<int>);
-void tst_QVector::setSharable_data()
+template<typename T>
+void tst_QVector::setSharable_data() const
{
- QTest::addColumn<QVector<int> >("vector");
+ QTest::addColumn<QVector<T> >("vector");
QTest::addColumn<int>("size");
QTest::addColumn<int>("capacity");
QTest::addColumn<bool>("isCapacityReserved");
- QVector<int> null;
- QVector<int> empty(0, 5);
- QVector<int> emptyReserved;
- QVector<int> nonEmpty;
- QVector<int> nonEmptyReserved;
+ QVector<T> null;
+ QVector<T> empty(0, SimpleValue<T>::at(1));
+ QVector<T> emptyReserved;
+ QVector<T> nonEmpty;
+ QVector<T> nonEmptyReserved;
emptyReserved.reserve(10);
nonEmptyReserved.reserve(15);
- nonEmpty << 0 << 1 << 2 << 3 << 4;
- nonEmptyReserved << 0 << 1 << 2 << 3 << 4 << 5 << 6;
+ nonEmpty << SimpleValue<T>::at(0) << SimpleValue<T>::at(1) << SimpleValue<T>::at(2) << SimpleValue<T>::at(3) << SimpleValue<T>::at(4);
+ nonEmptyReserved << SimpleValue<T>::at(0) << SimpleValue<T>::at(1) << SimpleValue<T>::at(2) << SimpleValue<T>::at(3) << SimpleValue<T>::at(4) << SimpleValue<T>::at(5) << SimpleValue<T>::at(6);
QVERIFY(emptyReserved.capacity() >= 10);
QVERIFY(nonEmptyReserved.capacity() >= 15);
QTest::newRow("non-empty, Reserved") << nonEmptyReserved << 7 << 15 << true;
}
-void tst_QVector::setSharable()
+void tst_QVector::setSharableInt_data()
{
- QFETCH(QVector<int>, vector);
+ setSharable_data<int>();
+}
+
+void tst_QVector::setSharableMovable_data()
+{
+ setSharable_data<Movable>();
+}
+
+void tst_QVector::setSharableCustom_data()
+{
+ setSharable_data<Custom>();
+}
+
+template<typename T>
+void tst_QVector::setSharable() const
+{
+ QFETCH(QVector<T>, vector);
QFETCH(int, size);
QFETCH(int, capacity);
QFETCH(bool, isCapacityReserved);
.arg(capacity)));
{
- QVector<int> copy(vector);
+ QVector<T> copy(vector);
QVERIFY(!copy.isDetached());
QVERIFY(copy.isSharedWith(vector));
}
vector.setSharable(false);
- QVERIFY(vector.isDetached() || vector.isSharedWith(QVector<int>()));
+ QVERIFY(vector.isDetached() || vector.isSharedWith(QVector<T>()));
{
- QVector<int> copy(vector);
+ QVector<T> copy(vector);
- QVERIFY(copy.isDetached() || copy.isSharedWith(QVector<int>()));
+ QVERIFY(copy.isDetached() || copy.isEmpty() || copy.isSharedWith(QVector<T>()));
QCOMPARE(copy.size(), size);
if (isCapacityReserved)
QVERIFY2(copy.capacity() >= capacity,
vector.setSharable(true);
{
- QVector<int> copy(vector);
+ QVector<T> copy(vector);
QVERIFY(!copy.isDetached());
QVERIFY(copy.isSharedWith(vector));
}
for (int i = 0; i < vector.size(); ++i)
- QCOMPARE(vector[i], i);
+ QCOMPARE(vector[i], SimpleValue<T>::at(i));
QCOMPARE(vector.size(), size);
if (isCapacityReserved)
.arg(capacity)));
}
+void tst_QVector::setSharableInt()
+{
+ setSharable<int>();
+}
+
+void tst_QVector::setSharableMovable()
+{
+ const int instancesCount = Movable::counter;
+ setSharable<Movable>();
+ QCOMPARE(instancesCount, Movable::counter);
+}
+
+void tst_QVector::setSharableCustom()
+{
+ const int instancesCount = Custom::counter;
+ setSharable<Custom>();
+ QCOMPARE(instancesCount, Custom::counter);
+}
+
+template<typename T>
+void tst_QVector::detach() const
+{
+ {
+ // detach an empty vector
+ QVector<T> v;
+ v.detach();
+ QVERIFY(v.isDetached());
+ QCOMPARE(v.size(), 0);
+ QCOMPARE(v.capacity(), 0);
+ }
+ {
+ // detach an empty referenced vector
+ QVector<T> v;
+ QVector<T> ref(v);
+ QVERIFY(!v.isDetached());
+ v.detach();
+ QVERIFY(v.isDetached());
+ QCOMPARE(v.size(), 0);
+ QCOMPARE(v.capacity(), 0);
+ }
+ {
+ // detach a not empty referenced vector
+ QVector<T> v(31);
+ QVector<T> ref(v);
+ QVERIFY(!v.isDetached());
+ v.detach();
+ QVERIFY(v.isDetached());
+ QCOMPARE(v.size(), 31);
+ QCOMPARE(v.capacity(), 31);
+ }
+ {
+ // detach a not empty vector
+ QVector<T> v(31);
+ QVERIFY(v.isDetached());
+ v.detach(); // detaching a detached vector
+ QVERIFY(v.isDetached());
+ QCOMPARE(v.size(), 31);
+ QCOMPARE(v.capacity(), 31);
+ }
+ {
+ // detach a not empty vector with preallocated space
+ QVector<T> v(3);
+ v.reserve(8);
+ QVector<T> ref(v);
+ QVERIFY(!v.isDetached());
+ v.detach();
+ QVERIFY(v.isDetached());
+ QCOMPARE(v.size(), 3);
+ QCOMPARE(v.capacity(), 8);
+ }
+ {
+ // detach a not empty vector with preallocated space
+ QVector<T> v(3);
+ v.reserve(8);
+ QVERIFY(v.isDetached());
+ v.detach(); // detaching a detached vector
+ QVERIFY(v.isDetached());
+ QCOMPARE(v.size(), 3);
+ QCOMPARE(v.capacity(), 8);
+ }
+ {
+ // detach a not empty, initialized vector
+ QVector<T> v(7, SimpleValue<T>::at(1));
+ QVector<T> ref(v);
+ QVERIFY(!v.isDetached());
+ v.detach();
+ QVERIFY(v.isDetached());
+ QCOMPARE(v.size(), 7);
+ for (int i = 0; i < v.size(); ++i)
+ QCOMPARE(v[i], SimpleValue<T>::at(1));
+ }
+ {
+ // detach a not empty, initialized vector
+ QVector<T> v(7, SimpleValue<T>::at(2));
+ QVERIFY(v.isDetached());
+ v.detach(); // detaching a detached vector
+ QVERIFY(v.isDetached());
+ QCOMPARE(v.size(), 7);
+ for (int i = 0; i < v.size(); ++i)
+ QCOMPARE(v[i], SimpleValue<T>::at(2));
+ }
+ {
+ // detach a not empty, initialized vector with preallocated space
+ QVector<T> v(7, SimpleValue<T>::at(3));
+ v.reserve(31);
+ QVector<T> ref(v);
+ QVERIFY(!v.isDetached());
+ v.detach();
+ QVERIFY(v.isDetached());
+ QCOMPARE(v.size(), 7);
+ QCOMPARE(v.capacity(), 31);
+ for (int i = 0; i < v.size(); ++i)
+ QCOMPARE(v[i], SimpleValue<T>::at(3));
+ }
+}
+
+void tst_QVector::detachInt() const
+{
+ detach<int>();
+}
+
+void tst_QVector::detachMovable() const
+{
+ const int instancesCount = Movable::counter;
+ detach<Movable>();
+ QCOMPARE(instancesCount, Movable::counter);
+}
+
+void tst_QVector::detachCustom() const
+{
+ const int instancesCount = Custom::counter;
+ detach<Custom>();
+ QCOMPARE(instancesCount, Custom::counter);
+}
+
QTEST_APPLESS_MAIN(tst_QVector)
#include "tst_qvector.moc"
projects / profile / ivi / qtbase.git / commitdiff