Run clang-format on all cpp/h files

NO_CHANGELOG

1 files changed, 56 insertions, 47 deletions

diff --git a/autotests/kconfig_compiler/kconfigcompiler_test_signals.cpp b/autotests/kconfig_compiler/kconfigcompiler_test_signals.cpp
index 3637b1ff..f493d35f 100644
--- a/autotests/kconfig_compiler/kconfigcompiler_test_signals.cpp
+++ b/autotests/kconfig_compiler/kconfigcompiler_test_signals.cpp
@@ -4,17 +4,17 @@
     SPDX-License-Identifier: MIT
 */
 
-#include "signals_test_singleton.h"
 #include "signals_test_no_singleton.h"
-#include "signals_test_singleton_dpointer.h"
 #include "signals_test_no_singleton_dpointer.h"
-#include <QtTestGui>
-#include <QSignalSpy>
-#include <QSharedPointer>
-#include <QtGlobal>
+#include "signals_test_singleton.h"
+#include "signals_test_singleton_dpointer.h"
 #include <QDebug>
-#include <QTemporaryFile>
 #include <QFileInfo>
+#include <QSharedPointer>
+#include <QSignalSpy>
+#include <QTemporaryFile>
+#include <QtGlobal>
+#include <QtTestGui>
 #include <functional>
 
 class KConfigCompiler_Test_Signals : public QObject
@@ -29,17 +29,17 @@ private Q_SLOTS:
     void cleanupTestCase();
 };
 
-static SignalsTestNoSingleton* noSingleton;
-static SignalsTestNoSingletonDpointer* noSingletonDpointer;
+static SignalsTestNoSingleton *noSingleton;
+static SignalsTestNoSingletonDpointer *noSingletonDpointer;
 
 void KConfigCompiler_Test_Signals::initTestCase()
 {
     // These tests do a lot quite a few I/O operations, speed that up by using a QTemporaryFile.
     // At least on Linux this is often a tmpfs which means only RAM operations
-    QTemporaryFile* tempFile1 = new QTemporaryFile(this);
-    QTemporaryFile* tempFile2 = new QTemporaryFile(this);
-    QTemporaryFile* tempFile3 = new QTemporaryFile(this);
-    QTemporaryFile* tempFile4 = new QTemporaryFile(this);
+    QTemporaryFile *tempFile1 = new QTemporaryFile(this);
+    QTemporaryFile *tempFile2 = new QTemporaryFile(this);
+    QTemporaryFile *tempFile3 = new QTemporaryFile(this);
+    QTemporaryFile *tempFile4 = new QTemporaryFile(this);
     QVERIFY(tempFile1->open());
     QVERIFY(tempFile2->open());
     QVERIFY(tempFile3->open());
@@ -47,15 +47,13 @@ void KConfigCompiler_Test_Signals::initTestCase()
 
     SignalsTestSingleton::instance(QFileInfo(*tempFile1).absoluteFilePath());
     SignalsTestSingletonDpointer::instance(QFileInfo(*tempFile2).absoluteFilePath());
-    noSingleton = new SignalsTestNoSingleton(
-                KSharedConfig::openConfig(QFileInfo(*tempFile3).absoluteFilePath(), KConfig::SimpleConfig));
-    noSingletonDpointer = new SignalsTestNoSingletonDpointer(
-                KSharedConfig::openConfig(QFileInfo(*tempFile4).absoluteFilePath(), KConfig::SimpleConfig));
+    noSingleton = new SignalsTestNoSingleton(KSharedConfig::openConfig(QFileInfo(*tempFile3).absoluteFilePath(), KConfig::SimpleConfig));
+    noSingletonDpointer = new SignalsTestNoSingletonDpointer(KSharedConfig::openConfig(QFileInfo(*tempFile4).absoluteFilePath(), KConfig::SimpleConfig));
 }
 
 void KConfigCompiler_Test_Signals::cleanupTestCase()
 {
-    //ensure these instances are deleted before the temporary files are closed
+    // ensure these instances are deleted before the temporary files are closed
     delete noSingleton;
     delete noSingletonDpointer;
     delete SignalsTestSingleton::self();
@@ -64,18 +62,29 @@ void KConfigCompiler_Test_Signals::cleanupTestCase()
 
 struct TestSettersArg {
     // default constructor required for Q_DECLARE_METATYPE
-    TestSettersArg() : obj(nullptr) {}
+    TestSettersArg()
+        : obj(nullptr)
+    {
+    }
     template<typename T>
-    TestSettersArg(T* object) : obj(object) {
+    TestSettersArg(T *object)
+        : obj(object)
+    {
         // we can also call static methods using object->foo() so this works for all four cases
-        getter = [object]() { return object->foo(); };
-        defaultGetter = [object]() { return object->defaultFooValue(); };
-        setter = [object](const QString& s) { object->setFoo(s); };
+        getter = [object]() {
+            return object->foo();
+        };
+        defaultGetter = [object]() {
+            return object->defaultFooValue();
+        };
+        setter = [object](const QString &s) {
+            object->setFoo(s);
+        };
     }
-    KCoreConfigSkeleton* obj;
+    KCoreConfigSkeleton *obj;
     std::function<QString()> getter;
     std::function<QString()> defaultGetter;
-    std::function<void(const QString&)> setter;
+    std::function<void(const QString &)> setter;
 };
 
 Q_DECLARE_METATYPE(TestSettersArg) // so that QFETCH works
@@ -93,7 +102,7 @@ void KConfigCompiler_Test_Signals::testSetters_data()
 void KConfigCompiler_Test_Signals::testSetters()
 {
     QFETCH(TestSettersArg, params);
-    const char* signal = SIGNAL(fooChanged(QString));
+    const char *signal = SIGNAL(fooChanged(QString));
     const QString defaultValue = QStringLiteral("default");
     const QString changedValue = QStringLiteral("changed");
 
@@ -105,21 +114,21 @@ void KConfigCompiler_Test_Signals::testSetters()
     QSignalSpy spy(params.obj, signal);
     QVERIFY2(spy.isValid(), signal);
 
-    //change value via setter, should get signal
+    // change value via setter, should get signal
     QCOMPARE(params.getter(), defaultValue);
     QCOMPARE(defaultValue, params.defaultGetter());
     QCOMPARE(params.getter(), params.defaultGetter());
     QVERIFY(changedValue != params.getter());
     params.setter(changedValue);
     QCOMPARE(params.getter(), changedValue);
-    QCOMPARE(spy.count(), 0); //should have no change yet, only after save()
+    QCOMPARE(spy.count(), 0); // should have no change yet, only after save()
     params.obj->save();
     QCOMPARE(spy.count(), 1);
     args = spy.takeFirst();
     QCOMPARE(args.size(), 1);
     QCOMPARE(args[0].toString(), changedValue);
 
-    //reset to default values via setDefaults()
+    // reset to default values via setDefaults()
     QVERIFY(params.getter() != params.defaultGetter());
     QVERIFY(params.getter() != defaultValue);
     QCOMPARE(params.getter(), changedValue);
@@ -127,67 +136,67 @@ void KConfigCompiler_Test_Signals::testSetters()
     QCOMPARE(params.getter(), params.defaultGetter());
     QCOMPARE(params.getter(), defaultValue);
 
-    QCOMPARE(spy.count(), 0); //should have no change yet, only after save()
+    QCOMPARE(spy.count(), 0); // should have no change yet, only after save()
     params.obj->save();
-    //TODO: This currently fails since setDefaults() does not yet cause emitting a signal
+    // TODO: This currently fails since setDefaults() does not yet cause emitting a signal
     QCOMPARE(spy.count(), 1);
     args = spy.takeFirst();
     QCOMPARE(args.size(), 1);
     QCOMPARE(args[0].value<QString>(), defaultValue);
 }
 
-Q_DECLARE_METATYPE(KCoreConfigSkeleton*)
+Q_DECLARE_METATYPE(KCoreConfigSkeleton *)
 
 void KConfigCompiler_Test_Signals::testSetProperty_data()
 {
-    QTest::addColumn<KCoreConfigSkeleton*>("obj");
-    QTest::newRow("singleton") << static_cast<KCoreConfigSkeleton*>(SignalsTestSingleton::self());
-    QTest::newRow("singleton dpointer") << static_cast<KCoreConfigSkeleton*>(SignalsTestSingletonDpointer::self());
-    QTest::newRow("non-singleton") << static_cast<KCoreConfigSkeleton*>(noSingleton);
-    QTest::newRow("non-singleton dpointer") << static_cast<KCoreConfigSkeleton*>(noSingletonDpointer);
+    QTest::addColumn<KCoreConfigSkeleton *>("obj");
+    QTest::newRow("singleton") << static_cast<KCoreConfigSkeleton *>(SignalsTestSingleton::self());
+    QTest::newRow("singleton dpointer") << static_cast<KCoreConfigSkeleton *>(SignalsTestSingletonDpointer::self());
+    QTest::newRow("non-singleton") << static_cast<KCoreConfigSkeleton *>(noSingleton);
+    QTest::newRow("non-singleton dpointer") << static_cast<KCoreConfigSkeleton *>(noSingletonDpointer);
 }
 
 /** Test that the signal is emitted when modifying the values using the underlying KConfigSkeletonItem (bypassing the setters) */
 void KConfigCompiler_Test_Signals::testSetProperty()
 {
-    QFETCH(KCoreConfigSkeleton*, obj);
-    const char* signal = SIGNAL(fooChanged(QString));
+    QFETCH(KCoreConfigSkeleton *, obj);
+    const char *signal = SIGNAL(fooChanged(QString));
     const QString propertyName = QStringLiteral("foo");
     const QString defaultValue = QStringLiteral("default");
     const QString newValue = QStringLiteral("changed");
     obj->setDefaults();
     obj->save();
 
-    KConfigSkeletonItem* item = obj->findItem(propertyName);
+    KConfigSkeletonItem *item = obj->findItem(propertyName);
     QVERIFY2(item, "Item must exist");
     QVERIFY2(!item->isImmutable(), "Item must not be immutable");
     QVERIFY2(!obj->isImmutable(propertyName), "Item must not be immutable");
 
-    //listen for all expected signals
+    // listen for all expected signals
     QSignalSpy spy(obj, signal);
     QVERIFY2(spy.isValid(), signal);
 
     QVERIFY(item->isEqual(defaultValue));
     QVERIFY(!item->isEqual(newValue));
 
-    item->setProperty(newValue); //change value now
-    //should have no change yet, only after save()
+    item->setProperty(newValue); // change value now
+    // should have no change yet, only after save()
     QCOMPARE(spy.count(), 0);
     obj->save();
-    //now check for the signal emissions
+    // now check for the signal emissions
     QCOMPARE(spy.count(), 1);
     QList<QVariant> args = spy.takeFirst();
     QCOMPARE(args.size(), 1);
     QVERIFY(item->isEqual(args[0]));
 
-    //now reset to default
+    // now reset to default
     QVERIFY(!item->isEqual(defaultValue));
     item->setDefault();
     QVERIFY(item->isEqual(defaultValue));
-    //should have no change yet, only after save()
+    // should have no change yet, only after save()
     QCOMPARE(spy.count(), 0);
     obj->save();
-    //now check for the signal emissions
+    // now check for the signal emissions
     QCOMPARE(spy.count(), 1);
     args = spy.takeFirst();
     QCOMPARE(args.size(), 1);