diff --git a/kdevplatform/serialization/indexedstring.cpp b/kdevplatform/serialization/indexedstring.cpp
index 73228e2ae3..715aaa7a11 100644
--- a/kdevplatform/serialization/indexedstring.cpp
+++ b/kdevplatform/serialization/indexedstring.cpp
@@ -1,408 +1,408 @@
 /* This file is part of KDevelop
 
    Copyright 2008 David Nolden <david.nolden.kdevelop@art-master.de>
    Copyright 2016 Milian Wolff <mail@milianw.de>
 
    This program is free software; you can redistribute it and/or
    modify it under the terms of the GNU General Public License as
    published by the Free Software Foundation; either version 2 of
    the License, or (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include "indexedstring.h"
 #include "serialization/stringrepository.h"
 
 #include "referencecounting.h"
 
 using namespace KDevelop;
 
 namespace {
 struct IndexedStringData
 {
     unsigned short length;
     uint refCount;
 
     IndexedStringData& operator=(const IndexedStringData& rhs) = delete;
 
     uint itemSize() const
     {
         return sizeof(IndexedStringData) + length;
     }
 
     uint hash() const
     {
         IndexedString::RunningHash running;
         const char* str = (( const char* )this) + sizeof(IndexedStringData);
         for (int a = length - 1; a >= 0; --a) {
             running.append(*str);
             ++str;
         }
 
         return running.hash;
     }
 };
 
 inline void increase(uint& val)
 {
     ++val;
 }
 
 inline void decrease(uint& val)
 {
     --val;
 }
 
 struct IndexedStringRepositoryItemRequest
 {
     //The text is supposed to be utf8 encoded
     IndexedStringRepositoryItemRequest(const char* text, uint hash, unsigned short length)
         : m_hash(hash)
         , m_length(length)
         , m_text(text)
     {
     }
 
     enum {
         AverageSize = 10 //This should be the approximate average size of an Item
     };
 
     using HashType = uint;
 
     //Should return the hash-value associated with this request(For example the hash of a string)
     HashType hash() const
     {
         return m_hash;
     }
 
     //Should return the size of an item created with createItem
     uint itemSize() const
     {
         return sizeof(IndexedStringData) + m_length;
     }
 
     //Should create an item where the information of the requested item is permanently stored. The pointer
     //@param item equals an allocated range with the size of itemSize().
     void createItem(IndexedStringData* item) const
     {
         item->length = m_length;
         item->refCount = 0;
-        ++item;
-        memcpy(item, m_text, m_length);
+        void* itemText = reinterpret_cast<void*>(item + 1);
+        memcpy(itemText, m_text, m_length);
     }
 
     static void destroy(IndexedStringData* item, AbstractItemRepository&)
     {
         Q_UNUSED(item);
         //Nothing to do here (The object is not intelligent)
     }
 
     static bool persistent(const IndexedStringData* item)
     {
         return ( bool )item->refCount;
     }
 
     //Should return whether the here requested item equals the given item
     bool equals(const IndexedStringData* item) const
     {
         return item->length == m_length && (memcmp(++item, m_text, m_length) == 0);
     }
 
     uint m_hash;
     unsigned short m_length;
     const char* m_text;
 };
 
 inline const char* c_strFromItem(const IndexedStringData* item)
 {
     return reinterpret_cast<const char*>(item + 1);
 }
 
 ///@param item must be valid(nonzero)
 inline QString stringFromItem(const IndexedStringData* item)
 {
     return QString::fromUtf8(c_strFromItem(item), item->length);
 }
 
 inline QByteArray arrayFromItem(const IndexedStringData* item)
 {
     return QByteArray(c_strFromItem(item), item->length);
 }
 
 inline bool isSingleCharIndex(uint index)
 {
     return (index & 0xffff0000) == 0xffff0000;
 }
 
 inline uint charToIndex(char c)
 {
     return 0xffff0000 | c;
 }
 
 inline char indexToChar(uint index)
 {
     Q_ASSERT(isSingleCharIndex(index));
     return static_cast<char>(index & 0xff);
 }
 
 using IndexedStringRepository = ItemRepository<IndexedStringData, IndexedStringRepositoryItemRequest, false, false>;
 using IndexedStringRepositoryManagerBase = RepositoryManager<IndexedStringRepository, true, false>;
 class IndexedStringRepositoryManager
     : public IndexedStringRepositoryManagerBase
 {
 public:
     IndexedStringRepositoryManager()
         : IndexedStringRepositoryManagerBase(QStringLiteral("String Index"))
     {
         repository()->setMutex(&m_mutex);
     }
 
 private:
     // non-recursive mutex to increase speed
     QMutex m_mutex;
 };
 
 IndexedStringRepository* globalIndexedStringRepository()
 {
     static IndexedStringRepositoryManager manager;
     return manager.repository();
 }
 
 template <typename ReadAction>
 auto readRepo(ReadAction action)->decltype(action(globalIndexedStringRepository()))
 {
     const auto* repo = globalIndexedStringRepository();
     QMutexLocker lock(repo->mutex());
     return action(repo);
 }
 
 template <typename EditAction>
 auto editRepo(EditAction action)->decltype(action(globalIndexedStringRepository()))
 {
     auto* repo = globalIndexedStringRepository();
     QMutexLocker lock(repo->mutex());
     return action(repo);
 }
 
 inline void ref(IndexedString* string)
 {
     const uint index = string->index();
     if (index && !isSingleCharIndex(index)) {
         if (shouldDoDUChainReferenceCounting(string)) {
             editRepo([index](IndexedStringRepository* repo) {
                     increase(repo->dynamicItemFromIndexSimple(index)->refCount);
                 });
         }
     }
 }
 
 inline void deref(IndexedString* string)
 {
     const uint index = string->index();
     if (index && !isSingleCharIndex(index)) {
         if (shouldDoDUChainReferenceCounting(string)) {
             editRepo([index](IndexedStringRepository* repo) {
                     decrease(repo->dynamicItemFromIndexSimple(index)->refCount);
                 });
         }
     }
 }
 }
 
 IndexedString::IndexedString()
 {
 }
 
 ///@param str must be a utf8 encoded string, does not need to be 0-terminated.
 ///@param length must be its length in bytes.
 IndexedString::IndexedString(const char* str, unsigned short length, uint hash)
 {
     if (!length) {
         m_index = 0;
     } else if (length == 1) {
         m_index = charToIndex(str[0]);
     } else {
         const auto request = IndexedStringRepositoryItemRequest(str, hash ? hash : hashString(str, length), length);
         bool refcount = shouldDoDUChainReferenceCounting(this);
         m_index = editRepo([request, refcount](IndexedStringRepository* repo) {
             auto index = repo->index(request);
             if (refcount) {
                 increase(repo->dynamicItemFromIndexSimple(index)->refCount);
             }
             return index;
         });
     }
 }
 
 IndexedString::IndexedString(char c)
     : m_index(charToIndex(c))
 {}
 
 IndexedString::IndexedString(const QUrl& url)
     : IndexedString(url.isLocalFile() ? url.toLocalFile() : url.toString())
 {
     Q_ASSERT(url.isEmpty() || !url.isRelative());
 #if !defined(QT_NO_DEBUG)
     if (url != url.adjusted(QUrl::NormalizePathSegments)) {
         qWarning() << "wrong url" << url << url.adjusted(QUrl::NormalizePathSegments);
     }
 #endif
     Q_ASSERT(url == url.adjusted(QUrl::NormalizePathSegments));
 }
 
 IndexedString::IndexedString(const QString& string)
     : IndexedString(string.toUtf8())
 {}
 
 IndexedString::IndexedString(const char* str)
     : IndexedString(str, str ? qstrlen(str) : 0)
 {}
 
 IndexedString::IndexedString(const QByteArray& str)
     : IndexedString(str.constData(), str.length())
 {}
 
 IndexedString::~IndexedString()
 {
     deref(this);
 }
 
 IndexedString::IndexedString(const IndexedString& rhs)
     : m_index(rhs.m_index)
 {
     ref(this);
 }
 
 IndexedString& IndexedString::operator=(const IndexedString& rhs)
 {
     if (m_index == rhs.m_index) {
         return *this;
     }
 
     deref(this);
 
     m_index = rhs.m_index;
 
     ref(this);
 
     return *this;
 }
 
 QUrl IndexedString::toUrl() const
 {
     if (isEmpty()) {
         return {};
     }
     QUrl ret = QUrl::fromUserInput(str());
     Q_ASSERT(!ret.isRelative());
     return ret;
 }
 
 QString IndexedString::str() const
 {
     if (!m_index) {
         return QString();
     } else if (isSingleCharIndex(m_index)) {
         return QString(QLatin1Char(indexToChar(m_index)));
     } else {
         const uint index = m_index;
         return readRepo([index](const IndexedStringRepository* repo) {
             return stringFromItem(repo->itemFromIndex(index));
         });
     }
 }
 
 int IndexedString::length() const
 {
     return lengthFromIndex(m_index);
 }
 
 int IndexedString::lengthFromIndex(uint index)
 {
     if (!index) {
         return 0;
     } else if (isSingleCharIndex(index)) {
         return 1;
     } else {
         return readRepo([index](const IndexedStringRepository* repo) {
             return repo->itemFromIndex(index)->length;
         });
     }
 }
 
 const char* IndexedString::c_str() const
 {
     if (!m_index) {
         return nullptr;
     } else if (isSingleCharIndex(m_index)) {
 #if Q_BYTE_ORDER == Q_LITTLE_ENDIAN
         const uint offset = 0;
 #else
         const uint offset = 3;
 #endif
         return reinterpret_cast<const char*>(&m_index) + offset;
     } else {
         const uint index = m_index;
         return readRepo([index](const IndexedStringRepository* repo) {
             return c_strFromItem(repo->itemFromIndex(index));
         });
     }
 }
 
 QByteArray IndexedString::byteArray() const
 {
     if (!m_index) {
         return QByteArray();
     } else if (isSingleCharIndex(m_index)) {
         return QByteArray(1, indexToChar(m_index));
     } else {
         const uint index = m_index;
         return readRepo([index](const IndexedStringRepository* repo) {
             return arrayFromItem(repo->itemFromIndex(index));
         });
     }
 }
 
 uint IndexedString::hashString(const char* str, unsigned short length)
 {
     RunningHash running;
     for (int a = length - 1; a >= 0; --a) {
         running.append(*str);
         ++str;
     }
 
     return running.hash;
 }
 
 uint IndexedString::indexForString(const char* str, short unsigned length, uint hash)
 {
     if (!length) {
         return 0;
     } else if (length == 1) {
         return charToIndex(str[0]);
     } else {
         const auto request = IndexedStringRepositoryItemRequest(str, hash ? hash : hashString(str, length), length);
         return editRepo([request](IndexedStringRepository* repo) {
             return repo->index(request);
         });
     }
 }
 
 uint IndexedString::indexForString(const QString& str, uint hash)
 {
     const QByteArray array(str.toUtf8());
     return indexForString(array.constBegin(), array.size(), hash);
 }
 
 QDebug operator<<(QDebug s, const IndexedString& string)
 {
     s.nospace() << string.str();
     return s.space();
 }
diff --git a/kdevplatform/serialization/stringrepository.h b/kdevplatform/serialization/stringrepository.h
index 817fa2cbea..1466f2d900 100644
--- a/kdevplatform/serialization/stringrepository.h
+++ b/kdevplatform/serialization/stringrepository.h
@@ -1,123 +1,123 @@
 /*
    Copyright 2008 David Nolden <david.nolden.kdevelop@art-master.de>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License version 2 as published by the Free Software Foundation.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
  */
 
 #ifndef KDEVPLATFORM_STRINGREPOSITORY_H
 #define KDEVPLATFORM_STRINGREPOSITORY_H
 
 #include <QString>
 
 #include "itemrepository.h"
 #include "indexedstring.h"
 
 namespace Repositories {
 using namespace KDevelop;
 
 struct StringData
 {
     unsigned short length;
 
     StringData& operator=(const StringData& rhs) = delete;
 
     unsigned int itemSize() const
     {
         return sizeof(StringData) + length;
     }
     unsigned int hash() const
     {
         IndexedString::RunningHash running;
         const char* str = (( const char* )this) + sizeof(StringData);
         for (int a = length - 1; a >= 0; --a) {
             running.append(*str);
             ++str;
         }
 
         return running.hash;
     }
 };
 
 struct StringRepositoryItemRequest
 {
     //The text is supposed to be utf8 encoded
     StringRepositoryItemRequest(const char* text, unsigned int hash, unsigned short length) : m_hash(hash)
         , m_length(length)
         , m_text(text)
     {
     }
 
     enum {
         AverageSize = 10 //This should be the approximate average size of an Item
     };
 
     using HashType = unsigned int;
 
     //Should return the hash-value associated with this request(For example the hash of a string)
     HashType hash() const
     {
         return m_hash;
     }
 
     //Should return the size of an item created with createItem
     uint itemSize() const
     {
         return sizeof(StringData) + m_length;
     }
     //Should create an item where the information of the requested item is permanently stored. The pointer
     //@param item equals an allocated range with the size of itemSize().
     void createItem(StringData* item) const
     {
         item->length = m_length;
-        ++item;
-        memcpy(item, m_text, m_length);
+        void* itemText = reinterpret_cast<void*>(item + 1);
+        memcpy(itemText, m_text, m_length);
     }
 
     static void destroy(StringData*, KDevelop::AbstractItemRepository&)
     {
     }
 
     static bool persistent(const StringData*)
     {
         //Reference-counting not supported in the normal string repository
         return true;
     }
 
     //Should return whether the here requested item equals the given item
     bool equals(const StringData* item) const
     {
         return item->length == m_length && (memcmp(++item, m_text, m_length) == 0);
     }
     unsigned int m_hash;
     unsigned short m_length;
     const char* m_text;
 };
 
 using StringRepository = ItemRepository<StringData, StringRepositoryItemRequest, false, true>;
 
 ///@param item must be valid(nonzero)
 inline QString stringFromItem(const StringData* item)
 {
     const unsigned short* textPos = ( unsigned short* )(item + 1);
     return QString::fromUtf8(( char* )textPos, item->length);
 }
 
 inline QByteArray arrayFromItem(const StringData* item)
 {
     const unsigned short* textPos = ( unsigned short* )(item + 1);
     return QByteArray(( char* )textPos, item->length);
 }
 }
 #endif
diff --git a/kdevplatform/serialization/tests/test_itemrepository.cpp b/kdevplatform/serialization/tests/test_itemrepository.cpp
index e5f6ec17ef..9ef9979928 100644
--- a/kdevplatform/serialization/tests/test_itemrepository.cpp
+++ b/kdevplatform/serialization/tests/test_itemrepository.cpp
@@ -1,394 +1,394 @@
 #include <QObject>
 #include <QTest>
 #include <serialization/itemrepository.h>
 #include <serialization/indexedstring.h>
 #include <stdlib.h>
 #include <time.h>
 
 using namespace KDevelop;
 
 struct TestItem
 {
     TestItem(uint hash, uint dataSize) : m_hash(hash)
         , m_dataSize(dataSize)
     {
     }
 
     TestItem& operator=(const TestItem& rhs) = delete;
 
     //Every item has to implement this function, and return a valid hash.
     //Must be exactly the same hash value as ExampleItemRequest::hash() has returned while creating the item.
     unsigned int hash() const
     {
         return m_hash;
     }
 
     //Every item has to implement this function, and return the complete size this item takes in memory.
     //Must be exactly the same value as ExampleItemRequest::itemSize() has returned while creating the item.
     unsigned int itemSize() const
     {
         return sizeof(TestItem) + m_dataSize;
     }
 
     bool equals(const TestItem* rhs) const
     {
         return rhs->m_hash == m_hash
                && itemSize() == rhs->itemSize()
                && memcmp(( char* )this, rhs, itemSize()) == 0;
     }
 
     uint m_hash;
     uint m_dataSize;
 };
 
 struct TestItemRequest
 {
     TestItem& m_item;
     bool m_compareData;
 
     TestItemRequest(TestItem& item, bool compareData = false)
         : m_item(item)
         , m_compareData(compareData)
     {
     }
     enum {
         AverageSize = 700 //This should be the approximate average size of an Item
     };
 
     uint hash() const
     {
         return m_item.hash();
     }
 
     //Should return the size of an item created with createItem
     size_t itemSize() const
     {
         return m_item.itemSize();
     }
 
     void createItem(TestItem* item) const
     {
-        memcpy(item, &m_item, m_item.itemSize());
+        memcpy(reinterpret_cast<void*>(item), &m_item, m_item.itemSize());
     }
 
     static void destroy(TestItem* /*item*/, AbstractItemRepository&)
     {
         //Nothing to do
     }
 
     static bool persistent(const TestItem* /*item*/)
     {
         return true;
     }
 
     //Should return whether the here requested item equals the given item
     bool equals(const TestItem* item) const
     {
         return hash() == item->hash() && (!m_compareData || m_item.equals(item));
     }
 };
 
 uint smallItemsFraction = 20; //Fraction of items betwen 0 and 1 kb
 uint largeItemsFraction = 1; //Fraction of items between 0 and 200 kb
 uint cycles = 10000;
 uint deletionProbability = 1; //Percentual probability that a checked item is deleted. Per-cycle probability must be multiplied with checksPerCycle.
 uint checksPerCycle = 10;
 
 TestItem* createItem(uint id, uint size)
 {
     TestItem* ret;
     char* data = new char[size];
     uint dataSize = size - sizeof(TestItem);
     ret = new (data) TestItem(id, dataSize);
 
     //Fill in same random pattern
     for (uint a = 0; a < dataSize; ++a)
         data[sizeof(TestItem) + a] = ( char )(a + id);
 
     return ret;
 }
 
 ///@todo Add a test where the complete content is deleted again, and make sure the result has a nice structure
 ///@todo More consistency and lost-space tests, especially about monster-buckets. Make sure their space is re-claimed
 class TestItemRepository
     : public QObject
 {
     Q_OBJECT
 
 private Q_SLOTS:
     void initTestCase()
     {
         ItemRepositoryRegistry::initialize(m_repositoryPath);
     }
     void cleanupTestCase()
     {
         ItemRepositoryRegistry::deleteRepositoryFromDisk(m_repositoryPath);
     }
 
     void testItemRepository()
     {
         ItemRepository<TestItem, TestItemRequest> repository(QStringLiteral("TestItemRepository"));
         uint itemId = 0;
         QHash<uint, TestItem*> realItemsByIndex;
         QHash<uint, TestItem*> realItemsById;
         uint totalInsertions = 0, totalDeletions = 0;
         uint maxSize = 0;
         uint totalSize = 0;
         srand(time(nullptr));
         uint highestSeenIndex = 0;
 
         for (uint a = 0; a < cycles; ++a) {
             {
                 //Insert an item
                 uint itemDecision = rand() % (smallItemsFraction + largeItemsFraction);
                 uint itemSize;
                 if (itemDecision < largeItemsFraction) {
                     //Create a large item: Up to 200kb
                     itemSize = (rand() % 200000) + sizeof(TestItem);
                 } else
                     itemSize = (rand() % 1000) + sizeof(TestItem);
                 TestItem* item = createItem(++itemId, itemSize);
                 Q_ASSERT(item->hash() == itemId);
                 QVERIFY(item->equals(item));
                 uint index = repository.index(TestItemRequest(*item));
                 if (index > highestSeenIndex)
                     highestSeenIndex = index;
                 Q_ASSERT(index);
                 realItemsByIndex.insert(index, item);
                 realItemsById.insert(itemId, item);
                 ++totalInsertions;
                 totalSize += itemSize;
                 if (itemSize > maxSize)
                     maxSize = itemSize;
             }
 
             for (uint a = 0; a < checksPerCycle; ++a) {
                 //Check an item
                 uint pick = rand() % itemId;
                 if (realItemsById.contains(pick)) {
                     uint index = repository.findIndex(*realItemsById[pick]);
                     QVERIFY(index);
                     QVERIFY(realItemsByIndex.contains(index));
                     QVERIFY(realItemsByIndex[index]->equals(repository.itemFromIndex(index)));
 
                     if (( uint ) (rand() % 100) < deletionProbability) {
                         ++totalDeletions;
                         //Delete the item
                         repository.deleteItem(index);
                         QVERIFY(!repository.findIndex(*realItemsById[pick]));
                         uint newIndex = repository.index(*realItemsById[pick]);
                         QVERIFY(newIndex);
                         QVERIFY(realItemsByIndex[index]->equals(repository.itemFromIndex(newIndex)));
 
 #ifdef POSITION_TEST
                         //Since we have previously deleted the item, there must be enough space
                         if (!((newIndex >> 16) <= (highestSeenIndex >> 16))) {
                             qDebug() << "size:" << realItemsById[pick]->itemSize();
                             qDebug() << "previous highest seen bucket:" << (highestSeenIndex >> 16);
                             qDebug() << "new bucket:" << (newIndex >> 16);
                         }
                         QVERIFY((newIndex >> 16) <= (highestSeenIndex >> 16));
 #endif
                         repository.deleteItem(newIndex);
                         QVERIFY(!repository.findIndex(*realItemsById[pick]));
                         delete[] realItemsById[pick];
                         realItemsById.remove(pick);
                         realItemsByIndex.remove(index);
                     }
                 }
             }
         }
 
         // cleanup
         {
             for (auto it = realItemsByIndex.constBegin(); it != realItemsByIndex.constEnd(); ++it) {
                 repository.deleteItem(it.key());
                 delete[] it.value();
             }
 
             realItemsById.clear();
             realItemsByIndex.clear();
         }
 
         qDebug() << "total insertions:" << totalInsertions << "total deletions:" << totalDeletions <<
         "average item size:" << (totalSize / totalInsertions) << "biggest item size:" << maxSize;
 
         ItemRepository<TestItem, TestItemRequest>::Statistics stats = repository.statistics();
         qDebug() << stats;
         QVERIFY(stats.freeUnreachableSpace < stats.freeSpaceInBuckets / 100); // < 1% of the free space is unreachable
         QVERIFY(stats.freeSpaceInBuckets < stats.usedSpaceForBuckets); // < 20% free space
     }
     void testLeaks()
     {
         ItemRepository<TestItem, TestItemRequest> repository(QStringLiteral("TestItemRepository"));
         QList<TestItem*> items;
         for (int i = 0; i < 10000; ++i) {
             TestItem* item = createItem(i, (rand() % 1000) + sizeof(TestItem));
             items << item;
             repository.index(TestItemRequest(*item));
         }
 
         for (auto item : qAsConst(items)) {
             delete[] item;
         }
     }
     void testStringSharing()
     {
         QString qString;
         qString.fill('.', 1000);
         IndexedString indexedString(qString);
         const int repeat = 10000;
         QVector<QString> strings;
         strings.resize(repeat);
         for (int i = 0; i < repeat; ++i) {
             strings[i] = indexedString.str();
             QCOMPARE(qString, strings[i]);
         }
     }
     void deleteClashingMonsterBucket()
     {
         ItemRepository<TestItem, TestItemRequest> repository(QStringLiteral("TestItemRepository"));
         const uint hash = 1235;
 
         QScopedArrayPointer<TestItem> monsterItem(createItem(hash, ItemRepositoryBucketSize + 10));
         QScopedArrayPointer<TestItem> smallItem(createItem(hash, 20));
         QVERIFY(!monsterItem->equals(smallItem.data()));
 
         uint smallIndex = repository.index(TestItemRequest(*smallItem, true));
         uint monsterIndex = repository.index(TestItemRequest(*monsterItem, true));
         QVERIFY(monsterIndex != smallIndex);
 
         repository.deleteItem(smallIndex);
         QVERIFY(!repository.findIndex(TestItemRequest(*smallItem, true)));
         QCOMPARE(monsterIndex, repository.findIndex(TestItemRequest(*monsterItem, true)));
         repository.deleteItem(monsterIndex);
 
         // now in reverse order, with different data see: https://bugs.kde.org/show_bug.cgi?id=272408
 
         monsterItem.reset(createItem(hash + 1, ItemRepositoryBucketSize + 10));
         smallItem.reset(createItem(hash + 1, 20));
         QVERIFY(!monsterItem->equals(smallItem.data()));
         monsterIndex = repository.index(TestItemRequest(*monsterItem, true));
         smallIndex = repository.index(TestItemRequest(*smallItem, true));
 
         repository.deleteItem(monsterIndex);
         QCOMPARE(smallIndex, repository.findIndex(TestItemRequest(*smallItem, true)));
         QVERIFY(!repository.findIndex(TestItemRequest(*monsterItem, true)));
         repository.deleteItem(smallIndex);
     }
     void usePermissiveModuloWhenRemovingClashLinks()
     {
         ItemRepository<TestItem, TestItemRequest> repository(QStringLiteral("PermissiveModulo"));
 
         const uint bucketHashSize = decltype(repository)::bucketHashSize;
         const uint nextBucketHashSize = decltype(repository)::MyBucket::NextBucketHashSize;
         auto bucketNumberForIndex = [](const uint index) {
                                         return index >> 16;
                                     };
 
         const uint clashValue = 2;
 
         // Choose sizes that ensure that the items fit in the desired buckets
         const uint bigItemSize = ItemRepositoryBucketSize * 0.55 - 1;
         const uint smallItemSize = ItemRepositoryBucketSize * 0.25 - 1;
 
         // Will get placed in bucket 1 (bucket zero is invalid), so the root bucket table at position 'clashValue' will be '1'
         const QScopedArrayPointer<TestItem> firstChainFirstLink(createItem(clashValue, bigItemSize));
         const uint firstChainFirstLinkIndex = repository.index(*firstChainFirstLink);
         QCOMPARE(bucketNumberForIndex(firstChainFirstLinkIndex), 1u);
 
         // Will also get placed in bucket 1, so root bucket table at position 'nextBucketHashSize + clashValue' will be '1'
         const QScopedArrayPointer<TestItem> secondChainFirstLink(createItem(nextBucketHashSize + clashValue,
                                                                             smallItemSize));
         const uint secondChainFirstLinkIndex = repository.index(*secondChainFirstLink);
         QCOMPARE(bucketNumberForIndex(secondChainFirstLinkIndex), 1u);
 
         // Will get placed in bucket 2, so bucket 1's next hash table at position 'clashValue' will be '2'
         const QScopedArrayPointer<TestItem> firstChainSecondLink(createItem(bucketHashSize + clashValue, bigItemSize));
         const uint firstChainSecondLinkIndex = repository.index(*firstChainSecondLink);
         QCOMPARE(bucketNumberForIndex(firstChainSecondLinkIndex), 2u);
 
         // Will also get placed in bucket 2, reachable since bucket 1's next hash table at position 'clashValue' is '2'
         const QScopedArrayPointer<TestItem> secondChainSecondLink(createItem(
                 bucketHashSize + nextBucketHashSize + clashValue, smallItemSize));
         const uint secondChainSecondLinkIndex = repository.index(*secondChainSecondLink);
         QCOMPARE(bucketNumberForIndex(secondChainSecondLinkIndex), 2u);
 
         /*
          * At this point we have two chains in the repository, rooted at 'clashValue' and 'nextBucketHashSize + clashValue'
          * Both of the chains start in bucket 1 and end in bucket 2, but both chains share the same link to bucket 2
          * This is because two of the hashes clash the other two when % bucketHashSize, but all of them clash % nextBucketHashSize
          */
 
         repository.deleteItem(firstChainSecondLinkIndex);
 
         /*
          * Now we've deleted the second item in the first chain, this means the first chain no longer requires a link to the
          * second bucket where that item was... but the link must remain, since it's shared (clashed) by the second chain.
          *
          * When cutting a link out of the middle of the chain, we need to check if its items clash using the "permissive"
          * modulus (the size of the /next/ buckets map), which is always a factor of the "stricter" modulus (the size of the
          * /root/ buckets map).
          *
          * This behavior implies that there will sometimes be useless buckets in the bucket chain for a given hash, so when
          * cutting out the root link, it's safe to skip over them to the first clash with the 'stricter' modulus.
          */
 
         // The second item of the second chain must still be reachable
         QCOMPARE(repository.findIndex(*secondChainSecondLink), secondChainSecondLinkIndex);
 
         /*
          * As a memo to anyone who's still reading this, this also means the following situation can exist:
          *
          * bucketHashSize == 8
          * nextBucketHashSize == 4
          * U is a link table
          * B is a bucket
          * [...] are the hashes of the contained items
          *
          * U
          * U
          * U -> B1
          * U
          * U
          * U
          * U -> B2
          * U
          *
          * B0 (Invalid)
          * B1 -> [2, 6]
          *   U
          *   U
          *   U -> B3
          *   U
          * B2 -> [14]
          *   U
          *   U
          *   U -> B1
          *   U
          * B3 -> [10]
          *   U
          *   U
          *   U
          *   U
          *
          * The chain for hash 6 is:
          * Root[6] -> B2[2] -> B1[2] -> B3
          *
          * If you remove the item with hash 6, 6 and 2 will clash with mod 4 (permissive)
          *
          * So the useless link `B2[2] -> B1` will be preserved, even though its useless
          * as the item with hash 2 is reachable directly from the root.
          *
          * So TODO: Don't preserve links to items accessible from root buckets. This cannot
          * be done correctly using only Bucket::hasClashingItem as of now.
          */
     }
 
 private:
     QString m_repositoryPath = QDir::tempPath() + QStringLiteral("/test_itemrepository");
 };
 
 #include "test_itemrepository.moc"
 
 QTEST_MAIN(TestItemRepository)