QResourcesManager unit test completed

Change-Id: I3fbf2f71d2ef35d0f0cbe6ac2c8d1f539a6c0de7
Reviewed-by: Sean Harmer <sean.harmer@kdab.com>

3 files changed, 411 insertions, 7 deletions

diff --git a/tests/auto/core/arrayresourcesmanager/tst_arrayresourcesmanager.cpp b/tests/auto/core/arrayresourcesmanager/tst_arrayresourcesmanager.cpp
index 981d05e60..e57be5746 100644
--- a/tests/auto/core/arrayresourcesmanager/tst_arrayresourcesmanager.cpp
+++ b/tests/auto/core/arrayresourcesmanager/tst_arrayresourcesmanager.cpp
@@ -59,6 +59,10 @@ private slots:
     void removeResource();
     void resetResource();
     void lookupResource();
+    void releaseResource();
+    void heavyDutyMultiThreadedAccess();
+    void heavyDutyMultiThreadedAccessRelease();
+    void maximumNumberOfResources();
 };
 
 class tst_ArrayResource
@@ -80,9 +84,9 @@ void tst_ArrayResourcesManager::createResourcesManager()
     Qt3D::QResourcesManager<tst_ArrayResource, int, 16> manager16;
     Qt3D::QResourcesManager<tst_ArrayResource, int, 4> manager4;
     Qt3D::QResourcesManager<tst_ArrayResource, int, 8> manager8;
-    QVERIFY(manager16.maxResourcesEntries() == 65536);
-    QVERIFY(manager8.maxResourcesEntries() == 256);
-    QVERIFY(manager4.maxResourcesEntries() == 16);
+    QVERIFY(manager16.maxResourcesEntries() == 65535);
+    QVERIFY(manager8.maxResourcesEntries() == 255);
+    QVERIFY(manager4.maxResourcesEntries() == 15);
 }
 
 /*!
@@ -183,7 +187,7 @@ void tst_ArrayResourcesManager::removeResource()
     manager.release(handles.at(2));
     QVERIFY(manager.data(handles.at(2)) == Q_NULLPTR);
     // Triggers QASSERT so commented
-//    manager.release(handles.at(2));
+    //    manager.release(handles.at(2));
 
     tHandle nHandle = manager.acquire();
     QVERIFY(manager.data(nHandle) != Q_NULLPTR);
@@ -244,6 +248,193 @@ void tst_ArrayResourcesManager::lookupResource()
     QVERIFY(manager.data(t) == resource);
 }
 
+void tst_ArrayResourcesManager::releaseResource()
+{
+    Qt3D::QResourcesManager<tst_ArrayResource, uint> manager;
+    QList<tst_ArrayResource *> resources;
+
+    for (int i = 0; i < 5; i++) {
+        resources << manager.getOrCreateResource(i);
+    }
+
+    for (int i = 0; i < 5; i++) {
+        QVERIFY(resources.at(i) == manager.lookupResource(i));
+    }
+
+    for (int i = 0; i < 5; i++) {
+        manager.releaseResource(i);
+        QVERIFY(manager.lookupResource(i) == Q_NULLPTR);
+    }
+}
+
+class tst_Thread : public QThread
+{
+    Q_OBJECT
+public:
+
+    typedef Qt3D::QResourcesManager<tst_ArrayResource,
+    int,
+    16,
+    Qt3D::ArrayAllocatingPolicy,
+    Qt3D::ObjectLevelLockingPolicy> Manager;
+
+    tst_Thread()
+        : QThread()
+    {
+    }
+
+    void setManager(Manager *manager)
+    {
+        m_manager = manager;
+    }
+
+    // QThread interface
+protected:
+    void run()
+    {
+        int i = 0;
+        int max = tHandle::maxIndex();
+        while (i < max) {
+            tst_ArrayResource *r = m_manager->getOrCreateResource(i);
+            i++;
+            QVERIFY(r != Q_NULLPTR);
+            Manager::WriteLocker lock(m_manager);
+            r->m_value++;
+        }
+        qDebug() << QThread::currentThread() << "Done";
+    }
+
+    Manager *m_manager;
+};
+
+void tst_ArrayResourcesManager::heavyDutyMultiThreadedAccess()
+{
+    tst_Thread::Manager *manager = new tst_Thread::Manager();
+
+    QList<tst_Thread *> threads;
+
+    int iterations = 8;
+    int max = tHandle16::maxIndex();
+
+    for (int i = 0; i < iterations; i++) {
+        tst_Thread *thread = new tst_Thread();
+        thread->setManager(manager);
+        threads << thread;
+    }
+
+    for (int i = 0; i < iterations; i++) {
+        threads[i]->start();
+    }
+
+    for (int i = 0; i < iterations; i++) {
+        threads[i]->wait();
+    }
+
+    for (int i = 0; i < max; i++) {
+        QVERIFY(manager->lookupResource(i) != Q_NULLPTR);
+        QVERIFY(manager->lookupResource(i)->m_value = iterations);
+    }
+
+    qDeleteAll(threads);
+    delete manager;
+}
+
+class tst_Thread2 : public QThread
+{
+    Q_OBJECT
+public:
+
+    typedef Qt3D::QResourcesManager<tst_ArrayResource,
+    int,
+    16,
+    Qt3D::ArrayAllocatingPolicy,
+    Qt3D::ObjectLevelLockingPolicy> Manager;
+
+    tst_Thread2(int releaseAbove = 7)
+        : QThread()
+        , m_releaseAbove(releaseAbove)
+    {
+    }
+
+    void setManager(Manager *manager)
+    {
+        m_manager = manager;
+    }
+
+    // QThread interface
+protected:
+    void run()
+    {
+        int i = 0;
+        int max = tHandle::maxIndex();
+        while (i < max) {
+            tst_ArrayResource *r = m_manager->getOrCreateResource(i);
+            QVERIFY(r != Q_NULLPTR);
+            Manager::WriteLocker lock(m_manager);
+            r->m_value++;
+            if (r->m_value > m_releaseAbove)
+                m_manager->releaseResource(i);
+            i++;
+        }
+        qDebug() << QThread::currentThread() << "Done";
+    }
+
+    Manager *m_manager;
+    int m_releaseAbove;
+};
+
+void tst_ArrayResourcesManager::heavyDutyMultiThreadedAccessRelease()
+{
+    tst_Thread2::Manager *manager = new tst_Thread2::Manager();
+
+    QList<tst_Thread2 *> threads;
+
+    int iterations = 8;
+    int max = tHandle16::maxIndex();
+
+    for (int u = 0; u < 2; u++) {
+
+        for (int i = 0; i < iterations; i++) {
+            tst_Thread2 *thread = new tst_Thread2();
+            thread->setManager(manager);
+            threads << thread;
+        }
+
+        for (int i = 0; i < iterations; i++) {
+            threads[i]->start();
+        }
+
+        for (int i = 0; i < iterations; i++) {
+            threads[i]->wait();
+        }
+
+        for (int i = 0; i < max; i++) {
+            QVERIFY(manager->lookupResource(i) == Q_NULLPTR);
+        }
+
+        qDeleteAll(threads);
+        threads.clear();
+    }
+
+    delete manager;
+}
+
+void tst_ArrayResourcesManager::maximumNumberOfResources()
+{
+    Qt3D::QResourcesManager<tst_ArrayResource, uint> manager;
+
+    QList<tst_ArrayResource *> resources;
+    QList<tHandle16> handles;
+
+    QCOMPARE(tHandle16::maxIndex(), (uint)manager.maxResourcesEntries());
+
+    for (int i = 0; i < manager.maxResourcesEntries(); i++) {
+        handles << manager.acquire();
+        resources << manager.data(handles.at(i));
+        resources.at(i)->m_value = 4;
+    }
+}
+
 QTEST_APPLESS_MAIN(tst_ArrayResourcesManager)
 
 #include "tst_arrayresourcesmanager.moc"
diff --git a/tests/auto/core/handlemanager/tst_handlemanager.cpp b/tests/auto/core/handlemanager/tst_handlemanager.cpp
index 8d603b6ab..b96949ae6 100644
--- a/tests/auto/core/handlemanager/tst_handlemanager.cpp
+++ b/tests/auto/core/handlemanager/tst_handlemanager.cpp
@@ -59,6 +59,7 @@ private slots:
     void validHandleForReplacementEntry();
     void updateChangesValue();
     void resetRemovesAllEntries();
+    void maximumEntries();
 };
 
 class SimpleResource
@@ -192,6 +193,27 @@ void tst_HandleManager::resetRemovesAllEntries()
     QVERIFY(manager.activeEntries() == 0);
 }
 
+void tst_HandleManager::maximumEntries()
+{
+    Qt3D::QHandleManager<SimpleResource> manager;
+
+    QCOMPARE(Handle::maxIndex(), (uint)((1 << 16) - 1));
+
+    for (int i = 0; i < (int)Handle::maxIndex(); ++i) {
+        SimpleResource *p = (SimpleResource *) 0xdead0000 + i;
+        const Handle h = manager.acquire(p);
+
+        bool ok = false;
+        SimpleResource *q = manager.data(h, &ok);
+        QVERIFY(ok == true);
+        QVERIFY(p == q);
+    }
+
+    QVERIFY(manager.activeEntries() == Handle::maxIndex());
+    manager.reset();
+    QVERIFY(manager.activeEntries() == 0);
+}
+
 QTEST_APPLESS_MAIN(tst_HandleManager)
 
 #include "tst_handlemanager.moc"
diff --git a/tests/auto/core/listresourcesmanager/tst_listresourcesmanager.cpp b/tests/auto/core/listresourcesmanager/tst_listresourcesmanager.cpp
index 1fe80eee2..b5bee9b88 100644
--- a/tests/auto/core/listresourcesmanager/tst_listresourcesmanager.cpp
+++ b/tests/auto/core/listresourcesmanager/tst_listresourcesmanager.cpp
@@ -59,6 +59,10 @@ private slots:
     void removeResource();
     void resetResource();
     void lookupResource();
+    void releaseResource();
+    void heavyDutyMultiThreadedAccess();
+    void heavyDutyMultiThreadedAccessRelease();
+    void maximumNumberOfResources();
 };
 
 class tst_ListResource
@@ -81,9 +85,9 @@ void tst_ListResourcesManager::createResourcesManager()
     Qt3D::QResourcesManager<tst_ListResource, int, 4, Qt3D::ListAllocatingPolicy> manager4;
     Qt3D::QResourcesManager<tst_ListResource, int, 8, Qt3D::ListAllocatingPolicy> manager8;
 
-    QVERIFY(manager16.maxResourcesEntries() == 65536);
-    QVERIFY(manager8.maxResourcesEntries() == 256);
-    QVERIFY(manager4.maxResourcesEntries() == 16);
+    QVERIFY(manager16.maxResourcesEntries() == 65535);
+    QVERIFY(manager8.maxResourcesEntries() == 255);
+    QVERIFY(manager4.maxResourcesEntries() == 15);
 }
 
 /*!
@@ -245,6 +249,193 @@ void tst_ListResourcesManager::lookupResource()
     QVERIFY(manager.data(t) == resource);
 }
 
+void tst_ListResourcesManager::releaseResource()
+{
+    Qt3D::QResourcesManager<tst_ListResource, uint, 16, Qt3D::ListAllocatingPolicy> manager;
+    QList<tst_ListResource *> resources;
+
+    for (int i = 0; i < 5; i++) {
+        resources << manager.getOrCreateResource(i);
+    }
+
+    for (int i = 0; i < 5; i++) {
+        QVERIFY(resources.at(i) == manager.lookupResource(i));
+    }
+
+    for (int i = 0; i < 5; i++) {
+        manager.releaseResource(i);
+        QVERIFY(manager.lookupResource(i) == Q_NULLPTR);
+    }
+}
+
+class tst_Thread : public QThread
+{
+    Q_OBJECT
+public:
+
+    typedef Qt3D::QResourcesManager<tst_ListResource,
+                            int,
+                            16,
+                            Qt3D::ListAllocatingPolicy,
+                            Qt3D::ObjectLevelLockingPolicy> Manager;
+
+    tst_Thread() : QThread()
+    {
+    }
+
+    void setManager(Manager *manager)
+    {
+        m_manager = manager;
+    }
+
+    // QThread interface
+protected:
+    void run()
+    {
+        int i = 0;
+        int max = tHandle16::maxIndex();
+        while (i < max) {
+            tst_ListResource *r = m_manager->getOrCreateResource(i);
+            i++;
+            QVERIFY(r != Q_NULLPTR);
+            Manager::WriteLocker lock(m_manager);
+            r->m_value++;
+        }
+        qDebug() << QThread::currentThread() << "Done";
+    }
+
+    Manager *m_manager;
+};
+
+
+void tst_ListResourcesManager::heavyDutyMultiThreadedAccess()
+{
+    tst_Thread::Manager *manager = new tst_Thread::Manager();
+
+    QList<tst_Thread *> threads;
+
+    int iterations = 8;
+    int max = tHandle16::maxIndex();
+
+    for (int i = 0; i < iterations; i++) {
+        tst_Thread *thread = new tst_Thread();
+        thread->setManager(manager);
+        threads << thread;
+    }
+
+    for (int i = 0; i < iterations; i++) {
+        threads[i]->start();
+    }
+
+    for (int i = 0; i < iterations; i++) {
+        threads[i]->wait();
+    }
+
+    for (int i = 0; i < max; i++) {
+        QVERIFY(manager->lookupResource(i) != Q_NULLPTR);
+        QVERIFY(manager->lookupResource(i)->m_value = iterations);
+    }
+
+    qDeleteAll(threads);
+    delete manager;
+}
+
+class tst_Thread2 : public QThread
+{
+    Q_OBJECT
+public:
+
+    typedef Qt3D::QResourcesManager<tst_ListResource,
+                            int,
+                            16,
+                            Qt3D::ListAllocatingPolicy,
+                            Qt3D::ObjectLevelLockingPolicy> Manager;
+
+    tst_Thread2(int releaseAbove = 7)
+        : QThread()
+        , m_releaseAbove(releaseAbove)
+    {
+    }
+
+    void setManager(Manager *manager)
+    {
+        m_manager = manager;
+    }
+
+    // QThread interface
+protected:
+    void run()
+    {
+        int i = 0;
+        int max = tHandle::maxIndex();
+        while (i < max) {
+            tst_ListResource *r = m_manager->getOrCreateResource(i);
+            QVERIFY(r != Q_NULLPTR);
+            Manager::WriteLocker lock(m_manager);
+            r->m_value++;
+            if (r->m_value > m_releaseAbove)
+                m_manager->releaseResource(i);
+            i++;
+        }
+        qDebug() << QThread::currentThread() << "Done";
+    }
+
+    Manager *m_manager;
+    int m_releaseAbove;
+};
+
+void tst_ListResourcesManager::heavyDutyMultiThreadedAccessRelease()
+{
+    tst_Thread2::Manager *manager = new tst_Thread2::Manager();
+
+    QList<tst_Thread2 *> threads;
+
+    int iterations = 8;
+    int max = tHandle16::maxIndex();
+
+    for (int u = 0; u < 2; u++) {
+
+        for (int i = 0; i < iterations; i++) {
+            tst_Thread2 *thread = new tst_Thread2();
+            thread->setManager(manager);
+            threads << thread;
+        }
+
+        for (int i = 0; i < iterations; i++) {
+            threads[i]->start();
+        }
+
+        for (int i = 0; i < iterations; i++) {
+            threads[i]->wait();
+        }
+
+        for (int i = 0; i < max; i++) {
+            QVERIFY(manager->lookupResource(i) == Q_NULLPTR);
+        }
+
+        qDeleteAll(threads);
+        threads.clear();
+    }
+
+    delete manager;
+}
+
+void tst_ListResourcesManager::maximumNumberOfResources()
+{
+    Qt3D::QResourcesManager<tst_ListResource, uint, 16, Qt3D::ListAllocatingPolicy> manager;
+
+    QList<tst_ListResource *> resources;
+    QList<tHandle16> handles;
+
+    QCOMPARE(tHandle16::maxIndex(), (uint)manager.maxResourcesEntries());
+
+    for (int i = 0; i < manager.maxResourcesEntries(); i++) {
+        handles << manager.acquire();
+        resources << manager.data(handles.at(i));
+        resources.at(i)->m_value = 4;
+    }
+}
+
 QTEST_APPLESS_MAIN(tst_ListResourcesManager)
 
 #include "tst_listresourcesmanager.moc"