TEST(fxcrt, WeakPtrNonNull) {
PseudoDeletable thing;
EXPECT_EQ(0, thing.delete_count());
{
UniquePtr unique(&thing);
WeakPtr ptr1(std::move(unique));
EXPECT_TRUE(ptr1);
EXPECT_EQ(&thing, ptr1.Get());
WeakPtr ptr2;
EXPECT_FALSE(ptr1 == ptr2);
EXPECT_TRUE(ptr1 != ptr2);
{
WeakPtr ptr3(ptr1);
EXPECT_TRUE(ptr1 == ptr3);
EXPECT_FALSE(ptr1 != ptr3);
EXPECT_EQ(&thing, ptr3.Get());
{
WeakPtr ptr4 = ptr1;
EXPECT_TRUE(ptr1 == ptr4);
EXPECT_FALSE(ptr1 != ptr4);
EXPECT_EQ(&thing, ptr4.Get());
}
}
EXPECT_EQ(0, thing.delete_count());
}
EXPECT_EQ(1, thing.delete_count());
}
void fit_smart_ptr_tests::test_case_get()
{
auto ptr1 = smart_make_shared<char>(45);
assert(ptr1.get() != nullptr);
fit_smart_ptr<char> ptr2(nullptr);
assert(ptr2.get() == nullptr);
fit_smart_ptr<char> ptr3(nullptr);
assert(ptr3.get() == nullptr);
auto ptr4(ptr1);
assert(ptr4.get() == ptr1.get());
ptr2 = ptr4;
assert(ptr2.get() == ptr4.get() && ptr4.get() == ptr1.get());
ptr3 = ptr1;
assert(ptr3.get() == ptr1.get());
*ptr1 = 123;
assert(ptr3.get() == ptr1.get());
ptr4 = nullptr;
assert(ptr4.get() == nullptr);
ptr3 = fit_smart_ptr<char>(nullptr);
assert(ptr3.get() == nullptr);
ptr1 = ptr2 = ptr3;
assert(ptr1.get() == nullptr);
assert(ptr2.get() == nullptr);
}
void test_uni1()
{
constexpr int value = 101;
my::unique_ptr<int> ptr(value);
if (*ptr == value)
std::cout << "OK ";
else
std::cout << "KO ";
int *i(new int(value + value));
my::unique_ptr<int> ptr2(i);
delete i;
if (*ptr2 == value + value)
std::cout << "OK ";
else
std::cout << "KO ";
my::unique_ptr<int> ptr3(std::move(ptr));
if (*ptr3 == value)
std::cout << "OK ";
else
std::cout << "KO ";
if (!ptr.get())
std::cout << "OK ";
else
std::cout << "KO ";
std::cout << std::endl;
}
void smart_ptr_tests::test_case_get()
{
smart_ptr<char> ptr1(new char(45));
assert(ptr1.get() != nullptr);
smart_ptr<char> ptr2(nullptr);
assert(ptr2.get() == nullptr);
smart_ptr<char> ptr3(nullptr);
assert(ptr3.get() == nullptr);
auto ptr4(ptr1);
assert(ptr4.get() == ptr1.get());
ptr2 = ptr4;
assert(ptr2.get() == ptr4.get() && ptr4.get() == ptr1.get());
ptr3 = ptr1;
assert(ptr3.get() == ptr1.get());
*ptr1 = 123;
assert(ptr3.get() == ptr1.get());
ptr4 = nullptr;
assert(ptr4.get() == nullptr);
ptr3 = smart_ptr<char>(nullptr);
assert(ptr3.get() == nullptr);
ptr1 = ptr2 = ptr3;
assert(ptr1.get() == nullptr);
assert(ptr2.get() == nullptr);
}
void smart_ptr_tests::test_case_comparisions()
{
smart_ptr<char> ptr1(new char(45));
assert(ptr1 != nullptr);
smart_ptr<char> ptr2(nullptr);
assert(ptr2 == nullptr);
smart_ptr<char> ptr3(nullptr);
assert(ptr3 == nullptr);
auto ptr4 = ptr1;
assert(ptr4 == ptr1);
ptr2 = ptr4;
assert(ptr2 == ptr4 && ptr4 == ptr1);
ptr3 = ptr1;
assert(ptr3 == ptr1);
*ptr1 = 123;
assert(ptr3 == ptr1);
ptr4 = nullptr;
assert(ptr4 == nullptr);
ptr3 = smart_ptr<char>(nullptr);
assert(ptr3 == nullptr);
assert(nullptr != ptr1);
ptr1 = ptr2 = ptr3;
assert(ptr1 == nullptr);
assert(ptr2 == nullptr);
assert(nullptr == ptr1);
}
void smart_ptr_tests::test_case_copy_and_assignment()
{
smart_ptr<char> ptr1(new char(45));
assert(*ptr1 == 45);
smart_ptr<char> ptr2(nullptr);
smart_ptr<char> ptr3(nullptr);
auto ptr4(ptr1);
assert(*ptr4 == 45);
ptr2 = ptr4;
assert(*ptr2 == 45);
ptr3 = ptr1;
assert(*ptr3 == 45);
*ptr1 = 123;
assert(*ptr2 == 123);
ptr3 = ptr1;
assert(*ptr3 == 123);
// nullptr is r-value so move operator=
ptr4 = smart_ptr<char>(nullptr);
ptr4 = nullptr;
ptr3 = smart_ptr<char>(nullptr);
ptr1 = ptr2 = ptr3;
smart_ptr<const char> ptr5(new char(12));
ptr5 = ptr5 = ptr5;
assert(*ptr5 == 12);
}
void fit_smart_ptr_tests::test_case_comparisions()
{
auto ptr1 = smart_make_shared<char>(45);
assert(ptr1 != nullptr);
fit_smart_ptr<char> ptr2(nullptr);
assert(ptr2 == nullptr);
fit_smart_ptr<char> ptr3(nullptr);
assert(ptr3 == nullptr);
auto ptr4 = ptr1;
assert(ptr4 == ptr1);
ptr2 = ptr4;
assert(ptr2 == ptr4 && ptr4 == ptr1);
ptr3 = ptr1;
assert(ptr3 == ptr1);
*ptr1 = 123;
assert(ptr3 == ptr1);
ptr4 = nullptr;
assert(ptr4 == nullptr);
ptr3 = fit_smart_ptr<char>(nullptr);
assert(ptr3 == nullptr);
assert(nullptr != ptr1);
ptr1 = ptr2 = ptr3;
assert(ptr1 == nullptr);
assert(ptr2 == nullptr);
assert(nullptr == ptr1);
}
void fit_smart_ptr_tests::test_case_copy_and_assignment()
{
auto ptr1 = smart_make_shared<char>(45);
assert(*ptr1 == 45);
assert(ptr1.use_count() == 1);
fit_smart_ptr<char> ptr2(nullptr);
fit_smart_ptr<char> ptr3(nullptr);
auto ptr4(ptr1);
assert(*ptr4 == 45);
assert(ptr4.use_count() == 2);
assert(ptr1.use_count() == 2);
ptr2 = ptr4;
assert(*ptr2 == 45);
ptr3 = ptr1;
assert(*ptr3 == 45);
*ptr1 = 123;
assert(*ptr2 == 123);
ptr3 = ptr1;
assert(*ptr3 == 123);
// nullptr is r-value so move operator=
ptr4 = fit_smart_ptr<char>(nullptr);
ptr4 = nullptr;
ptr3 = fit_smart_ptr<char>(nullptr);
ptr1 = ptr2 = ptr3;
fit_smart_ptr<char> ptr5 = smart_make_shared<char>(12);
ptr5 = ptr5 = ptr5;
assert(*ptr5 == 12);
}
void testObj::test<10>(void)
{
PointerWrapper< boost::shared_ptr<Data> > ptr(sp_);
PointerWrapper< boost::shared_ptr<Data> > ptr1(ptr);
PointerWrapper< boost::shared_ptr<const Data> > ptr2(ptr);
PointerWrapper<Data*> ptr3(ptr);
PointerWrapper<const Data*> ptr4(ptr);
}
int main(int argc, char **argv) {
HasPtr ptr1("good");
HasPtr ptr2 = ptr1;
HasPtr ptr3("terrible");
std::string* str2 = new std::string("happy");
ptr2.setPs(str2);
ptr1 = ptr3;
ptr1.print();
ptr2.print();
return 0;
}
void testObj::test<9>(void)
{
PointerWrapper< Commons::SharedPtrNotNULL<Data> > ptr(spnn_);
PointerWrapper< Commons::SharedPtrNotNULL<Data> > ptr1(ptr);
PointerWrapper< Commons::SharedPtrNotNULL<const Data> > ptr2(ptr);
PointerWrapper< boost::shared_ptr<Data> > ptr3(ptr);
PointerWrapper< boost::shared_ptr<const Data> > ptr4(ptr);
PointerWrapper<Data*> ptr5(ptr);
PointerWrapper<const Data*> ptr6(ptr);
}
void smart_ptr_tests::test_case_use_count()
{
smart_ptr<char> ptr1(new char(45));
assert(ptr1.use_count() == 1);
smart_ptr<char> ptr2(nullptr);
smart_ptr<char> ptr3(nullptr);
auto ptr4(ptr1);
assert(ptr4.use_count() == 2);
assert(ptr3.use_count() == 0);
assert(ptr2.use_count() == 0);
assert(ptr1.use_count() == 2);
ptr2 = ptr4;
assert(ptr4.use_count() == 3);
assert(ptr3.use_count() == 0);
assert(ptr2.use_count() == 3);
assert(ptr1.use_count() == 3);
ptr3 = ptr1;
assert(ptr3.use_count() == 4);
assert(ptr4.use_count() == 4);
assert(ptr2.use_count() == 4);
assert(ptr1.use_count() == 4);
*ptr1 = 123;
assert(ptr3.use_count() == 4);
assert(ptr4.use_count() == 4);
assert(ptr2.use_count() == 4);
assert(ptr1.use_count() == 4);
// testing overloading for nullptr
ptr4 = nullptr;
assert(ptr4.use_count() == 0);
assert(ptr3.use_count() == 3);
assert(ptr2.use_count() == 3);
assert(ptr1.use_count() == 3);
// NULL is r-value so move operator=
ptr3 = smart_ptr<char>(nullptr);
assert(ptr4.use_count() == 0);
assert(ptr3.use_count() == 0);
assert(ptr2.use_count() == 2);
assert(ptr1.use_count() == 2);
ptr1 = ptr2 = ptr3;
assert(ptr4.use_count() == 0);
assert(ptr3.use_count() == 0);
assert(ptr2.use_count() == 0);
assert(ptr1.use_count() == 0);
}
TEST(fxcrt, WeakPtrNull) {
WeakPtr ptr1;
EXPECT_FALSE(ptr1);
WeakPtr ptr2;
EXPECT_TRUE(ptr1 == ptr2);
EXPECT_FALSE(ptr1 != ptr2);
WeakPtr ptr3(ptr1);
EXPECT_TRUE(ptr1 == ptr3);
EXPECT_FALSE(ptr1 != ptr3);
WeakPtr ptr4 = ptr1;
EXPECT_TRUE(ptr1 == ptr4);
EXPECT_FALSE(ptr1 != ptr4);
}
// Test the gmGCRoot system
void TestGMGCRoot()
{
gmGCRootManager::Init(); // Init system
{
gmMachine machine1;
gmGCRoot<gmStringObject> ptr1;
gmStringObject* stringObj1 = machine1.AllocStringObject("hello");
ptr1.Set(stringObj1, &machine1); // Initialize via func
gmStringObject* nat1 = ptr1; // Assign pointer
gmGCRoot<gmStringObject> ptr2;
ptr2 = ptr1;
ptr1 = NULL; // Assign to null
ptr2 = NULL;
//ptr2 = nat1; // ERROR
gmStringObject* stringObj2 = machine1.AllocStringObject("apple");
gmGCRoot<gmStringObject> ptr3(stringObj2, &machine1); // Initialize via constructor
gmGCRoot<gmStringObject> ptr4(stringObj2, &machine1); // Duplicate without copy
gmGCRoot<gmStringObject> ptr5;
{
gmMachine machine2;
gmStringObject* stringObj3 = machine2.AllocStringObject("bannana");
ptr5.Set(stringObj3, &machine2);
gmGCRootManager::Get()->DestroyMachine(&machine2); // Null associated pointers
}
if( ptr5 )
{
int i=1; // Won't get here
}
}
gmGCRootManager::Destroy();
}
/** \brief function to test a ptr_t
*/
nunit_res_t ptr_testclass_t::ptr_cow(const nunit_testclass_ftor_t &testclass_ftor) throw()
{
// log to debug
KLOG_DBG("enter");
// create a ptr_cow_t
const ptr_cow_t<std::string> ptr1(nipmem_new std::string("hello world."));
// run some check on ptr1
NUNIT_ASSERT( ptr1.get_ptr() != NULL );
NUNIT_ASSERT( ptr1.count() == 1 );
NUNIT_ASSERT( *ptr1 == "hello world." );
// copy the ptr1 into const ptr2 INSIDE bracket to ctor/dtor
{
const ptr_cow_t<std::string> ptr2(ptr1);
// run some check on ptr2
NUNIT_ASSERT( ptr2.get_ptr() == ptr1.get_ptr() );
NUNIT_ASSERT( *ptr2 == "hello world." );
// as ptr2 is const, using it doesnt trigger the copy-on-write
NUNIT_ASSERT( ptr1.count() == 2 );
NUNIT_ASSERT( ptr2.count() == 2 );
}
// copy the ptr1 into ptr3 INSIDE bracket to ctor/dtor
{
ptr_cow_t<std::string> ptr3(ptr1);
// at this point, ptr3 is still shared with ptr1
NUNIT_ASSERT( ptr1.count() == 2 );
NUNIT_ASSERT( ptr3.count() == 2 );
// this trigger the usage of ptr3, as it is non const, it trigger the copy on write too
NUNIT_ASSERT( *ptr3 == "hello world." );
NUNIT_ASSERT( ptr1.count() == 1 );
NUNIT_ASSERT( ptr3.count() == 1 );
}
// return no error
return NUNIT_RES_OK;
}
TEST(fxcrt, MaybeOwnedMove) {
int delete_count = 0;
PseudoDeletable thing1(100, &delete_count);
{
CFX_MaybeOwned<PseudoDeletable> ptr1(&thing1);
CFX_MaybeOwned<PseudoDeletable> ptr2(
pdfium::MakeUnique<PseudoDeletable>(200, &delete_count));
EXPECT_FALSE(ptr1.IsOwned());
EXPECT_TRUE(ptr2.IsOwned());
CFX_MaybeOwned<PseudoDeletable> ptr3(std::move(ptr1));
CFX_MaybeOwned<PseudoDeletable> ptr4(std::move(ptr2));
EXPECT_FALSE(ptr1.IsOwned());
EXPECT_FALSE(ptr2.IsOwned());
EXPECT_FALSE(ptr3.IsOwned());
EXPECT_TRUE(ptr4.IsOwned());
EXPECT_EQ(0, delete_count);
EXPECT_EQ(nullptr, ptr1.Get());
EXPECT_EQ(nullptr, ptr2.Get());
EXPECT_EQ(100, ptr3->GetID());
EXPECT_EQ(200, ptr4->GetID());
CFX_MaybeOwned<PseudoDeletable> ptr5;
CFX_MaybeOwned<PseudoDeletable> ptr6;
ptr5 = std::move(ptr3);
ptr6 = std::move(ptr4);
EXPECT_FALSE(ptr3.IsOwned());
EXPECT_FALSE(ptr4.IsOwned());
EXPECT_FALSE(ptr5.IsOwned());
EXPECT_TRUE(ptr6.IsOwned());
EXPECT_EQ(0, delete_count);
EXPECT_EQ(nullptr, ptr3.Get());
EXPECT_EQ(nullptr, ptr4.Get());
EXPECT_EQ(100, ptr5->GetID());
EXPECT_EQ(200, ptr6->GetID());
}
EXPECT_EQ(1, delete_count);
}
FourTree::FourTree(int maxObjects, int maxLevels, sf::FloatRect bounds, int currentLevel)
:mMaxLevels(maxLevels),
mMaxObjects(maxObjects),
mBounds(bounds),
mCurrentLevel(currentLevel),
isSpilt(false),
mWorldLocation(0.f, 0.f)
{
for (int i = 0; i < LocationCount; i++)
mNodes[i] = NULL;
if (mCurrentLevel < mMaxLevels){
float subWidth = mBounds.width / 2;
float subHeight = mBounds.height / 2;
float x = mBounds.left;
float y = mBounds.top;
//top right
FourTree::Ptr ptr1(new FourTree(maxObjects, maxLevels,
sf::FloatRect(x + subWidth, y, subWidth, subHeight), mCurrentLevel + 1));
//top left
FourTree::Ptr ptr2(new FourTree(maxObjects, maxLevels,
sf::FloatRect(x, y, subWidth, subHeight), mCurrentLevel + 1));
//bottom left
FourTree::Ptr ptr3(new FourTree(maxObjects, maxLevels,
sf::FloatRect(x, y + subHeight, subWidth, subHeight), mCurrentLevel + 1));
//bottom right
FourTree::Ptr ptr4(new FourTree(maxObjects, maxLevels,
sf::FloatRect(x + subWidth, y + subHeight, subWidth, subHeight), mCurrentLevel + 1));
mNodes[Top_Right] = std::move(ptr1);
mNodes[Top_Left] = std::move(ptr2);
mNodes[Bottom_Left] = std::move(ptr3);
mNodes[Bottom_Right] = std::move(ptr4);
}
}
void TestPtr()
{
bool b = false;
// конструкторы
{
Ptr<set_bool> ptr1;
Ptr<set_bool> ptr2((set_bool*)0);
Ptr<set_bool> ptr3(new set_bool(b));
BOOST_CHECK( b );
}
BOOST_CHECK( !b );
// get(), operator =
{
Ptr<set_bool> ptr;
BOOST_CHECK( !ptr.get() );
set_bool* p_sb = new set_bool(b);
ptr = p_sb;
BOOST_CHECK( ptr.get() == p_sb );
BOOST_CHECK( b );
Ptr<set_bool> new_ptr(ptr);
BOOST_CHECK( new_ptr.get() == p_sb );
BOOST_CHECK( b );
}
BOOST_CHECK( !b );
// reset()
{
Ptr<set_bool> ptr(new set_bool(b));
ptr.reset((set_bool*)0);
BOOST_CHECK( !b );
ptr.reset( new set_bool(b) );
BOOST_CHECK( b );
}
// if( ptr )
// operator *
{
Ptr<int> ptr;
if( ptr )
BOOST_CHECK( false );
int* p_int = new int(5);
ptr = p_int;
if( ptr )
BOOST_CHECK( true );
BOOST_CHECK( 5 == *ptr );
}
// operator ->
{
typedef std::pair<int, int> iint;
Ptr<iint> pair_ptr(new iint(1,2));
BOOST_CHECK( pair_ptr->first == 1 );
BOOST_CHECK( pair_ptr->second == 2 );
}
}
void tst_QSharedPointer::customDeleter()
{
{
QSharedPointer<Data> ptr(new Data, &Data::doDelete);
QSharedPointer<Data> ptr2(new Data, &Data::alsoDelete);
QSharedPointer<Data> ptr3(new Data, &Data::virtualDelete);
}
{
QSharedPointer<DerivedData> ptr(new DerivedData, &Data::doDelete);
QSharedPointer<DerivedData> ptr2(new DerivedData, &Data::alsoDelete);
QSharedPointer<DerivedData> ptr3(new DerivedData, &Data::virtualDelete);
}
customDeleterFnCallCount = 0;
{
QSharedPointer<Data> ptr = QSharedPointer<Data>(new Data, customDeleterFn);
ptr.data();
QCOMPARE(customDeleterFnCallCount, 0);
}
QCOMPARE(customDeleterFnCallCount, 1);
customDeleterFnCallCount = 0;
{
QSharedPointer<Data> ptr = QSharedPointer<Data>(new Data, customDeleterFn);
QCOMPARE(customDeleterFnCallCount, 0);
ptr.clear();
QCOMPARE(customDeleterFnCallCount, 1);
}
QCOMPARE(customDeleterFnCallCount, 1);
customDeleterFnCallCount = 0;
{
QSharedPointer<Data> ptr = QSharedPointer<Data>(new Data, customDeleterFn);
QCOMPARE(customDeleterFnCallCount, 0);
ptr = QSharedPointer<Data>(new Data);
QCOMPARE(customDeleterFnCallCount, 1);
}
QCOMPARE(customDeleterFnCallCount, 1);
customDeleterFnCallCount = 0;
{
QSharedPointer<Data> ptr = QSharedPointer<Data>(new DerivedData, customDeleterFn);
ptr.data();
QCOMPARE(customDeleterFnCallCount, 0);
}
QCOMPARE(customDeleterFnCallCount, 1);
customDeleterFnCallCount = 0;
{
QSharedPointer<DerivedData> ptr = QSharedPointer<DerivedData>(new DerivedData, customDeleterFn);
ptr.data();
QCOMPARE(customDeleterFnCallCount, 0);
}
QCOMPARE(customDeleterFnCallCount, 1);
customDeleterFnCallCount = 0;
{
QSharedPointer<Data> other;
{
QSharedPointer<Data> ptr = QSharedPointer<Data>(new Data, customDeleterFn);
other = ptr;
QCOMPARE(customDeleterFnCallCount, 0);
}
QCOMPARE(customDeleterFnCallCount, 0);
}
QCOMPARE(customDeleterFnCallCount, 1);
customDeleterFnCallCount = 0;
{
QSharedPointer<Data> other;
{
QSharedPointer<DerivedData> ptr = QSharedPointer<DerivedData>(new DerivedData, customDeleterFn);
other = ptr;
QCOMPARE(customDeleterFnCallCount, 0);
}
QCOMPARE(customDeleterFnCallCount, 0);
}
QCOMPARE(customDeleterFnCallCount, 1);
CustomDeleter<Data> dataDeleter;
dataDeleter.callCount = 0;
{
QSharedPointer<Data> ptr = QSharedPointer<Data>(new Data, dataDeleter);
ptr.data();
QCOMPARE(dataDeleter.callCount, 0);
}
QCOMPARE(dataDeleter.callCount, 1);
dataDeleter.callCount = 0;
{
QSharedPointer<Data> ptr = QSharedPointer<Data>(new Data, dataDeleter);
QSharedPointer<Data> other = ptr;
other.clear();
QCOMPARE(dataDeleter.callCount, 0);
}
QCOMPARE(dataDeleter.callCount, 1);
dataDeleter.callCount = 0;
{
QSharedPointer<Data> other;
{
QSharedPointer<Data> ptr = QSharedPointer<Data>(new Data, dataDeleter);
other = ptr;
QCOMPARE(dataDeleter.callCount, 0);
}
QCOMPARE(dataDeleter.callCount, 0);
}
QCOMPARE(dataDeleter.callCount, 1);
dataDeleter.callCount = 0;
{
QSharedPointer<DerivedData> ptr = QSharedPointer<DerivedData>(new DerivedData, dataDeleter);
ptr.data();
QCOMPARE(dataDeleter.callCount, 0);
}
QCOMPARE(dataDeleter.callCount, 1);
CustomDeleter<DerivedData> derivedDataDeleter;
derivedDataDeleter.callCount = 0;
dataDeleter.callCount = 0;
{
QSharedPointer<DerivedData> ptr = QSharedPointer<DerivedData>(new DerivedData, derivedDataDeleter);
ptr.data();
QCOMPARE(dataDeleter.callCount, 0);
QCOMPARE(derivedDataDeleter.callCount, 0);
}
QCOMPARE(dataDeleter.callCount, 0);
QCOMPARE(derivedDataDeleter.callCount, 1);
derivedDataDeleter.callCount = 0;
dataDeleter.callCount = 0;
{
QSharedPointer<Data> other;
{
QSharedPointer<DerivedData> ptr = QSharedPointer<DerivedData>(new DerivedData, dataDeleter);
other = ptr;
QCOMPARE(dataDeleter.callCount, 0);
QCOMPARE(derivedDataDeleter.callCount, 0);
}
QCOMPARE(dataDeleter.callCount, 0);
QCOMPARE(derivedDataDeleter.callCount, 0);
}
QCOMPARE(dataDeleter.callCount, 1);
QCOMPARE(derivedDataDeleter.callCount, 0);
derivedDataDeleter.callCount = 0;
dataDeleter.callCount = 0;
{
QSharedPointer<Data> other;
{
QSharedPointer<DerivedData> ptr = QSharedPointer<DerivedData>(new DerivedData, derivedDataDeleter);
other = ptr;
QCOMPARE(dataDeleter.callCount, 0);
QCOMPARE(derivedDataDeleter.callCount, 0);
}
QCOMPARE(dataDeleter.callCount, 0);
QCOMPARE(derivedDataDeleter.callCount, 0);
}
QCOMPARE(dataDeleter.callCount, 0);
QCOMPARE(derivedDataDeleter.callCount, 1);
}
