31 #define QT_SHAREDPOINTER_TRACK_POINTERS
35 #include <QRandomGenerator>
36 #include <QtCore/QHash>
37 #include <QtCore/QList>
38 #include <QtCore/QMap>
39 #include <QtCore/QThread>
40 #include <QtCore/private/qvolatile_p.h>
51 #if defined(Q_OS_UNIX) && !defined(Q_OS_INTEGRITY)
52 #include <sys/resource.h>
73 void useOfForwardDeclared();
74 void memoryManagement();
75 void dropLastReferenceOfForwardDeclared();
76 void nonVirtualDestructors();
79 void functionCallDownCast();
81 void qobjectWeakManagement();
82 void weakQObjectFromSharedPointer();
84 void objectCastStdSharedPtr();
85 void differentPointers();
86 void virtualBaseDifferentPointers();
89 void dynamicCastDifferentPointers();
90 void dynamicCastVirtualBase();
91 void dynamicCastFailure();
92 void dynamicCastFailureNoLeak();
94 void constCorrectness();
96 void lambdaCustomDeleter();
97 void customDeleterOnNullptr();
99 void creatingCvQualified();
100 void creatingVariadic();
101 void creatingQObject();
102 void mixTrackingPointerCode();
103 void reentrancyWhileDestructing();
107 void sharedFromThis();
109 void constructorThrow();
112 void threadStressTest_data();
113 void threadStressTest();
114 void validConstructs();
116 void invalidConstructs_data();
117 void invalidConstructs();
128 #ifdef QT_BUILD_INTERNAL
134 void tst_QSharedPointer::initTestCase()
136 #if defined(Q_OS_UNIX) && !defined(Q_OS_INTEGRITY)
140 struct rlimit numFiles;
141 if (getrlimit(RLIMIT_NOFILE, &numFiles) == 0 && numFiles.rlim_cur < 1024) {
142 numFiles.rlim_cur = qMin(rlim_t(1024), numFiles.rlim_max);
143 setrlimit(RLIMIT_NOFILE, &numFiles);
148 template<
typename T>
static inline
159 return static_cast<const Dummy*
>(
static_cast<const void*
>(&
b))->data;
175 qFatal(
"tst_qsharedpointer: Double deletion!");
244 std::unique_ptr<int>
i;
248 void tst_QSharedPointer::basics_data()
250 QTest::addColumn<bool>(
"isNull");
255 void tst_QSharedPointer::basics()
261 QCOMPARE(
sizeof(ptr), 2*
sizeof(
void*));
269 QCOMPARE(
sizeof(ptr), 2*
sizeof(
void*));
290 Data &dataReference = *ptr;
304 QVERIFY(!refCountData(ptr) || refCountData(ptr)->
weakref.loadRelaxed() == 1);
305 QVERIFY(!refCountData(ptr) || refCountData(ptr)->strongref.loadRelaxed() == 1);
317 QVERIFY(!refCountData(ptr) || refCountData(ptr)->
weakref.loadRelaxed() == 1);
318 QVERIFY(!refCountData(ptr) || refCountData(ptr)->strongref.loadRelaxed() == 1);
335 QVERIFY(!refCountData(ptr) || refCountData(ptr)->
weakref.loadRelaxed() == 1);
336 QVERIFY(!refCountData(ptr) || refCountData(ptr)->strongref.loadRelaxed() == 1);
345 QCOMPARE(weak.isNull(), (weak ==
nullptr));
346 QCOMPARE(weak.isNull(), (
nullptr == weak));
347 QCOMPARE(!weak.isNull(), (weak !=
nullptr));
348 QCOMPARE(!weak.isNull(), (
nullptr != weak));
373 QVERIFY(!refCountData(ptr) || refCountData(ptr)->
weakref.loadRelaxed() == 1);
374 QVERIFY(!refCountData(ptr) || refCountData(ptr)->strongref.loadRelaxed() == 1);
379 void tst_QSharedPointer::operators()
415 void tst_QSharedPointer::nullptrOps()
473 void tst_QSharedPointer::swap()
528 void tst_QSharedPointer::moveSemantics()
584 void tst_QSharedPointer::useOfForwardDeclared()
611 void tst_QSharedPointer::memoryManagement()
616 int generation =
Data::generationCounter + 1;
617 int destructorCounter =
Data::destructorCounter;
620 QCOMPARE(ptr->generation, generation);
625 QCOMPARE(ptr->generation, generation);
631 QCOMPARE(ptr->generation, generation);
632 QCOMPARE(copy->generation, generation);
636 QCOMPARE(ptr->generation, generation);
643 QCOMPARE(ptr->generation, generation);
648 QCOMPARE(ptr->generation, generation);
653 QCOMPARE(ptr->generation, generation);
660 QCOMPARE(ptr->generation, generation);
680 void tst_QSharedPointer::dropLastReferenceOfForwardDeclared()
706 void tst_QSharedPointer::nonVirtualDestructors()
739 void tst_QSharedPointer::lock()
795 void tst_QSharedPointer::downCast()
818 baseptr = qSharedPointerCast<Data>(ptr);
819 baseweak = qSharedPointerCast<Data>(ptr);
820 baseweak2 = baseweak;
823 baseptr = qSharedPointerCast<Data>(std::move(ptr));
825 baseweak = qSharedPointerCast<Data>(std::move(ptr));
827 baseweak2 = qSharedPointerCast<Data>(std::move(baseweak));
853 baseweak = std::move(ptr);
854 baseweak2 = std::move(weak);
856 baseptr = std::move(ptr);
905 void tst_QSharedPointer::functionCallDownCast()
912 void tst_QSharedPointer::upCast()
918 QVERIFY(baseptr == derivedptr);
922 QCOMPARE(
int(refCountData(baseptr)->strongref.loadRelaxed()), 1);
926 QVERIFY(baseptr == derivedptr);
929 QCOMPARE(
int(refCountData(baseptr)->strongref.loadRelaxed()), 1);
934 QVERIFY(baseptr == derivedptr);
938 QCOMPARE(
int(refCountData(baseptr)->strongref.loadRelaxed()), 1);
942 QVERIFY(baseptr == derivedptr);
946 QCOMPARE(
int(refCountData(baseptr)->strongref.loadRelaxed()), 1);
954 void tst_QSharedPointer::qobjectWeakManagement()
1028 void tst_QSharedPointer::weakQObjectFromSharedPointer()
1041 void tst_QSharedPointer::objectCast()
1060 ptr = qobject_cast<OtherObject *>(baseptr);
1064 ptr = qobject_cast<QSharedPointer<OtherObject> >(baseptr);
1086 ptr = qobject_cast<const OtherObject *>(baseptr);
1090 ptr = qobject_cast<QSharedPointer<const OtherObject> >(baseptr);
1106 otherptr = qobject_cast<OtherObject *>(weakptr);
1110 otherptr = qobject_cast<QSharedPointer<OtherObject> >(weakptr);
1125 otherptr = qobject_cast<OtherObject *>(weakptr);
1129 otherptr = qobject_cast<QSharedPointer<OtherObject> >(weakptr);
1136 void tst_QSharedPointer::objectCastStdSharedPtr()
1140 std::shared_ptr<QObject> baseptr = std::shared_ptr<QObject>(
data);
1144 std::shared_ptr<OtherObject> ptr = qobject_pointer_cast<OtherObject>(baseptr);
1153 std::shared_ptr<QObject> baseptr = std::shared_ptr<QObject>(
data);
1157 std::shared_ptr<OtherObject> ptr = qobject_pointer_cast<OtherObject>(std::move(baseptr));
1166 std::shared_ptr<QObject> baseptr = std::shared_ptr<QObject>(
data);
1170 std::shared_ptr<OtherObject> ptr = qobject_pointer_cast<OtherObject>(baseptr);
1178 std::shared_ptr<QObject> baseptr = std::shared_ptr<QObject>(
data);
1182 std::shared_ptr<OtherObject> ptr = qobject_pointer_cast<OtherObject>(std::move(baseptr));
1189 void tst_QSharedPointer::differentPointers()
1193 Data *aBase = aData;
1196 if (*
reinterpret_cast<quintptr *
>(&aData) == *
reinterpret_cast<quintptr *
>(&aBase))
1197 QFAIL(
"Something went very wrong -- we couldn't create two different pointers to the same object");
1198 if (aData != aBase || aBase != aData)
1199 QSKIP(
"Broken compiler");
1203 qDebug(
"naked: orig: %p; base: %p (%s) -- QSharedPointer: orig: %p; base %p (%s) -- result: %s",
1204 aData, aBase, aData == aBase ?
"equal" :
"not equal",
1205 ptr.
data(), baseptr.
data(), ptr.
data() == baseptr.
data() ?
"equal" :
"not equal",
1206 baseptr.
data() == aData ?
"equal" :
"not equal");
1237 Data *aBase = aData;
1252 Data *aBase = aData;
1268 void tst_QSharedPointer::virtualBaseDifferentPointers()
1272 Data *aBase = aData;
1289 Data *aBase = aData;
1305 #ifndef QTEST_NO_RTTI
1306 void tst_QSharedPointer::dynamicCast()
1313 QVERIFY(baseptr == derivedptr);
1318 QCOMPARE(
int(refCountData(baseptr)->strongref.loadRelaxed()), 1);
1323 QVERIFY(baseptr == derivedptr);
1328 QCOMPARE(
int(refCountData(baseptr)->strongref.loadRelaxed()), 1);
1332 QVERIFY(baseptr == derivedptr);
1337 QCOMPARE(
int(refCountData(baseptr)->strongref.loadRelaxed()), 1);
1340 void tst_QSharedPointer::dynamicCastDifferentPointers()
1348 QVERIFY(baseptr == derivedptr);
1353 QCOMPARE(
int(refCountData(baseptr)->strongref.loadRelaxed()), 1);
1358 QVERIFY(baseptr == derivedptr);
1363 QCOMPARE(
int(refCountData(baseptr)->strongref.loadRelaxed()), 1);
1367 QVERIFY(baseptr == derivedptr);
1372 QCOMPARE(
int(refCountData(baseptr)->strongref.loadRelaxed()), 1);
1380 QVERIFY(otherbaseptr == nakedptr);
1386 void tst_QSharedPointer::dynamicCastVirtualBase()
1393 QVERIFY(baseptr == derivedptr);
1398 QCOMPARE(
int(refCountData(baseptr)->strongref.loadRelaxed()), 1);
1403 QVERIFY(baseptr == derivedptr);
1408 QCOMPARE(
int(refCountData(baseptr)->strongref.loadRelaxed()), 1);
1412 QVERIFY(baseptr == derivedptr);
1417 QCOMPARE(
int(refCountData(baseptr)->strongref.loadRelaxed()), 1);
1420 void tst_QSharedPointer::dynamicCastFailure()
1430 QCOMPARE(
int(refCountData(baseptr)->strongref.loadRelaxed()), 1);
1437 QCOMPARE(
int(refCountData(baseptr)->strongref.loadRelaxed()), 1);
1440 void tst_QSharedPointer::dynamicCastFailureNoLeak()
1446 void tst_QSharedPointer::constCorrectness()
1455 ptr = qSharedPointerConstCast<Data>(cptr);
1456 ptr = qSharedPointerConstCast<Data>(vptr);
1466 ptr = qSharedPointerConstCast<Data>(cvptr);
1479 #ifndef QT_NO_DYNAMIC_CAST
1480 other = qSharedPointerDynamicCast<Data>(cptr);
1484 QCOMPARE(cptr.operator->(), aData);
1489 static int customDeleterFnCallCount;
1492 ++customDeleterFnCallCount;
1496 static int refcount;
1498 template <
typename T>
1513 void tst_QSharedPointer::customDeleter()
1540 customDeleterFnCallCount = 0;
1544 QCOMPARE(customDeleterFnCallCount, 0);
1546 QCOMPARE(customDeleterFnCallCount, 1);
1549 customDeleterFnCallCount = 0;
1552 QCOMPARE(customDeleterFnCallCount, 0);
1554 QCOMPARE(customDeleterFnCallCount, 1);
1556 QCOMPARE(customDeleterFnCallCount, 1);
1559 customDeleterFnCallCount = 0;
1562 QCOMPARE(customDeleterFnCallCount, 0);
1564 QCOMPARE(customDeleterFnCallCount, 1);
1566 QCOMPARE(customDeleterFnCallCount, 1);
1569 customDeleterFnCallCount = 0;
1573 QCOMPARE(customDeleterFnCallCount, 0);
1575 QCOMPARE(customDeleterFnCallCount, 1);
1578 customDeleterFnCallCount = 0;
1582 QCOMPARE(customDeleterFnCallCount, 0);
1584 QCOMPARE(customDeleterFnCallCount, 1);
1587 customDeleterFnCallCount = 0;
1593 QCOMPARE(customDeleterFnCallCount, 0);
1595 QCOMPARE(customDeleterFnCallCount, 0);
1597 QCOMPARE(customDeleterFnCallCount, 1);
1600 customDeleterFnCallCount = 0;
1606 QCOMPARE(customDeleterFnCallCount, 0);
1608 QCOMPARE(customDeleterFnCallCount, 0);
1610 QCOMPARE(customDeleterFnCallCount, 1);
1745 void tst_QSharedPointer::lambdaCustomDeleter()
1754 customDeleterFnCallCount = 0;
1760 QCOMPARE(customDeleterFnCallCount, 1);
1772 void tst_QSharedPointer::customDeleterOnNullptr()
1774 Data *
null =
nullptr;
1776 auto deleter = [&callCount](
Data *) { ++callCount; };
1801 ++customDeleterFnCallCount;
1805 void tst_QSharedPointer::creating()
1833 QVERIFY(
d->weakref.loadRelaxed() == 1);
1834 QVERIFY(
d->strongref.loadRelaxed() == 0);
1866 QCOMPARE(baseptr->classLevel(), 4);
1871 void tst_QSharedPointer::creatingCvQualified()
1878 void tst_QSharedPointer::creatingVariadic()
1910 QCOMPARE(ptr->ptr, (
void*)
nullptr);
1928 std::unique_ptr<int>
p(
new int(
i));
1953 void tst_QSharedPointer::creatingQObject()
1957 QCOMPARE(ptr->metaObject(), &QObject::staticMetaObject);
1968 QCOMPARE(ptr->metaObject(), &OtherObject::staticMetaObject);
1973 void tst_QSharedPointer::mixTrackingPointerCode()
2033 void tst_QSharedPointer::threadStressTest_data()
2035 QTest::addColumn<int>(
"strongThreadCount");
2036 QTest::addColumn<int>(
"weakThreadCount");
2054 void tst_QSharedPointer::threadStressTest()
2056 QFETCH(
int, strongThreadCount);
2057 QFETCH(
int, weakThreadCount);
2063 memset(guard1, 0,
sizeof guard1);
2064 memset(guard2, 0,
sizeof guard2);
2066 for (
int r = 0;
r < 5; ++
r) {
2067 QList<QThread*> allThreads(6 * qMax(strongThreadCount, weakThreadCount) + 3, 0);
2072 for (
int i = 0;
i < strongThreadCount; ++
i) {
2075 allThreads[2 *
i] =
t;
2077 for (
int i = 0;
i < weakThreadCount; ++
i) {
2080 allThreads[6 *
i + 3] =
t;
2086 for (
int i = 0;
i < allThreads.count(); ++
i)
2087 if (allThreads[
i]) allThreads[
i]->start();
2090 for (
int i = 0;
i < allThreads.count(); ++
i)
2091 if (allThreads[
i]) allThreads[
i]->wait();
2095 for (
uint i = 0;
i <
sizeof guard1 /
sizeof guard1[0]; ++
i)
2097 for (
uint i = 0;
i <
sizeof guard2 /
sizeof guard2[0]; ++
i)
2102 int maxValue = strongThreadCount + weakThreadCount;
2108 template<
typename Container,
bool Ordered,
bool Multi>
2167 void tst_QSharedPointer::map()
2169 hashAndMapTest<QMap<QSharedPointer<int>,
int>,
true,
false>();
2170 hashAndMapTest<QMultiMap<QSharedPointer<int>,
int>,
true,
true>();
2173 void tst_QSharedPointer::hash()
2175 hashAndMapTest<QHash<QSharedPointer<int>,
int>,
false,
false>();
2176 hashAndMapTest<QMultiHash<QSharedPointer<int>,
int>,
false,
true>();
2179 void tst_QSharedPointer::validConstructs()
2203 void tst_QSharedPointer::invalidConstructs_data()
2205 QTest::addColumn<TestFunction>(
"testFunction");
2206 QTest::addColumn<QString>(
"code");
2215 <<
"QSharedPointer<Data> ptr = new Data;";
2218 <<
"QSharedPointer<Data> ptr;"
2222 <<
"QWeakPointer<Data> ptr = new Data;";
2225 <<
"QWeakPointer<Data> ptr;"
2231 <<
"QSharedPointer<ForwardDeclared>::create();";
2236 <<
"QSharedPointer<Data> baseptr = QSharedPointer<Data>(new DerivedData);\n"
2237 "QSharedPointer<DerivedData> ptr(baseptr);";
2240 <<
"QSharedPointer<Data> baseptr = QSharedPointer<Data>(new DerivedData);\n"
2241 "QSharedPointer<DerivedData> ptr;\n"
2247 <<
"QSharedPointer<const Data> baseptr = QSharedPointer<const Data>(new Data);\n"
2248 "QSharedPointer<Data> ptr(baseptr);";
2251 <<
"QSharedPointer<const Data> baseptr = QSharedPointer<const Data>(new Data);\n"
2252 "QSharedPointer<Data> ptr;"
2256 <<
"QSharedPointer<const Data> baseptr = QSharedPointer<const Data>(new Data);\n"
2257 "qSharedPointerCast<DerivedData>(baseptr);";
2258 #ifndef QTEST_NO_RTTI
2261 <<
"QSharedPointer<const Data> baseptr = QSharedPointer<const Data>(new Data);\n"
2262 "qSharedPointerDynamicCast<DerivedData>(baseptr);";
2266 <<
"QSharedPointer<const QObject> baseptr = QSharedPointer<const QObject>(new QObject);\n"
2267 "qSharedPointerObjectCast<QCoreApplication>(baseptr);";
2270 <<
"QSharedPointer<const QObject> baseptr = QSharedPointer<const QObject>(new QObject);\n"
2271 "qobject_cast<QCoreApplication *>(baseptr);";
2276 <<
"QSharedPointer<int> a;"
2277 "QSharedPointer<Data> b;\n"
2278 "if (a == b) return;";
2281 <<
"QSharedPointer<int> a;"
2282 "QSharedPointer<Data> b;\n"
2283 "if (a + b) return;";
2288 <<
"Data *aData = new Data;\n"
2289 "QSharedPointer<Data> ptr1 = QSharedPointer<Data>(aData);\n"
2290 "QSharedPointer<Data> ptr2 = QSharedPointer<Data>(aData);\n";
2295 <<
"QObject *anObj = new QObject;\n"
2296 "QSharedPointer<QObject> ptr1 = QSharedPointer<QObject>(anObj);\n"
2297 "QSharedPointer<QObject> ptr2 = QSharedPointer<QObject>(anObj);\n";
2302 <<
"Data *aData = new Data;\n"
2303 "QSharedPointer<Data> ptr1 = QSharedPointer<Data>(aData);"
2304 "ptr1 = QSharedPointer<Data>(aData);";
2310 <<
"QSharedPointer<Data> ptr1;\n"
2311 "QSharedPointer<int> ptr2 = qSharedPointerCast<int>(ptr1);";
2312 #ifndef QTEST_NO_RTTI
2315 <<
"QSharedPointer<Data> ptr1;\n"
2316 "QSharedPointer<int> ptr2 = qSharedPointerDynamicCast<int>(ptr1);";
2320 <<
"QSharedPointer<Data> ptr1;\n"
2321 "QSharedPointer<int> ptr2 = qSharedPointerConstCast<int>(ptr1);";
2324 <<
"QSharedPointer<Data> ptr1;\n"
2325 "QSharedPointer<int> ptr2 = qSharedPointerObjectCast<int>(ptr1);";
2329 <<
"Data *ptr = nullptr;\n"
2330 "QWeakPointer<Data> weakptr(ptr);\n";
2334 <<
"Data *ptr = nullptr;\n"
2335 "QSharedPointer<Data> weakptr = Qt::Uninitialized;\n";
2339 <<
"extern void incompatibleCustomDeleter(int *);\n"
2340 "QSharedPointer<Data> ptr(new Data, incompatibleCustomDeleter);\n";
2343 <<
"struct IncompatibleCustomDeleter { void operator()(int *); };\n"
2344 "QSharedPointer<Data> ptr(new Data, IncompatibleCustomDeleter());\n";
2347 <<
"QSharedPointer<Data> ptr(new Data, [](int *) {});\n";
2351 <<
"void foo(QSharedPointer<DerivedData>) {}\n"
2352 "void bar() { foo(QSharedPointer<Data>()); }\n";
2355 void tst_QSharedPointer::invalidConstructs()
2358 QSKIP(
"The maintainer of QSharedPointer: 'We don't know what the problem is so skip the tests.'");
2360 #ifdef QTEST_CROSS_COMPILED
2361 QSKIP(
"This test does not work on cross compiled systems");
2366 test.setProgramHeader(
2367 "#define QT_SHAREDPOINTER_TRACK_POINTERS\n"
2368 "#define QT_DEBUG\n"
2369 "#include <QtCore/qsharedpointer.h>\n"
2370 "#include <QtCore/qcoreapplication.h>\n"
2372 "struct Data { int i; };\n"
2373 "struct DerivedData: public Data { int j; };\n"
2375 "class ForwardDeclared;\n"
2379 static bool sane =
true;
2380 if (
code.isEmpty()) {
2381 if (!
test.tryRun(
"")
2382 || !
test.tryRunFail(
"exit(1);")
2383 || !
test.tryRun(
"QSharedPointer<Data> baseptr; QSharedPointer<DerivedData> ptr;")) {
2385 qWarning(
"Sanity checking failed\nCode:\n%s\n",
2386 qPrintable(
test.errorReport()));
2390 QFAIL(
"External testing failed sanity checking, cannot proceed");
2397 if (!
result || qgetenv(
"QTEST_EXTERNAL_DEBUG").toInt() > 0) {
2398 qDebug(
"External test output:");
2401 printf(
"%s\n",
test.standardOutput().constData());
2403 printf(
"%s\n",
test.standardError().constData());
2406 qWarning(
"External code testing failed\nCode:\n%s\n",
body.constData());
2412 void tst_QSharedPointer::qvariantCast()
2415 sp->setObjectName(
"A test name");
2447 return sharedFromThis();
2452 return sharedFromThis();
2458 void tst_QSharedPointer::sharedFromThis()
2570 scp5 =
const_cast<const SomeClass *
>(sc)->getSharedPtr();
2592 scp = scp2->sharedFromThis();
2607 scp2 = scp->sharedFromThis();
2621 scp2 = scp->getSharedPtr();
2635 scp2 = qSharedPointerConstCast<const SomeClass>(scp)->getSharedPtr();
2649 scp2 = scp->sharedFromThis();
2677 scp = scp2->sharedFromThis();
2708 #ifndef QT_NO_EXCEPTIONS
2717 childGenerationCounter++;
2723 childDestructorCounter++;
2730 void tst_QSharedPointer::constructorThrow()
2732 #ifndef QT_NO_EXCEPTIONS
2752 QSKIP(
"Needs exceptions");
2803 void tst_QSharedPointer::reentrancyWhileDestructing()
2812 struct Child1 : Base1 {};
2813 struct Child2 : Base2 {};
2815 template<
template<
typename>
class SmartPtr>
2818 std::array<int, 1> call(
const SmartPtr<const Base1> &)
2822 std::array<int, 2> call(
const SmartPtr<const Base2> &)
2826 static const constexpr
uint base1Called =
sizeof(std::array<int, 1>);
2827 static const constexpr
uint base2Called =
sizeof(std::array<int, 2>);
2831 #define QVERIFY_CALLS(expr, base) static_assert(sizeof(call(expr)) == base##Called)
2840 #undef QVERIFY_CALLS
2845 void tst_QSharedPointer::overloads()
2848 sharedOverloaded.test();
2850 weakOverloaded.test();
2854 #include "tst_qsharedpointer.moc"
small capitals from c petite p scientific f u
small capitals from c petite p scientific i
[1]
size_t qHash(const FixStringCacheKey &f)
int classLevel() override
void virtualDelete() override
static int derivedDestructorCounter
int classLevel() override
The QAtomicInt class provides platform-independent atomic operations on int.
The QByteArray class provides an array of bytes.
A base class that allows obtaining a QSharedPointer for an object already managed by a shared pointer...
QSharedPointer< T > sharedFromThis()
The QLatin1String class provides a thin wrapper around an US-ASCII/Latin-1 encoded string literal.
The QObject class is the base class of all Qt objects.
Q_INVOKABLE QObject(QObject *parent=nullptr)
void swap(QPixmap &other) noexcept
static Q_DECL_CONST_FUNCTION QRandomGenerator * global()
The QSharedPointer class holds a strong reference to a shared pointer.
bool isNull() const noexcept
QSharedPointer< X > constCast() const
QSharedPointer< X > objectCast() const
T * data() const noexcept
QSharedPointer< X > dynamicCast() const
static QSharedPointer create(Args &&...arguments)
QSharedPointer< X > staticCast() const
void swap(QSharedPointer &other) noexcept
The QString class provides a Unicode character string.
static QString fromLatin1(QByteArrayView ba)
bool tryCompileFail(const QByteArray &body)
bool tryRunFail(const QByteArray &body)
bool tryCompile(const QByteArray &body)
static void usleep(unsigned long)
The QVariant class acts like a union for the most common Qt data types.
static auto fromValue(const T &value) -> std::enable_if_t< std::is_copy_constructible_v< T >, QVariant >
The QWeakPointer class holds a weak reference to a shared pointer.
QSharedPointer< T > toStrongRef() const
QSharedPointer< T > lock() const
bool isNull() const noexcept
QSharedPointer< const SomeClass > getSharedPtr() const
QSharedPointer< SomeClass > getSharedPtr()
QSharedPointer< ThreadData > ptr
ThreadData(QAtomicInt *p)
static int childDestructorCounter
static int childGenerationCounter
int classLevel() override
QWeakPointer< ThreadData > weak
qDeleteAll(list.begin(), list.end())
QSharedPointer< ForwardDeclared > * forwardPointer()
int forwardDeclaredDestructorRunCount
void dynamicCastFailureNoLeak()
typename C::value_type value_type
typename C::key_type key_type
typename C::mapped_type mapped_type
typename C::iterator iterator
Q_TESTLIB_EXPORT QTestData & newRow(const char *dataTag)
auto volatilePreIncrement(T &x)
Q_AUTOTEST_EXPORT void internalSafetyCheckCleanCheck()
typing.Tuple[int, int] test(str binary_directory, *debug=False)
#define QT_WARNING_DISABLE_CLANG(text)
typedef QByteArray(EGLAPIENTRYP PFNQGSGETDISPLAYSPROC)()
EGLOutputLayerEXT EGLint EGLAttrib value
GLboolean GLboolean GLboolean b
GLsizei const GLfloat * v
[13]
GLint GLint GLint GLint GLint x
[0]
GLfloat GLfloat GLfloat w
[0]
GLint GLsizei GLsizei GLenum GLenum GLsizei void * data
GLdouble GLdouble GLint GLint GLdouble GLdouble GLint GLint GLdouble GLdouble w2
GLdouble GLdouble GLint GLint GLdouble GLdouble GLint GLint GLdouble w1
#define QStringLiteral(str)
#define QTEST_MAIN(TestObject)
#define QSKIP(statement,...)
#define QFETCH(Type, name)
#define QVERIFY_THROWS_EXCEPTION(exceptiontype,...)
#define QVERIFY(statement)
CustomDeleter(const CustomDeleter &)
virtual void virtualDelete()
static int destructorCounter
static int generationCounter
static int destructorCounter
static int destructorCounter
NoDefaultConstructor1(int i)
NoDefaultConstructor1(uint j)
NoDefaultConstructor2(void *ptr, int i)
NoDefaultConstructorConstRef2(const QString &str, int i)
NoDefaultConstructorConstRef2(const QByteArray &ba, int i=42)
NoDefaultConstructorRRef1(int &&i)
NoDefaultConstructorRRef2(std::unique_ptr< int > &&i)
NoDefaultConstructorRef1(int &i)
NoDefaultConstructorRef2(QString &str, int i)
virtual QSharedPointer< IB > getB() override
virtual QSharedPointer< IB > getB()=0
void customDeleterFn(Data *ptr)
void functionDataByValue(QSharedPointer< Data > p)
void customQObjectDeleterFn(QObject *obj)
void functionDataByRef(const QSharedPointer< Data > &p)
#define QVERIFY_CALLS(expr, base)