////  Created by Dale Glass on 2022/10/22//  Copyright 2022 Overte e.V.////  Distributed under the Apache License, Version 2.0.//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html//  #include "SettingsTests.h" #include <QtTest/QtTest>#include <SettingHandle.h>#include <SettingManager.h>#include <DependencyManager.h>#include <QDebug>#include <QCoreApplication>#include "SettingInterface.h"#include "SettingHandle.h"   QTEST_MAIN(SettingsTests) void SettingsTestsWorker::saveSettings() {    auto sm = DependencyManager::get<Setting::Manager>();    QThread *thread = QThread::currentThread();     while(! thread->isInterruptionRequested() ) {        //qDebug() << "Thread is saving config";        sm->forceSave();         // Not having any wait here for some reason locks up the benchmark.        // Logging a message also does the trick.        //        // This looks like a bug somewhere and needs investigating.        thread->yieldCurrentThread();    }     thread->exit(0);} void SettingsTests::initTestCase() {    QCoreApplication::setOrganizationName("OverteTest");     DependencyManager::set<Setting::Manager>();     Setting::init();} void SettingsTests::cleanupTestCase() {  //  Setting::cleanupSettingsSaveThread();} void SettingsTests::loadSettings() {    Settings s;    qDebug() << "Loaded" << s.fileName();} void SettingsTests::saveSettings() {    Settings s;    s.setValue("TestValue", "Hello");     auto sm = DependencyManager::get<Setting::Manager>();    sm->setValue("TestValueSM", "Hello");     // There seems to be a bug here, data gets lost without this call here.    sm->forceSave();    qDebug() << "Wrote" << s.fileName();} void SettingsTests::testSettings() {    auto sm = DependencyManager::get<Setting::Manager>();    Settings s;     s.setValue("settingsTest", 1);    QVERIFY(sm->value("settingsTest") == 1);     QVERIFY(!sm->contains("nonExistingKey"));    QVERIFY(sm->value("nonExistingKey") == QVariant()); } void SettingsTests::testGroups() {    auto sm = DependencyManager::get<Setting::Manager>();    Settings s;     s.setValue("valueNotInGroupBefore", 1);    s.beginGroup("testGroup");    s.setValue("valueInGroup", 2);    s.endGroup();     s.beginGroup("testGroupFirst");    s.beginGroup("testGroupSecond");    s.setValue("valueInGroup", 44);    s.endGroup();    s.endGroup();     s.setValue("valueNotInGroupAfter", 3);     QVERIFY(sm->value("valueNotInGroupBefore") == 1);    QVERIFY(sm->value("testGroup/valueInGroup") == 2);    QVERIFY(sm->value("testGroupFirst/testGroupSecond/valueInGroup") == 44);    QVERIFY(sm->value("valueNotInGroupAfter") == 3);} void SettingsTests::testArray() {    auto sm = DependencyManager::get<Setting::Manager>();    Settings s;     s.beginWriteArray("testArray", 2);    s.setValue("A", 1);    s.setValue("B", 2);    s.setArrayIndex(1);    s.setValue("A", 11);    s.setValue("B", 22);    s.endArray();     s.setValue("valueNotInArray", 6);     QVERIFY(sm->value("testArray/size") == 2);    QVERIFY(sm->value("testArray/1/A") == 1);    QVERIFY(sm->value("testArray/1/B") == 2);    QVERIFY(sm->value("testArray/2/A") == 11);    QVERIFY(sm->value("testArray/2/B") == 22);    QVERIFY(sm->value("valueNotInArray") == 6);} void SettingsTests::testArrayInGroup() {    auto sm = DependencyManager::get<Setting::Manager>();    Settings s;     s.beginGroup("groupWithArray");    s.beginWriteArray("arrayInGroup", 2);    s.setValue("X", 10);    s.setArrayIndex(1);    s.setValue("X", 20);    s.endArray();    s.endGroup();     s.setValue("valueNotInArrayOrGroup", 8);     QVERIFY(sm->value("groupWithArray/arrayInGroup/size") == 2);    QVERIFY(sm->value("groupWithArray/arrayInGroup/1/X") == 10);    QVERIFY(sm->value("groupWithArray/arrayInGroup/2/X") == 20);    QVERIFY(sm->value("valueNotInArrayOrGroup") == 8);} void SettingsTests::testHandleUnused() {     {        Setting::Handle<int> testHandle("unused_handle", -1);    }} void SettingsTests::testHandle() {    auto sm = DependencyManager::get<Setting::Manager>();    Setting::Handle<int> testHandle("integer_value", -1);     QVERIFY(!testHandle.isSet());    QVERIFY(testHandle.get() == -1);    QVERIFY(testHandle.get(-5) == -5);    QVERIFY(testHandle.getDefault() == -1);     testHandle.set(42);    QVERIFY(testHandle.get() == 42);    QVERIFY(testHandle.isSet());    QVERIFY(sm->value("integer_value") == 42);     testHandle.reset();    QVERIFY(testHandle.get() == -1);    QVERIFY(testHandle.isSet());    QVERIFY(sm->value("integer_value") == -1);     testHandle.remove();    QVERIFY(!testHandle.isSet());}  void SettingsTests::benchmarkSetValue() {    auto sm = DependencyManager::get<Setting::Manager>();    int i = 0;     QBENCHMARK {        sm->setValue("BenchmarkSetValue", ++i);    } }  void SettingsTests::benchmarkSaveSettings() {    auto sm = DependencyManager::get<Setting::Manager>();    int i = 0;     QBENCHMARK {        sm->setValue("BenchmarkSave", ++i);        sm->forceSave();    } }  void SettingsTests::benchmarkSetValueConcurrent() {    auto sm = DependencyManager::get<Setting::Manager>();    int i = 0;     _settingsThread = new QThread(qApp);    _testWorker = new SettingsTestsWorker();     _settingsThread->setObjectName("Save thread");    _testWorker->moveToThread(_settingsThread);     QObject::connect(_settingsThread, &QThread::started, _testWorker, &SettingsTestsWorker::saveSettings, Qt::QueuedConnection );     _settingsThread->start();    QBENCHMARK {        sm->setValue("BenchmarkSetValueConcurrent", ++i);    }     _settingsThread->requestInterruption();    _settingsThread->wait();     delete _testWorker;    delete _settingsThread;}